2003-07-07 Moritz Schulte <moritz@g10code.com>
authorMoritz Schulte <mo@g10code.com>
Mon, 7 Jul 2003 16:21:36 +0000 (16:21 +0000)
committerMoritz Schulte <mo@g10code.com>
Mon, 7 Jul 2003 16:21:36 +0000 (16:21 +0000)
* ac.c (gcry_ac_data_set): Only release old MPI value if it is
different from the new value.

* pubkey.c (gcry_pk_list): New function.
* md.c (gcry_md_list): New function.

* ac.c (gcry_ac_key_pair_generate): Fix calculation of format
string size.

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

* md.c: Named struct of digest_table `digest_table_entry'.
(digest_table_entry): New member: algorithm; filled in.
(digest_table_entry): Removed unused member: flags.
(gcry_md_register): New argument: algorithm_id, filled in.
(gcry_md_register_default): Used algorithm ID from module
structure.
(gcry_md_map_name): Likewise.
(md_enable): Likewise.
(md_read): Likewise.
(gcry_md_info): Likewise.

* pubkey.c: Named truct for pubkey_table `pubkey_table_entry'.
(pubkey_table_entry): New member: algorithm; filled in.
(gcry_pk_register_default): Used algorithm ID from pubkey_table.
(gcry_pk_register): New argument: algorithm_id, filled in.
(gcry_pk_map_name): Used algorithm ID from module structure.
(gcry_pk_decrypt): Likewise.
(gcry_pk_encrypt): Likewise.
(gcry_pk_verify): Likewise.
(gcry_pk_sign): Likewise.
(gcry_pk_testkey): Likewise.
(gcry_pk_genkey): Likewise.
(gcry_pk_get_nbits): Likewise.
(sexp_to_key): Removed unused variable: algo.
(sexp_to_sig): Likewise.

* cipher.c: Named struct for cipher_table `cipher_table_entry'.
(cipher_table_entry): New member: algorithm; filled in.
(gcry_cipher_register_default): Used algorithm ID from
cipher_table.
(gcry_cipher_register): New argument: algorithm_id, filled in.
(gcry_cipher_map_name): Used algorithm ID from module structure.

* arcfour.c (cipher_spec_arcfour): Removed algorithm ID.
* blowfish.c (cipher_spec_blowfish): Likewise.
* cast5.c (cipher_spec_cast5): Likewise.
* crc.c (digest_spec_crc32): Likewise.
* crc.c (digest_spec_crc32_rfc1510): Likewise.
* crc.c (digest_spec_crc32_rfc2440): Likewise.
* des.c (cipher_spec_des): Likewise.
* des.c (cipher_spec_tripledes): Likewise.
* dsa.c (pubkey_spec_dsa): Likewise.
* elgamal.c (pubkey_spec_elg): Likewise.
* md4.c (digest_spec_md4): Likewise.
* md5.c (digest_spec_md5): Likewise.
* aes.c (cipher_spec_aes): Likewise.
* aes.c (cipher_spec_aes192): Likewise.
* aes.c (cipher_spec_aes256): Likewise.
* rsa.c (pubkey_spec_rsa): Likewise.
* sha1.c (digest_spec_sha1): Likewise.
* sha256.c (digest_spec_sha256): Likewise.
* sha512.c (digest_spec_sha512): Likewise.
* tiger.c (digest_spec_tiger): Likewise.
* twofish.c (cipher_spec_twofish): Likewise.
* twofish.c (cipher_spec_twofish128): Likewise.

* Makefile.am (EXTRA_libcipher_la_SOURCES): Fix list of source
files; reported by Simon Josefsson <jas@extundo.com>.

* pubkey.c: Replaced all occurences of `id' with `algorithm',
since `id' is a keyword in obj-c.
* md.c: Likewise.
* cipher.c: Likewise.

* crc.c, md4.c, md5.c, rmd160.c, sha1.c, sha256.c, tiger.c:
Replaced all occurences of gcry_digest_spec_t with gcry_md_spec_t.

* dsa.c, rsa.c, elgamal.c: Replaced all occurencens of
gcry_pubkey_spec_t with gcry_pk_spec_t.

* md.c: Replaced all occurences of gcry_digest_spec_t with
gcry_md_spec_t.
(gcry_digest_register_default): Renamed to ...
(gcry_md_register_default): ... this; adjusted callers.
(gcry_digest_lookup_func_name): Renamed to ...
(gcry_md_lookup_func_name): ... this; adjusted callers.
(gcry_digest_lookup_name): Renamed to ...
(gcry_md_lookup_name): ... this; adjusted callers.
(gcry_digest_register): Renamed to ...
(gcry_md_register): ... this.
(gcry_digest_unregister): Renamed to ...
(gcry_md_unregister): ... this.

* pubkey.c (gcry_pubkey_register): Renamed to ...
(gcry_pk_register): ... this.
(gcry_pubkey_unregister): Renamed to ...
(gcry_pk_unregister): ... this.
Replaced all occurences of gcry_pubkey_spec_t with gcry_pk_spec_t.
(gcry_pubkey_register_default): Renamed to ...
(gcry_pk_register_default): ... this; adjusted callers.
(gcry_pubkey_lookup_func_name): Renamed to ...
(gcry_pk_lookup_func_name): ... this; adjusted callers.
(gcry_pubkey_lookup_name): Renamed to ...
(gcry_pk_lookup_name): ... this; adjusted callers.

* md.c (gcry_md_hash_buffer): Fix error checking.  Thanks to Simon
Josefsson <jas@extunde.com>.

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

* cipher.c (gcry_cipher_list): New function.

23 files changed:
cipher/ChangeLog
cipher/Makefile.am
cipher/ac.c
cipher/arcfour.c
cipher/blowfish.c
cipher/cast5.c
cipher/cipher.c
cipher/crc.c
cipher/des.c
cipher/dsa.c
cipher/elgamal.c
cipher/md.c
cipher/md4.c
cipher/md5.c
cipher/pubkey.c
cipher/rijndael.c
cipher/rmd160.c
cipher/rsa.c
cipher/sha1.c
cipher/sha256.c
cipher/sha512.c
cipher/tiger.c
cipher/twofish.c

index 72cf4f2..891c91a 100644 (file)
@@ -1,3 +1,134 @@
+2003-07-07  Moritz Schulte  <moritz@g10code.com>
+
+       * ac.c (gcry_ac_data_set): Only release old MPI value if it is
+       different from the new value.
+
+       * pubkey.c (gcry_pk_list): New function.
+       * md.c (gcry_md_list): New function.
+
+       * ac.c (gcry_ac_key_pair_generate): Fix calculation of format
+       string size.
+
+2003-07-05  Moritz Schulte  <moritz@g10code.com>
+
+       * md.c: Named struct of digest_table `digest_table_entry'.
+       (digest_table_entry): New member: algorithm; filled in.
+       (digest_table_entry): Removed unused member: flags.
+       (gcry_md_register): New argument: algorithm_id, filled in.
+       (gcry_md_register_default): Used algorithm ID from module
+       structure.
+       (gcry_md_map_name): Likewise.
+       (md_enable): Likewise.
+       (md_read): Likewise.
+       (gcry_md_info): Likewise.
+
+       * pubkey.c: Named truct for pubkey_table `pubkey_table_entry'.
+       (pubkey_table_entry): New member: algorithm; filled in.
+       (gcry_pk_register_default): Used algorithm ID from pubkey_table.
+       (gcry_pk_register): New argument: algorithm_id, filled in.
+       (gcry_pk_map_name): Used algorithm ID from module structure.
+       (gcry_pk_decrypt): Likewise.
+       (gcry_pk_encrypt): Likewise.
+       (gcry_pk_verify): Likewise.
+       (gcry_pk_sign): Likewise.
+       (gcry_pk_testkey): Likewise.
+       (gcry_pk_genkey): Likewise.
+       (gcry_pk_get_nbits): Likewise.
+       (sexp_to_key): Removed unused variable: algo.
+       (sexp_to_sig): Likewise.
+
+       * cipher.c: Named struct for cipher_table `cipher_table_entry'.
+       (cipher_table_entry): New member: algorithm; filled in.
+       (gcry_cipher_register_default): Used algorithm ID from
+       cipher_table.
+       (gcry_cipher_register): New argument: algorithm_id, filled in.
+       (gcry_cipher_map_name): Used algorithm ID from module structure.
+
+       * arcfour.c (cipher_spec_arcfour): Removed algorithm ID.
+       * blowfish.c (cipher_spec_blowfish): Likewise.
+       * cast5.c (cipher_spec_cast5): Likewise.
+       * crc.c (digest_spec_crc32): Likewise.
+       * crc.c (digest_spec_crc32_rfc1510): Likewise.
+       * crc.c (digest_spec_crc32_rfc2440): Likewise.
+       * des.c (cipher_spec_des): Likewise.
+       * des.c (cipher_spec_tripledes): Likewise.
+       * dsa.c (pubkey_spec_dsa): Likewise.
+       * elgamal.c (pubkey_spec_elg): Likewise.
+       * md4.c (digest_spec_md4): Likewise.
+       * md5.c (digest_spec_md5): Likewise.
+       * aes.c (cipher_spec_aes): Likewise.
+       * aes.c (cipher_spec_aes192): Likewise.
+       * aes.c (cipher_spec_aes256): Likewise.
+       * rsa.c (pubkey_spec_rsa): Likewise.
+       * sha1.c (digest_spec_sha1): Likewise.
+       * sha256.c (digest_spec_sha256): Likewise.
+       * sha512.c (digest_spec_sha512): Likewise.
+       * tiger.c (digest_spec_tiger): Likewise.
+       * twofish.c (cipher_spec_twofish): Likewise.
+       * twofish.c (cipher_spec_twofish128): Likewise.
+
+       * Makefile.am (EXTRA_libcipher_la_SOURCES): Fix list of source
+       files; reported by Simon Josefsson <jas@extundo.com>.
+
+       * pubkey.c: Replaced all occurences of `id' with `algorithm',
+       since `id' is a keyword in obj-c.
+       * md.c: Likewise.
+       * cipher.c: Likewise.
+
+       * crc.c, md4.c, md5.c, rmd160.c, sha1.c, sha256.c, tiger.c:
+       Replaced all occurences of gcry_digest_spec_t with gcry_md_spec_t.
+
+       * dsa.c, rsa.c, elgamal.c: Replaced all occurencens of
+       gcry_pubkey_spec_t with gcry_pk_spec_t.
+
+       * md.c: Replaced all occurences of gcry_digest_spec_t with
+       gcry_md_spec_t.
+       (gcry_digest_register_default): Renamed to ...
+       (gcry_md_register_default): ... this; adjusted callers.
+       (gcry_digest_lookup_func_name): Renamed to ...
+       (gcry_md_lookup_func_name): ... this; adjusted callers.
+       (gcry_digest_lookup_name): Renamed to ...
+       (gcry_md_lookup_name): ... this; adjusted callers.
+       (gcry_digest_register): Renamed to ...
+       (gcry_md_register): ... this.
+       (gcry_digest_unregister): Renamed to ...
+       (gcry_md_unregister): ... this.
+
+       * pubkey.c (gcry_pubkey_register): Renamed to ...
+       (gcry_pk_register): ... this.
+       (gcry_pubkey_unregister): Renamed to ...
+       (gcry_pk_unregister): ... this.
+       Replaced all occurences of gcry_pubkey_spec_t with gcry_pk_spec_t.
+       (gcry_pubkey_register_default): Renamed to ...
+       (gcry_pk_register_default): ... this; adjusted callers.
+       (gcry_pubkey_lookup_func_name): Renamed to ...
+       (gcry_pk_lookup_func_name): ... this; adjusted callers.
+       (gcry_pubkey_lookup_name): Renamed to ...
+       (gcry_pk_lookup_name): ... this; adjusted callers.
+
+       * md.c (gcry_md_hash_buffer): Fix error checking.  Thanks to Simon
+       Josefsson <jas@extunde.com>.
+
+2003-07-04  Moritz Schulte  <moritz@g10code.com>
+
+       * cipher.c (gcry_cipher_list): New function.
+
+2003-07-01  Moritz Schulte  <moritz@g10code.com>
+
+       * pubkey.c (sexp_to_sig): Accept a `flags' S-expression to be more
+       consistent with sexp_to_enc.
+
+2003-06-30  Moritz Schulte  <moritz@g10code.com>
+
+       * Makefile.am (libcipher_la_SOURCES): Added: ac.c.
+
+       * pubkey.c (_gcry_pk_module_lookup): New function.
+       (_gcry_pk_module_release): New function.
+
+2003-06-29  Moritz Schulte  <moritz@g10code.com>
+
+       * ac.c: New file.
+
 2003-06-18  Werner Koch  <wk@gnupg.org>
 
        * cipher.c (gcry_cipher_get_algo_keylen): New.
index ad6025b..8fb5a63 100644 (file)
@@ -49,10 +49,12 @@ md4.c \
 md5.c \
 rijndael.c \
 rmd160.c \
+rndlinux.c \
 rndegd.c \
-endunix.c \
-rndnw32.c \
+rndunix.c \
+rndw32.c \
 rsa.c \
+sha1.c \
 sha256.c \
 sha512.c \
 tiger.c \
index ad1574b..f35a733 100644 (file)
@@ -80,7 +80,7 @@ struct gcry_ac_handle
                                   handle.  */
   const char *algorithm_name;  /* Name of the algorithm.  */
   unsigned int flags;          /* Flags, not used yet.  */
-  gcry_module_t *module;       /* Reference to the algorithm
+  gcry_module_t module;                /* Reference to the algorithm
                                   module.  */
 };
 
@@ -472,7 +472,7 @@ gcry_ac_data_construct (const char *identifier, unsigned int flags,
  * Functions for working with data sets.
  */
 
-/* Returns a new, empty data set in DATA.  */
+/* Creates a new, empty data set and stores it in DATA.  */
 gpg_error_t
 gcry_ac_data_new (gcry_ac_data_t *data)
 {
@@ -493,7 +493,7 @@ gcry_ac_data_new (gcry_ac_data_t *data)
   return gpg_error (err);
 }
 
-/* Destroy the data set DATA.  */
+/* Destroys the data set DATA.  */
 void
 gcry_ac_data_destroy (gcry_ac_data_t data)
 {
@@ -508,8 +508,9 @@ gcry_ac_data_destroy (gcry_ac_data_t data)
   gcry_free (data);
 }
 
-/* Add the value MPI to DATA with the label NAME.  If there is already
-   a value with that label, replace it, otherwise add it.  */
+/* 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_ac_data_set (gcry_ac_data_t data,
                  const char *name, gcry_mpi_t mpi)
@@ -521,8 +522,11 @@ gcry_ac_data_set (gcry_ac_data_t data,
   if (ac_mpi)
     {
       /* An entry for NAME does already exist, replace it.  */
-      gcry_mpi_release (ac_mpi->mpi);
-      ac_mpi->mpi = mpi;
+      if (ac_mpi->mpi != mpi)
+       {
+         gcry_mpi_release (ac_mpi->mpi);
+         ac_mpi->mpi = mpi;
+       }
     }
   else
     {
@@ -552,7 +556,7 @@ gcry_ac_data_set (gcry_ac_data_t data,
   return gpg_error (err);
 }
 
-/* Return the number of named MPI values inside of the data set
+/* Returns the number of named MPI values inside of the data set
    DATA.  */
 unsigned int
 gcry_ac_data_length (gcry_ac_data_t data)
@@ -560,8 +564,10 @@ gcry_ac_data_length (gcry_ac_data_t data)
   return data->data_n;
 }
 
-/* Store the value labelled with NAME found in DATA in MPI or NULL if
-   a value with that label was not found.  */
+/* Stores the value labelled with NAME found in the data set DATA in
+   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_ac_data_get_name (gcry_ac_data_t data, const char *name,
                       gcry_mpi_t *mpi)
@@ -583,8 +589,10 @@ gcry_ac_data_get_name (gcry_ac_data_t data, const char *name,
   return gpg_error (err);
 }
 
-/* Return the MPI value with index INDEX contained in the data set
-   DATA.  */
+/* 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_ac_data_get_index (gcry_ac_data_t data, unsigned int index,
                        const char **name, gcry_mpi_t *mpi)
@@ -604,7 +612,7 @@ gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int index,
   return gpg_error (err);
 }
 
-/* Destroy any values contained in the data set DATA.  */
+/* Destroys any values contained in the data set DATA.  */
 void
 gcry_ac_data_clear (gcry_ac_data_t data)
 {
@@ -619,13 +627,14 @@ gcry_ac_data_clear (gcry_ac_data_t data)
  * Handle management.
  */
 
-/* Create a new ac handle.  */
+/* Creates a new handle for the algorithm ALGORITHM and store it in
+   HANDLE.  FLAGS is not used yet.  */
 gpg_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_module_t *module = NULL;
+  gcry_module_t module = NULL;
   gcry_ac_handle_t handle_new;
   const char *algorithm_name;
 
@@ -665,7 +674,7 @@ gcry_ac_open (gcry_ac_handle_t *handle,
   return gpg_error (err);
 }
 
-/* Destroy an ac handle.  */
+/* Destroys the handle HANDLE.  */
 void
 gcry_ac_close (gcry_ac_handle_t handle)
 {
@@ -680,7 +689,8 @@ gcry_ac_close (gcry_ac_handle_t handle)
  * Key management.
  */
 
-/* Initialize a key from a given data set.  */
+/* 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_ac_key_init (gcry_ac_key_t *key,
                  gcry_ac_handle_t handle,
@@ -726,7 +736,10 @@ gcry_ac_key_init (gcry_ac_key_t *key,
   return gpg_error (err);
 }
 
-/* Generate a new key pair.  */
+/* 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_ac_key_pair_generate (gcry_ac_handle_t handle,
                           gcry_ac_key_pair_t *key_pair,
@@ -776,13 +789,13 @@ gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
     {
       /* Calculate size of the format string, that is used for
         creating the request S-expression.  */
-      genkey_format_n = 22;
+      genkey_format_n = 23;
 
       /* Respect any relevant algorithm specific commands.  */
       if (key_spec)
        for (i = 0; gcry_ac_key_generate_specs[i].algorithm; i++)
          if (handle->algorithm == gcry_ac_key_generate_specs[i].algorithm)
-           genkey_format_n += 4;
+           genkey_format_n += 6;
 
       /* Create format string.  */
       genkey_format = gcry_malloc (genkey_format_n);
@@ -908,7 +921,7 @@ gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
   return gpg_error (err);
 }
 
-/* Returns a specified key from a key pair.  */
+/* Returns the key of type WHICH out of the key pair KEY_PAIR.  */
 gcry_ac_key_t
 gcry_ac_key_pair_extract (gcry_ac_key_pair_t key_pair,
                          gcry_ac_key_type_t witch)
@@ -929,7 +942,7 @@ gcry_ac_key_pair_extract (gcry_ac_key_pair_t key_pair,
   return key;
 }
 
-/* Destroy a key.  */
+/* Destroys the key KEY.  */
 void
 gcry_ac_key_destroy (gcry_ac_key_t key)
 {
@@ -947,7 +960,7 @@ gcry_ac_key_destroy (gcry_ac_key_t key)
   gcry_free (key);
 }
 
-/* Destroy a key pair.  */
+/* Destroys the key pair KEY_PAIR.  */
 void
 gcry_ac_key_pair_destroy (gcry_ac_key_pair_t key_pair)
 {
@@ -956,7 +969,7 @@ gcry_ac_key_pair_destroy (gcry_ac_key_pair_t key_pair)
   gcry_free (key_pair);
 }
 
-/* Verify that the key KEY is sane.  */
+/* Verifies that the key KEY is sane.  */
 gpg_error_t
 gcry_ac_key_test (gcry_ac_key_t key)
 {
@@ -967,7 +980,7 @@ gcry_ac_key_test (gcry_ac_key_t key)
   return gpg_error (err);
 }
 
-/* Return the number of bits of the key KEY in NBITS.  */
+/* Stores the number of bits of the key KEY in NBITS.  */
 gpg_error_t
 gcry_ac_key_get_nbits (gcry_ac_key_t key, unsigned int *nbits)
 {
@@ -983,7 +996,7 @@ gcry_ac_key_get_nbits (gcry_ac_key_t key, unsigned int *nbits)
   return gpg_error (err);
 }
 
-/* Write the 20 byte long key grip of the key KEY to KEY_GRIP.  */
+/* Writes the 20 byte long key grip of the key KEY to KEY_GRIP.  */
 gpg_error_t
 gcry_ac_key_get_grip (gcry_ac_key_t key, unsigned char *key_grip)
 {
@@ -1003,9 +1016,9 @@ gcry_ac_key_get_grip (gcry_ac_key_t key, unsigned char *key_grip)
  * Functions performing cryptographic operations.
  */
 
-/* Encrypt the plain text MPI value DATA_PLAIN with the key KEY under
-   the control of the flags FLAGS and store the resulting data set
-   into DATA_ENCRYPTED.  */
+/* 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_ac_data_encrypt (gcry_ac_handle_t handle,
                      unsigned int flags,
@@ -1081,9 +1094,10 @@ gcry_ac_data_encrypt (gcry_ac_handle_t handle,
   return gpg_error (err);
 }
 
-/* Decrypt the decrypted data contained in the data set DATA_ENCRYPTED
-   with the key KEY under the control of the flags FLAGS and store the
-   resulting plain text MPI value in DATA_PLAIN.  */
+/* 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_ac_data_decrypt (gcry_ac_handle_t handle,
                      unsigned int flags,
@@ -1143,8 +1157,8 @@ gcry_ac_data_decrypt (gcry_ac_handle_t handle,
 
 }
 
-/* Sign the data contained in DATA with the key KEY and store the
-   resulting signature in the data set DATA_SIGNATURE.  */
+/* 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_ac_data_sign (gcry_ac_handle_t handle,
                   gcry_ac_key_t key,
@@ -1185,9 +1199,9 @@ gcry_ac_data_sign (gcry_ac_handle_t handle,
   return gpg_error (err);
 }
 
-/* Verify 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.  */
+/* 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_ac_data_verify (gcry_ac_handle_t handle,
                     gcry_ac_key_t key,
@@ -1231,8 +1245,8 @@ gcry_ac_data_verify (gcry_ac_handle_t handle,
  * General functions.
  */
 
-/* Store the textual representation of the algorithm whose id is given
-   in ALGORITHM in NAME.  */
+/* Stores the textual representation of the algorithm whose id is
+   given in ALGORITHM in NAME.  */
 gpg_error_t
 gcry_ac_id_to_name (gcry_ac_id_t algorithm, const char **name)
 {
@@ -1248,7 +1262,7 @@ gcry_ac_id_to_name (gcry_ac_id_t algorithm, const char **name)
   return gpg_error (err);
 }
 
-/* Store the numeric ID of the algorithm whose textual representation
+/* Stores the numeric ID of the algorithm whose textual representation
    is contained in NAME in ALGORITHM.  */
 gpg_error_t
 gcry_ac_name_to_id (const char *name, gcry_ac_id_t *algorithm)
index 90d6698..2e3bf22 100644 (file)
@@ -149,6 +149,6 @@ selftest(void)
 
 gcry_cipher_spec_t cipher_spec_arcfour =
   {
-    "ARCFOUR", GCRY_CIPHER_ARCFOUR, 1, 128, sizeof (ARCFOUR_context),
+    "ARCFOUR", 1, 128, sizeof (ARCFOUR_context),
     arcfour_setkey, NULL, NULL, encrypt_stream, encrypt_stream,
   };
index f5eb513..97909a5 100644 (file)
@@ -587,7 +587,7 @@ bf_setkey (void *context, const byte *key, unsigned keylen)
 
 gcry_cipher_spec_t cipher_spec_blowfish =
   {
-    "BLOWFISH", GCRY_CIPHER_BLOWFISH, BLOWFISH_BLOCKSIZE, 128,
+    "BLOWFISH", BLOWFISH_BLOCKSIZE, 128,
     sizeof (BLOWFISH_context),
     bf_setkey, encrypt_block, decrypt_block,
   };
index fb590d0..8c036d8 100644 (file)
@@ -616,6 +616,6 @@ cast_setkey (void *context, const byte *key, unsigned keylen )
 
 gcry_cipher_spec_t cipher_spec_cast5 =
   {
-    "CAST5", GCRY_CIPHER_CAST5, CAST5_BLOCKSIZE, 128, sizeof (CAST5_context),
+    "CAST5", CAST5_BLOCKSIZE, 128, sizeof (CAST5_context),
     cast_setkey, encrypt_block, decrypt_block,
   };
index 185ac9f..30cd4f0 100644 (file)
@@ -65,38 +65,39 @@ static struct
 
 /* This is the list of the default ciphers, which are included in
    libgcrypt.  */
-static struct
+static struct cipher_table_entry
 {
   gcry_cipher_spec_t *cipher;
+  unsigned int algorithm;
 } cipher_table[] =
   {
 #if USE_BLOWFISH
-    { &cipher_spec_blowfish,  },
+    { &cipher_spec_blowfish,   GCRY_CIPHER_BLOWFISH },
 #endif
 #if USE_DES
-    { &cipher_spec_des        },
-    { &cipher_spec_tripledes  },
+    { &cipher_spec_des,        GCRY_CIPHER_DES },
+    { &cipher_spec_tripledes,  GCRY_CIPHER_3DES },
 #endif
 #if USE_ARCFOUR
-    { &cipher_spec_arcfour    },
+    { &cipher_spec_arcfour,    GCRY_CIPHER_ARCFOUR },
 #endif
 #if USE_CAST5
-    { &cipher_spec_cast5      },
+    { &cipher_spec_cast5,      GCRY_CIPHER_CAST5 },
 #endif
 #if USE_AES
-    { &cipher_spec_aes        },
-    { &cipher_spec_aes192     },
-    { &cipher_spec_aes256     },
+    { &cipher_spec_aes,        GCRY_CIPHER_AES },
+    { &cipher_spec_aes192,     GCRY_CIPHER_AES192 },
+    { &cipher_spec_aes256,     GCRY_CIPHER_AES256 },
 #endif
 #if USE_TWOFISH
-    { &cipher_spec_twofish    },
-    { &cipher_spec_twofish128 },
+    { &cipher_spec_twofish,    GCRY_CIPHER_TWOFISH },
+    //    { &cipher_spec_twofish128, GCRY_CIPHER_TWOFISH128 },
 #endif
     { NULL                    },
   };
 
 /* List of registered ciphers.  */
-static gcry_module_t *ciphers_registered;
+static gcry_module_t ciphers_registered;
 
 /* This is the lock protecting CIPHERS_REGISTERED.  */
 static ath_mutex_t ciphers_registered_lock = ATH_MUTEX_INITIALIZER;
@@ -181,7 +182,7 @@ gcry_cipher_register_default (void)
        cipher_table[i].cipher->stdecrypt = dummy_decrypt_stream;
 
       err = _gcry_module_add (&ciphers_registered,
-                             cipher_table[i].cipher->id,
+                             cipher_table[i].algorithm,
                              (void *) cipher_table[i].cipher,
                              NULL);
     }
@@ -201,10 +202,10 @@ gcry_cipher_lookup_func_name (void *spec, void *data)
 }
 
 /* Internal function.  Lookup a cipher entry by it's name.  */
-static gcry_module_t *
+static gcry_module_t
 gcry_cipher_lookup_name (const char *name)
 {
-  gcry_module_t *cipher;
+  gcry_module_t cipher;
 
   cipher = _gcry_module_lookup (ciphers_registered, (void *) name,
                                gcry_cipher_lookup_func_name);
@@ -212,15 +213,16 @@ gcry_cipher_lookup_name (const char *name)
   return cipher;
 }
 
-/* Public function.  Register a provided CIPHER.  Returns zero on
-   success, in which case the chosen cipher ID has been stored in
-   CIPHER, or an error code.  */
+/* 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_cipher_register (gcry_cipher_spec_t *cipher,
-                     gcry_module_t **module)
+                     unsigned int *algorithm_id,
+                     gcry_module_t *module)
 {
   gpg_err_code_t err = 0;
-  gcry_module_t *mod;
+  gcry_module_t mod;
 
   ath_mutex_lock (&ciphers_registered_lock);
   err = _gcry_module_add (&ciphers_registered, 0,
@@ -230,16 +232,16 @@ gcry_cipher_register (gcry_cipher_spec_t *cipher,
   if (! err)
     {
       *module = mod;
-      cipher->id = mod->id;
+      *algorithm_id = mod->mod_id;
     }
 
   return gpg_error (err);
 }
 
-/* Public function.  Unregister the cipher identified by MODULE, which
-   must have been registered with gcry_cipher_register.  */
+/* Unregister the cipher identified by MODULE, which must have been
+   registered with gcry_cipher_register.  */
 void
-gcry_cipher_unregister (gcry_module_t *module)
+gcry_cipher_unregister (gcry_module_t module)
 {
   ath_mutex_lock (&ciphers_registered_lock);
   _gcry_module_release (module);
@@ -251,7 +253,7 @@ struct gcry_cipher_handle
 {
   int magic;
   gcry_cipher_spec_t *cipher;
-  gcry_module_t *module;
+  gcry_module_t module;
   int  mode;
   unsigned int flags;
   byte iv[MAX_BLOCKSIZE];      /* (this should be ulong aligned) */
@@ -292,8 +294,8 @@ search_oid (const char *string)
 int
 gcry_cipher_map_name( const char *string )
 {
-  gcry_module_t *cipher;
-  int i, id = 0;
+  gcry_module_t cipher;
+  int i, algorithm = 0;
   
   if (!string)
     return 0;
@@ -322,12 +324,12 @@ gcry_cipher_map_name( const char *string )
   cipher = gcry_cipher_lookup_name (string);
   if (cipher)
     {
-      id = ((gcry_cipher_spec_t *) cipher->spec)->id;
+      algorithm = cipher->mod_id;
       _gcry_module_release (cipher);
     }
   ath_mutex_unlock (&ciphers_registered_lock);
   
-  return id;
+  return algorithm;
 }
 
 int
@@ -344,15 +346,15 @@ gcry_cipher_mode_from_oid (const char *string)
  * Map a cipher algo to a string
  */
 static const char *
-cipher_algo_to_string (int id)
+cipher_algo_to_string (int algorithm)
 {
-  gcry_module_t *cipher;
+  gcry_module_t cipher;
   const char *name = NULL;
 
   REGISTER_DEFAULT_CIPHERS;
 
   ath_mutex_lock (&ciphers_registered_lock);
-  cipher = _gcry_module_lookup_id (ciphers_registered, id);
+  cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
   if (cipher)
     {
       name = ((gcry_cipher_spec_t *) cipher->spec)->name;
@@ -368,22 +370,22 @@ cipher_algo_to_string (int id)
  * string when there is no algo.  It will never return NULL.
  */
 const char *
-gcry_cipher_algo_name (int id)
+gcry_cipher_algo_name (int algorithm)
 {
-  const char *s = cipher_algo_to_string (id);
+  const char *s = cipher_algo_to_string (algorithm);
   return s ? s : "";
 }
 
 
 static void
-disable_cipher_algo (int id)
+disable_cipher_algo (int algorithm)
 {
-  gcry_module_t *cipher;
+  gcry_module_t cipher;
 
   REGISTER_DEFAULT_CIPHERS;
 
   ath_mutex_lock (&ciphers_registered_lock);
-  cipher = _gcry_module_lookup_id (ciphers_registered, id);
+  cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
   if (cipher)
     {
       if (! (cipher->flags & FLAG_MODULE_DISABLED))
@@ -399,15 +401,15 @@ disable_cipher_algo (int id)
  */
 
 static gpg_err_code_t
-check_cipher_algo (int id)
+check_cipher_algo (int algorithm)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
-  gcry_module_t *cipher;
+  gcry_module_t cipher;
 
   REGISTER_DEFAULT_CIPHERS;
 
   ath_mutex_lock (&ciphers_registered_lock);
-  cipher = _gcry_module_lookup_id (ciphers_registered, id);
+  cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
   if (cipher)
     {
       if (cipher->flags & FLAG_MODULE_DISABLED)
@@ -422,48 +424,48 @@ check_cipher_algo (int id)
 }
 
 static unsigned
-cipher_get_keylen (int id)
+cipher_get_keylen (int algorithm)
 {
-  gcry_module_t *cipher;
+  gcry_module_t cipher;
   unsigned len = 0;
 
   REGISTER_DEFAULT_CIPHERS;
 
   ath_mutex_lock (&ciphers_registered_lock);
-  cipher = _gcry_module_lookup_id (ciphers_registered, id);
+  cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
   if (cipher)
     {
       len = ((gcry_cipher_spec_t *) cipher->spec)->keylen;
       if (! len)
-       log_bug ("cipher %d w/o key length\n", id);
+       log_bug ("cipher %d w/o key length\n", algorithm);
       _gcry_module_release (cipher);
     }
   else
-    log_bug ("cipher %d not found\n", id);
+    log_bug ("cipher %d not found\n", algorithm);
   ath_mutex_unlock (&ciphers_registered_lock);
 
   return len;
 }
 
 static unsigned
-cipher_get_blocksize (int id)
+cipher_get_blocksize (int algorithm)
 {
-  gcry_module_t *cipher;
+  gcry_module_t cipher;
   unsigned len = 0;
 
   REGISTER_DEFAULT_CIPHERS;
 
   ath_mutex_lock (&ciphers_registered_lock);
-  cipher = _gcry_module_lookup_id (ciphers_registered, id);
+  cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
   if (cipher)
     {
       len = ((gcry_cipher_spec_t *) cipher->spec)->blocksize;
       if (! len)
-         log_bug ("cipher %d w/o blocksize\n", id);
+         log_bug ("cipher %d w/o blocksize\n", algorithm);
       _gcry_module_release (cipher);
     }
   else
-    log_bug ("cipher %d not found\n", id);
+    log_bug ("cipher %d not found\n", algorithm);
   ath_mutex_unlock (&ciphers_registered_lock);
 
   return len;
@@ -477,11 +479,11 @@ cipher_get_blocksize (int id)
 
 gpg_error_t
 gcry_cipher_open (gcry_cipher_hd_t *handle,
-                 int algo, int mode, unsigned int flags )
+                 int algo, int mode, unsigned int flags)
 {
   int secure = (flags & GCRY_CIPHER_SECURE);
   gcry_cipher_spec_t *cipher = NULL;
-  gcry_module_t *module = NULL;
+  gcry_module_t module = NULL;
   gcry_cipher_hd_t h = NULL;
   gpg_err_code_t err = 0;
 
@@ -1280,3 +1282,21 @@ _gcry_cipher_init (void)
 
   return err;
 }
+
+/* Get a list consisting of the IDs of the loaded cipher modules.  If
+   LIST is zero, write the number of loaded cipher modules to
+   LIST_LENGTH and return.  If LIST is non-zero, the first
+   *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_cipher_list (int *list, int *list_length)
+{
+  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+
+  ath_mutex_lock (&ciphers_registered_lock);
+  err = _gcry_module_list (ciphers_registered, list, list_length);
+  ath_mutex_unlock (&ciphers_registered_lock);
+
+  return err;
+}
index 70546c2..f2116c1 100644 (file)
@@ -271,24 +271,24 @@ crc24rfc2440_final (void *context)
   ctx->buf[2] = (ctx->CRC      ) & 0xFF;
 }
 
-gcry_digest_spec_t digest_spec_crc32 =
+gcry_md_spec_t digest_spec_crc32 =
   {
-    "CRC32", GCRY_MD_CRC32, NULL, 0, 4,
+    "CRC32", NULL, 0, 4,
     crc32_init, crc32_write, crc32_final, crc32_read,
     sizeof (CRC_CONTEXT)
   };
 
-gcry_digest_spec_t digest_spec_crc32_rfc1510 =
+gcry_md_spec_t digest_spec_crc32_rfc1510 =
   {
-    "CRC32RFC1510", GCRY_MD_CRC32_RFC1510, NULL, 0, 4,
+    "CRC32RFC1510", NULL, 0, 4,
     crc32rfc1510_init, crc32_write,
     crc32rfc1510_final, crc32_read,
     sizeof (CRC_CONTEXT)
   };
 
-gcry_digest_spec_t digest_spec_crc24_rfc2440 =
+gcry_md_spec_t digest_spec_crc24_rfc2440 =
   {
-    "CRC24RFC2440", GCRY_MD_CRC24_RFC2440, NULL, 0, 3,
+    "CRC24RFC2440", NULL, 0, 3,
     crc24rfc2440_init, crc24rfc2440_write,
     crc24rfc2440_final, crc32_read,
     sizeof (CRC_CONTEXT)
index 9a9555a..d9acaaf 100644 (file)
@@ -1068,12 +1068,12 @@ do_des_decrypt( void *context, byte *outbuf, const byte *inbuf )
 
 gcry_cipher_spec_t cipher_spec_des =
   {
-    "DES", GCRY_CIPHER_DES, 8, 64, sizeof (struct _des_ctx),
+    "DES", 8, 64, sizeof (struct _des_ctx),
     do_des_setkey, do_des_encrypt, do_des_decrypt
   };
 
 gcry_cipher_spec_t cipher_spec_tripledes =
   {
-    "3DES", GCRY_CIPHER_3DES, 8, 192, sizeof (struct _tripledes_ctx),
+    "3DES", 8, 192, sizeof (struct _tripledes_ctx),
     do_tripledes_setkey, do_tripledes_encrypt, do_tripledes_decrypt
   };
index c2a2e51..970002e 100644 (file)
@@ -456,9 +456,9 @@ static char *dsa_names[] =
     NULL,
   };
 
-gcry_pubkey_spec_t pubkey_spec_dsa =
+gcry_pk_spec_t pubkey_spec_dsa =
   {
-    "DSA", dsa_names, GCRY_PK_DSA,
+    "DSA", dsa_names, 
     "pqgy", "pqgyx", "", "rs", "pqgy",
     GCRY_PK_USAGE_SIGN,
     _gcry_dsa_generate,
index dee79da..e1b2074 100644 (file)
@@ -1,4 +1,4 @@
-/* elgamal.c  -  ElGamal Public Key encryption
+/* Elgamal.c  -  ElGamal Public Key encryption
  * Copyright (C) 1998, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
@@ -641,9 +641,9 @@ static char *elg_names[] =
   };
 
 
-gcry_pubkey_spec_t pubkey_spec_elg =
+gcry_pk_spec_t pubkey_spec_elg =
   {
-    "ELG", elg_names, GCRY_PK_ELG,
+    "ELG", elg_names,
     "pgy", "pgyx", "ab", "rs", "pgy",
     GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR,
     _gcry_elg_generate,
index 4872e49..82fe186 100644 (file)
@@ -60,44 +60,44 @@ static struct {
   {NULL}
 };
 
-static struct
+static struct digest_table_entry
 {
-  gcry_digest_spec_t *digest;
-  int flags;
+  gcry_md_spec_t *digest;
+  unsigned int algorithm;
 } digest_table[] =
   {
 #if USE_CRC    
-    { &digest_spec_crc32, 0 },
-    { &digest_spec_crc32_rfc1510, 0 },
-    { &digest_spec_crc24_rfc2440, 0 },
+    { &digest_spec_crc32, GCRY_MD_CRC32 },
+    { &digest_spec_crc32_rfc1510, GCRY_MD_CRC32_RFC1510 },
+    { &digest_spec_crc24_rfc2440, GCRY_MD_CRC24_RFC2440 },
 #endif
 #if USE_MD4
-    { &digest_spec_md4, 0 },
+    { &digest_spec_md4, GCRY_MD_MD4 },
 #endif
 #if USE_MD5
-    { &digest_spec_md5, 0 },
+    { &digest_spec_md5, GCRY_MD_MD5 },
 #endif
 #if USE_RMD160
-    { &digest_spec_rmd160, 0 },
+    { &digest_spec_rmd160, GCRY_MD_RMD160 },
 #endif
 #if USE_SHA1
-    { &digest_spec_sha1, 0 },
+    { &digest_spec_sha1, GCRY_MD_SHA1 },
 #endif
 #if USE_SHA256
-    { &digest_spec_sha256, 0 },
+    { &digest_spec_sha256, GCRY_MD_SHA256 },
 #endif
 #if USE_SHA512
-    { &digest_spec_sha512, 0 },
-    { &digest_spec_sha384, 0 },
+    { &digest_spec_sha512, GCRY_MD_SHA512 },
+    { &digest_spec_sha384, GCRY_MD_SHA384 },
 #endif
 #if USE_TIGER
-    { &digest_spec_tiger, 0 },
+    { &digest_spec_tiger, GCRY_MD_TIGER },
 #endif
     { NULL },
   };
 
 /* List of registered digests.  */
-static gcry_module_t *digests_registered;
+static gcry_module_t digests_registered;
 
 /* This is the lock protecting DIGESTS_REGISTERED.  */
 static ath_mutex_t digests_registered_lock = ATH_MUTEX_INITIALIZER;
@@ -113,7 +113,7 @@ static int default_digests_registered;
       ath_mutex_lock (&digests_registered_lock);   \
       if (! default_digests_registered)            \
         {                                          \
-          gcry_digest_register_default ();         \
+          gcry_md_register_default ();             \
           default_digests_registered = 1;          \
         }                                          \
       ath_mutex_unlock (&digests_registered_lock); \
@@ -123,14 +123,14 @@ static int default_digests_registered;
 /* Internal function.  Register all the ciphers included in
    CIPHER_TABLE.  Returns zero on success or an error code.  */
 static void
-gcry_digest_register_default (void)
+gcry_md_register_default (void)
 {
   gpg_err_code_t err = 0;
   int i;
   
   for (i = 0; (! err) && digest_table[i].digest; i++)
     err = _gcry_module_add (&digests_registered,
-                           digest_table[i].digest->id,
+                           digest_table[i].algorithm,
                            (void *) digest_table[i].digest,
                            NULL);
 
@@ -140,34 +140,36 @@ gcry_digest_register_default (void)
 
 /* Internal callback function.  */
 static int
-gcry_digest_lookup_func_name (void *spec, void *data)
+gcry_md_lookup_func_name (void *spec, void *data)
 {
-  gcry_digest_spec_t *digest = (gcry_digest_spec_t *) spec;
+  gcry_md_spec_t *digest = (gcry_md_spec_t *) spec;
   char *name = (char *) data;
 
   return (! stricmp (digest->name, name));
 }
 
 /* Internal function.  Lookup a digest entry by it's name.  */
-static gcry_module_t *
-gcry_digest_lookup_name (const char *name)
+static gcry_module_t 
+gcry_md_lookup_name (const char *name)
 {
-  gcry_module_t *digest;
+  gcry_module_t digest;
 
   digest = _gcry_module_lookup (digests_registered, (void *) name,
-                               gcry_digest_lookup_func_name);
+                               gcry_md_lookup_func_name);
 
   return digest;
 }
 
-/* Public function.  Register a provided DIGEST.  Returns zero on
-   success, in which case the chosen digest ID has been stored in
-   DIGEST, or an error code.  */
+/* 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_digest_register (gcry_digest_spec_t *digest, gcry_module_t **module)
+gcry_md_register (gcry_md_spec_t *digest,
+                 unsigned int *algorithm_id,
+                 gcry_module_t *module)
 {
   gpg_err_code_t err = 0;
-  gcry_module_t *mod;
+  gcry_module_t mod;
 
   ath_mutex_lock (&digests_registered_lock);
   err = _gcry_module_add (&digests_registered, 0,
@@ -177,16 +179,16 @@ gcry_digest_register (gcry_digest_spec_t *digest, gcry_module_t **module)
   if (! err)
     {
       *module = mod;
-      digest->id = mod->id;
+      *algorithm_id = mod->mod_id;
     }
 
   return gpg_error (err);
 }
 
-/* Public function.  Unregister the digest identified by ID, which
-   must have been registered with gcry_digest_register.  */
+/* Unregister the digest identified by ID, which must have been
+   registered with gcry_digest_register.  */
 void
-gcry_digest_unregister (gcry_module_t *module)
+gcry_md_unregister (gcry_module_t module)
 {
   ath_mutex_lock (&digests_registered_lock);
   _gcry_module_release (module);
@@ -195,8 +197,8 @@ gcry_digest_unregister (gcry_module_t *module)
 
 typedef struct gcry_md_list
 {
-  gcry_digest_spec_t *digest;
-  gcry_module_t *module;
+  gcry_md_spec_t *digest;
+  gcry_module_t module;
   struct gcry_md_list *next;
   PROPERLY_ALIGNED_TYPE context;
 } GcryDigestEntry;
@@ -237,8 +239,8 @@ static void md_stop_debug( gcry_md_hd_t a );
 int
 gcry_md_map_name (const char *string)
 {
-  gcry_module_t *digest;
-  int id = 0;
+  gcry_module_t digest;
+  int algorithm = 0;
 
   if (!string)
     return 0;
@@ -264,15 +266,15 @@ gcry_md_map_name (const char *string)
   REGISTER_DEFAULT_DIGESTS;
 
   ath_mutex_lock (&digests_registered_lock);
-  digest = gcry_digest_lookup_name (string);
+  digest = gcry_md_lookup_name (string);
   if (digest)
     {
-      id = ((gcry_digest_spec_t *) digest->spec)->id;
+      algorithm = digest->mod_id;
       _gcry_module_release (digest);
     }
   ath_mutex_unlock (&digests_registered_lock);
 
-  return id;
+  return algorithm;
 }
 
 
@@ -280,18 +282,18 @@ gcry_md_map_name (const char *string)
  * Map a digest algo to a string
  */
 static const char *
-digest_algo_to_string (int id)
+digest_algo_to_string (int algorithm)
 {
   const char *name = NULL;
-  gcry_module_t *digest;
+  gcry_module_t digest;
 
   REGISTER_DEFAULT_DIGESTS;
 
   ath_mutex_lock (&digests_registered_lock);
-  digest = _gcry_module_lookup_id (digests_registered, id);
+  digest = _gcry_module_lookup_id (digests_registered, algorithm);
   if (digest)
     {
-      name = ((gcry_digest_spec_t *) digest->spec)->name;
+      name = ((gcry_md_spec_t *) digest->spec)->name;
       _gcry_module_release (digest);
     }
   ath_mutex_unlock (&digests_registered_lock);
@@ -306,23 +308,23 @@ digest_algo_to_string (int id)
  * is valid.
  */
 const char *
-gcry_md_algo_name (int id)
+gcry_md_algo_name (int algorithm)
 {
-  const char *s = digest_algo_to_string (id);
+  const char *s = digest_algo_to_string (algorithm);
   return s ? s : "?";
 }
 
 
 static gpg_err_code_t
-check_digest_algo (int id)
+check_digest_algo (int algorithm)
 {
   gpg_err_code_t rc = 0;
-  gcry_module_t *digest;
+  gcry_module_t digest;
 
   REGISTER_DEFAULT_DIGESTS;
 
   ath_mutex_lock (&digests_registered_lock);
-  digest = _gcry_module_lookup_id (digests_registered, id);
+  digest = _gcry_module_lookup_id (digests_registered, algorithm);
   if (digest)
     _gcry_module_release (digest);
   else
@@ -443,30 +445,30 @@ gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
 
 
 static gpg_err_code_t
-md_enable (gcry_md_hd_t hd, int id)
+md_enable (gcry_md_hd_t hd, int algorithm)
 {
   struct gcry_md_context *h = hd->ctx;
-  gcry_digest_spec_t *digest = NULL;
+  gcry_md_spec_t *digest = NULL;
   GcryDigestEntry *entry;
-  gcry_module_t *module;
+  gcry_module_t module;
   gpg_err_code_t err = 0;
 
   for (entry = h->list; entry; entry = entry->next)
-    if (entry->digest->id == id)
+    if (entry->module->mod_id == algorithm)
       return err; /* already enabled */
 
   REGISTER_DEFAULT_DIGESTS;
 
   ath_mutex_lock (&digests_registered_lock);
-  module = _gcry_module_lookup_id (digests_registered, id);
+  module = _gcry_module_lookup_id (digests_registered, algorithm);
   ath_mutex_unlock (&digests_registered_lock);
   if (! module)
     {
-      log_debug ("md_enable: algorithm %d not available\n", id);
+      log_debug ("md_enable: algorithm %d not available\n", algorithm);
       err = GPG_ERR_DIGEST_ALGO;
     }
   else
-    digest = (gcry_digest_spec_t *) module->spec;
+    digest = (gcry_md_spec_t *) module->spec;
 
   if (! err)
     {
@@ -509,9 +511,9 @@ md_enable (gcry_md_hd_t hd, int id)
 
 
 gpg_error_t
-gcry_md_enable (gcry_md_hd_t hd, int id)
+gcry_md_enable (gcry_md_hd_t hd, int algorithm)
 {
-  gpg_err_code_t err = md_enable (hd, id);
+  gpg_err_code_t err = md_enable (hd, algorithm);
   return gpg_error (err);
 }
 
@@ -811,7 +813,7 @@ md_read( gcry_md_hd_t a, int algo )
   else
     {
       for (r = a->ctx->list; r; r = r->next)
-       if (r->digest->id == algo)
+       if (r->module->mod_id == algo)
          return (*r->digest->read) (&r->context.c);
     }
   BUG();
@@ -909,7 +911,7 @@ gcry_md_hash_buffer (int algo, void *digest, const void *buffer, size_t length)
         normal functions to do it */
       gcry_md_hd_t h;
       gpg_err_code_t err = md_open (&h, algo, 0, 0);
-      if(! err)
+      if (err)
        /* FIXME?  */
        BUG(); /* algo not available */
       md_write (h, (byte *) buffer, length);
@@ -926,7 +928,7 @@ md_get_algo (gcry_md_hd_t a)
 
   if (r && r->next)
     log_error("WARNING: more than algorithm in md_get_algo()\n");
-  return r ? r->digest->id : 0;
+  return r ? r->module->mod_id : 0;
 }
 
 int
@@ -940,18 +942,18 @@ gcry_md_get_algo (gcry_md_hd_t hd)
  * Return the length of the digest
  */
 static int
-md_digest_length (int id)
+md_digest_length (int algorithm)
 {
-  gcry_module_t *digest;
+  gcry_module_t digest;
   int mdlen = 0;
 
   REGISTER_DEFAULT_DIGESTS;
 
   ath_mutex_lock (&digests_registered_lock);
-  digest = _gcry_module_lookup_id (digests_registered, id);
+  digest = _gcry_module_lookup_id (digests_registered, algorithm);
   if (digest)
     {
-      mdlen = ((gcry_digest_spec_t *) digest->spec)->mdlen;
+      mdlen = ((gcry_md_spec_t *) digest->spec)->mdlen;
       _gcry_module_release (digest);
     }
   ath_mutex_unlock (&digests_registered_lock);
@@ -964,35 +966,35 @@ md_digest_length (int id)
  * This function will return 0 in case of errors.
  */
 unsigned int
-gcry_md_get_algo_dlen (int id)
+gcry_md_get_algo_dlen (int algorithm)
 {
-  return md_digest_length (id);
+  return md_digest_length (algorithm);
 }
 
 
 /* Hmmm: add a mode to enumerate the OIDs
  *     to make g10/sig-check.c more portable */
 static const byte *
-md_asn_oid (int id, size_t *asnlen, size_t *mdlen)
+md_asn_oid (int algorithm, size_t *asnlen, size_t *mdlen)
 {
   const byte *asnoid = NULL;
-  gcry_module_t *digest;
+  gcry_module_t digest;
 
   REGISTER_DEFAULT_DIGESTS;
 
   ath_mutex_lock (&digests_registered_lock);
-  digest = _gcry_module_lookup_id (digests_registered, id);
+  digest = _gcry_module_lookup_id (digests_registered, algorithm);
   if (digest)
     {
       if (asnlen)
-       *asnlen = ((gcry_digest_spec_t *) digest->spec)->asnlen;
+       *asnlen = ((gcry_md_spec_t *) digest->spec)->asnlen;
       if (mdlen)
-       *mdlen = ((gcry_digest_spec_t *) digest->spec)->mdlen;
-      asnoid = ((gcry_digest_spec_t *) digest->spec)->asnoid;
+       *mdlen = ((gcry_md_spec_t *) digest->spec)->mdlen;
+      asnoid = ((gcry_md_spec_t *) digest->spec)->asnoid;
       _gcry_module_release (digest);
     }
   else
-    log_bug ("no asn for md algo %d\n", id);
+    log_bug ("no asn for md algo %d\n", algorithm);
   ath_mutex_unlock (&digests_registered_lock);
 
   return asnoid;
@@ -1130,7 +1132,7 @@ gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
            
            *nbytes = 0;
            for(r=h->ctx->list; r; r = r->next ) {
-             if (r->digest->id == algo)
+             if (r->module->mod_id == algo)
                {
                  *nbytes = 1;
                  break;
@@ -1179,3 +1181,22 @@ gcry_md_is_enabled (gcry_md_hd_t a, int algo)
     value = 0;
   return value;
 }
+
+/* Get a list consisting of the IDs of the loaded message digest
+   modules.  If LIST is zero, write the number of loaded message
+   digest modules to LIST_LENGTH and return.  If LIST is non-zero, the
+   first *LIST_LENGTH algorithm IDs are stored in LIST, which must be
+   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_md_list (int *list, int *list_length)
+{
+  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+
+  ath_mutex_lock (&digests_registered_lock);
+  err = _gcry_module_list (digests_registered, list, list_length);
+  ath_mutex_unlock (&digests_registered_lock);
+
+  return err;
+}
index 1686675..42f85e3 100644 (file)
@@ -303,9 +303,9 @@ static byte asn[18] = /* Object ID is 1.2.840.113549.2.4 */
   { 0x30, 0x20, 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86,0x48,
     0x86, 0xf7, 0x0d, 0x02, 0x04, 0x05, 0x00, 0x04, 0x10 };
 
-gcry_digest_spec_t digest_spec_md4 =
+gcry_md_spec_t digest_spec_md4 =
   {
-    "MD4", GCRY_MD_MD4, asn, DIM (asn), 16,
+    "MD4", asn, DIM (asn), 16,
     md4_init, md4_write, md4_final, md4_read,
     sizeof (MD4_CONTEXT)
   };
index 878a250..31159d2 100644 (file)
@@ -329,9 +329,9 @@ md5_read( void *context )
                      0x86, 0xf7, 0x0d, 0x02, 0x05, 0x05, 0x00, 0x04, 0x10 };
 
 
-gcry_digest_spec_t digest_spec_md5 =
+gcry_md_spec_t digest_spec_md5 =
   {
-    "MD5", GCRY_MD_MD5, asn, DIM (asn), 16,
+    "MD5", asn, DIM (asn), 16,
     md5_init, md5_write, md5_final, md5_read,
     sizeof (MD5_CONTEXT)
   };
index 178670d..ff29563 100644 (file)
@@ -37,25 +37,26 @@ static gpg_err_code_t pubkey_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data
 
 /* This is the list of the default public-key ciphers included in
    libgcrypt.  */
-static struct
+static struct pubkey_table_entry
 {
-  gcry_pubkey_spec_t *pubkey;
+  gcry_pk_spec_t *pubkey;
+  unsigned int algorithm;
 } pubkey_table[] =
   {
 #if USE_RSA
-    { &pubkey_spec_rsa },
+    { &pubkey_spec_rsa, GCRY_PK_RSA },
 #endif
 #if USE_ELGAMAL
-    { &pubkey_spec_elg },
+    { &pubkey_spec_elg, GCRY_PK_ELG },
 #endif
 #if USE_DSA
-    { &pubkey_spec_dsa },
+    { &pubkey_spec_dsa, GCRY_PK_DSA },
 #endif
     { NULL },
   };
 
 /* List of registered ciphers.  */
-static gcry_module_t *pubkeys_registered;
+static gcry_module_t pubkeys_registered;
 
 /* This is the lock protecting PUBKEYS_REGISTERED.  */
 static ath_mutex_t pubkeys_registered_lock;
@@ -71,7 +72,7 @@ static int default_pubkeys_registered;
       ath_mutex_lock (&pubkeys_registered_lock);   \
       if (! default_pubkeys_registered)            \
         {                                          \
-          gcry_pubkey_register_default ();         \
+          gcry_pk_register_default ();         \
           default_pubkeys_registered = 1;          \
         }                                          \
       ath_mutex_unlock (&pubkeys_registered_lock); \
@@ -82,60 +83,60 @@ static int default_pubkeys_registered;
    refuses to provide it's own functions.  */
 
 static gpg_err_code_t
-dummy_generate (int id, unsigned int nbits, unsigned long dummy,
+dummy_generate (int algorithm, unsigned int nbits, unsigned long dummy,
                 gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
-  log_bug ("no generate() for %d\n", id);
+  log_bug ("no generate() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_check_secret_key (int id, gcry_mpi_t *skey)
+dummy_check_secret_key (int algorithm, gcry_mpi_t *skey)
 {
-  log_bug ("no check_secret_key() for %d\n", id);
+  log_bug ("no check_secret_key() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_encrypt (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey, int flags)
+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", id);
+  log_bug ("no encrypt() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_decrypt (int id, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey, int flags)
+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", id);
+  log_bug ("no decrypt() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_sign (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
+dummy_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
-  log_bug ("no sign() for %d\n", id);
+  log_bug ("no sign() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_verify (int id, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+dummy_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
              int (*cmp) (void *, gcry_mpi_t), void *opaquev)
 {
-  log_bug ("no verify() for %d\n", id);
+  log_bug ("no verify() for %d\n", algorithm);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static unsigned
-dummy_get_nbits (int id, gcry_mpi_t *pkey)
+dummy_get_nbits (int algorithm, gcry_mpi_t *pkey)
 {
-  log_bug ("no get_nbits() for %d\n", id);
+  log_bug ("no get_nbits() for %d\n", algorithm);
   return 0;
 }
 
 /* Internal function.  Register all the pubkeys included in
    PUBKEY_TABLE.  Returns zero on success or an error code.  */
 static void
-gcry_pubkey_register_default (void)
+gcry_pk_register_default (void)
 {
   gpg_err_code_t err = 0;
   int i;
@@ -155,7 +156,7 @@ gcry_pubkey_register_default (void)
       pubkey_use_dummy (get_nbits);
 
       err = _gcry_module_add (&pubkeys_registered,
-                             pubkey_table[i].pubkey->id,
+                             pubkey_table[i].algorithm,
                              (void *) pubkey_table[i].pubkey, NULL);
     }
 
@@ -165,9 +166,9 @@ gcry_pubkey_register_default (void)
 
 /* Internal callback function.  Used via _gcry_module_lookup.  */
 static int
-gcry_pubkey_lookup_func_name (void *spec, void *data)
+gcry_pk_lookup_func_name (void *spec, void *data)
 {
-  gcry_pubkey_spec_t *pubkey = (gcry_pubkey_spec_t *) spec;
+  gcry_pk_spec_t *pubkey = (gcry_pk_spec_t *) spec;
   char *name = (char *) data;
   char **sexp_names = pubkey->sexp_names;
   int ret = stricmp (name, pubkey->name);
@@ -179,25 +180,27 @@ gcry_pubkey_lookup_func_name (void *spec, void *data)
 }
 
 /* Internal function.  Lookup a pubkey entry by it's name.  */
-static gcry_module_t *
-gcry_pubkey_lookup_name (const char *name)
+static gcry_module_t 
+gcry_pk_lookup_name (const char *name)
 {
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
 
   pubkey = _gcry_module_lookup (pubkeys_registered, (void *) name,
-                               gcry_pubkey_lookup_func_name);
+                               gcry_pk_lookup_func_name);
 
   return pubkey;
 }
 
-/* Public function.  Register a provided PUBKEY.  Returns zero on
-   success, in which case the chosen pubkey ID has been stored in
-   PUBKEY, or an error code.  */
+/* 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_pubkey_register (gcry_pubkey_spec_t *pubkey, gcry_module_t **module)
+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_module_t *mod;
+  gcry_module_t mod;
 
   ath_mutex_lock (&pubkeys_registered_lock);
   err = _gcry_module_add (&pubkeys_registered, 0,
@@ -207,16 +210,16 @@ gcry_pubkey_register (gcry_pubkey_spec_t *pubkey, gcry_module_t **module)
   if (! err)
     {
       *module = mod;
-      pubkey->id = mod->id;
+      *algorithm_id = mod->mod_id;
     }
 
   return err;
 }
 
-/* Public function.  Unregister the pubkey identified by ID, which
-   must have been registered with gcry_pubkey_register.  */
+/* Unregister the pubkey identified by ID, which must have been
+   registered with gcry_pk_register.  */
 void
-gcry_pubkey_unregister (gcry_module_t *module)
+gcry_pk_unregister (gcry_module_t module)
 {
   ath_mutex_lock (&pubkeys_registered_lock);
   _gcry_module_release (module);
@@ -239,21 +242,21 @@ release_mpi_array (gcry_mpi_t *array)
 int
 gcry_pk_map_name (const char *string)
 {
-  gcry_module_t *pubkey;
-  int id = 0;
+  gcry_module_t pubkey;
+  int algorithm = 0;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = gcry_pubkey_lookup_name (string);
+  pubkey = gcry_pk_lookup_name (string);
   if (pubkey)
     {
-      id = ((gcry_pubkey_spec_t *) pubkey->spec)->id;
+      algorithm = pubkey->mod_id;
       _gcry_module_release (pubkey);
     }
   ath_mutex_unlock (&pubkeys_registered_lock);
 
-  return id;
+  return algorithm;
 }
 
 
@@ -261,18 +264,18 @@ gcry_pk_map_name (const char *string)
  * Map a pubkey algo to a string
  */
 const char *
-gcry_pk_algo_name (int id)
+gcry_pk_algo_name (int algorithm)
 {
   const char *name = NULL;
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     {
-      name = ((gcry_pubkey_spec_t *) pubkey->spec)->name;
+      name = ((gcry_pk_spec_t *) pubkey->spec)->name;
       _gcry_module_release (pubkey);
     }
   ath_mutex_unlock (&pubkeys_registered_lock);
@@ -282,12 +285,12 @@ gcry_pk_algo_name (int id)
 
 
 static void
-disable_pubkey_algo (int id)
+disable_pubkey_algo (int algorithm)
 {
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     {
       if (! (pubkey-> flags & FLAG_MODULE_DISABLED))
@@ -302,19 +305,19 @@ disable_pubkey_algo (int id)
  * a use of 0 means: don't care
  */
 static gpg_err_code_t
-check_pubkey_algo (int id, unsigned use)
+check_pubkey_algo (int algorithm, unsigned use)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
-  gcry_pubkey_spec_t *pubkey;
-  gcry_module_t *module;
+  gcry_pk_spec_t *pubkey;
+  gcry_module_t module;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  module = _gcry_module_lookup_id (pubkeys_registered, id);
+  module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (module)
     {
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
+      pubkey = (gcry_pk_spec_t *) module->spec;
 
       if (((use & GCRY_PK_USAGE_SIGN)
           && (! (pubkey->use & GCRY_PK_USAGE_SIGN)))
@@ -337,18 +340,18 @@ check_pubkey_algo (int id, unsigned use)
  * Return the number of public key material numbers
  */
 static int
-pubkey_get_npkey (int id)
+pubkey_get_npkey (int algorithm)
 {
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
   int npkey = 0;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     {
-      npkey = strlen (((gcry_pubkey_spec_t *) pubkey->spec)->elements_pkey);
+      npkey = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_pkey);
       _gcry_module_release (pubkey);
     }
   ath_mutex_unlock (&pubkeys_registered_lock);
@@ -360,18 +363,18 @@ pubkey_get_npkey (int id)
  * Return the number of secret key material numbers
  */
 static int
-pubkey_get_nskey (int id)
+pubkey_get_nskey (int algorithm)
 {
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
   int nskey = 0;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     {
-      nskey = strlen (((gcry_pubkey_spec_t *) pubkey->spec)->elements_skey);
+      nskey = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_skey);
       _gcry_module_release (pubkey);
     }
   ath_mutex_unlock (&pubkeys_registered_lock);
@@ -383,18 +386,18 @@ pubkey_get_nskey (int id)
  * Return the number of signature material numbers
  */
 static int
-pubkey_get_nsig (int id)
+pubkey_get_nsig (int algorithm)
 {
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
   int nsig = 0;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     {
-      nsig = strlen (((gcry_pubkey_spec_t *) pubkey->spec)->elements_sig);
+      nsig = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_sig);
       _gcry_module_release (pubkey);
     }
   ath_mutex_unlock (&pubkeys_registered_lock);
@@ -406,18 +409,18 @@ pubkey_get_nsig (int id)
  * Return the number of encryption material numbers
  */
 static int
-pubkey_get_nenc (int id)
+pubkey_get_nenc (int algorithm)
 {
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
   int nenc = 0;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     {
-      nenc = strlen (((gcry_pubkey_spec_t *) pubkey->spec)->elements_enc);
+      nenc = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_enc);
       _gcry_module_release (pubkey);
     }
   ath_mutex_unlock (&pubkeys_registered_lock);
@@ -427,19 +430,19 @@ pubkey_get_nenc (int id)
 
 
 static gpg_err_code_t
-pubkey_generate (int id, unsigned int nbits, unsigned long use_e,
+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_module_t *pubkey;
+  gcry_module_t pubkey;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     {
-      err = (*((gcry_pubkey_spec_t *) pubkey->spec)->generate) (id, nbits, use_e, skey,
+      err = (*((gcry_pk_spec_t *) pubkey->spec)->generate) (algorithm, nbits, use_e, skey,
                                                            retfactors);
       _gcry_module_release (pubkey);
     }
@@ -449,18 +452,18 @@ pubkey_generate (int id, unsigned int nbits, unsigned long use_e,
 }
 
 static gpg_err_code_t
-pubkey_check_secret_key (int id, gcry_mpi_t *skey)
+pubkey_check_secret_key (int algorithm, gcry_mpi_t *skey)
 {
   gpg_err_code_t err = GPG_ERR_PUBKEY_ALGO;
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     {
-      err = (*((gcry_pubkey_spec_t *) pubkey->spec)->check_secret_key) (id, skey);
+      err = (*((gcry_pk_spec_t *) pubkey->spec)->check_secret_key) (algorithm, skey);
       _gcry_module_release (pubkey);
     }
   ath_mutex_unlock (&pubkeys_registered_lock);
@@ -476,28 +479,28 @@ pubkey_check_secret_key (int id, gcry_mpi_t *skey)
  * check with pubkey_get_nenc() )
  */
 static gpg_err_code_t
-pubkey_encrypt (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
+pubkey_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
                int flags)
 {
-  gcry_pubkey_spec_t *pubkey;
-  gcry_module_t *module;
+  gcry_pk_spec_t *pubkey;
+  gcry_module_t module;
   gpg_err_code_t rc;
   int i;
 
   if (DBG_CIPHER)
     {
-      log_debug ("pubkey_encrypt: algo=%d\n", id);
-      for(i = 0; i < pubkey_get_npkey (id); i++)
+      log_debug ("pubkey_encrypt: algo=%d\n", algorithm);
+      for(i = 0; i < pubkey_get_npkey (algorithm); i++)
        log_mpidump ("  pkey:", pkey[i]);
       log_mpidump ("  data:", data);
     }
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  module = _gcry_module_lookup_id (pubkeys_registered, id);
+  module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (module)
     {
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
-      rc = (*pubkey->encrypt) (id, resarr, data, pkey, flags);
+      pubkey = (gcry_pk_spec_t *) module->spec;
+      rc = (*pubkey->encrypt) (algorithm, resarr, data, pkey, flags);
       _gcry_module_release (module);
       goto ready;
     }
@@ -508,7 +511,7 @@ pubkey_encrypt (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
 
   if (!rc && DBG_CIPHER)
     {
-      for(i = 0; i < pubkey_get_nenc (id); i++)
+      for(i = 0; i < pubkey_get_nenc (algorithm); i++)
        log_mpidump("  encr:", resarr[i] );
     }
   return rc;
@@ -523,30 +526,30 @@ pubkey_encrypt (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
  * newly allocated mpi or NULL in case of an error.
  */
 static gpg_err_code_t
-pubkey_decrypt (int id, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey,
+pubkey_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey,
                int flags)
 {
-  gcry_pubkey_spec_t *pubkey;
-  gcry_module_t *module;
+  gcry_pk_spec_t *pubkey;
+  gcry_module_t module;
   gpg_err_code_t rc;
   int i;
 
   *result = NULL; /* so the caller can always do a mpi_free */
   if (DBG_CIPHER)
     {
-      log_debug ("pubkey_decrypt: algo=%d\n", id);
-      for(i = 0; i < pubkey_get_nskey (id); i++)
+      log_debug ("pubkey_decrypt: algo=%d\n", algorithm);
+      for(i = 0; i < pubkey_get_nskey (algorithm); i++)
        log_mpidump ("  skey:", skey[i]);
-      for(i = 0; i < pubkey_get_nenc (id); i++)
+      for(i = 0; i < pubkey_get_nenc (algorithm); i++)
        log_mpidump ("  data:", data[i]);
     }
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  module = _gcry_module_lookup_id (pubkeys_registered, id);
+  module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (module)
     {
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
-      rc = (*pubkey->decrypt) (id, result, data, skey, flags);
+      pubkey = (gcry_pk_spec_t *) module->spec;
+      rc = (*pubkey->decrypt) (algorithm, result, data, skey, flags);
       _gcry_module_release (module);
       goto ready;
     }
@@ -570,27 +573,27 @@ pubkey_decrypt (int id, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey,
  * algorithm allows this - check with pubkey_get_nsig() )
  */
 static gpg_err_code_t
-pubkey_sign (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
+pubkey_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
-  gcry_pubkey_spec_t *pubkey;
-  gcry_module_t *module;
+  gcry_pk_spec_t *pubkey;
+  gcry_module_t module;
   gpg_err_code_t rc;
   int i;
 
   if (DBG_CIPHER)
     {
-      log_debug ("pubkey_sign: algo=%d\n", id);
-      for(i = 0; i < pubkey_get_nskey (id); i++)
+      log_debug ("pubkey_sign: algo=%d\n", algorithm);
+      for(i = 0; i < pubkey_get_nskey (algorithm); i++)
        log_mpidump ("  skey:", skey[i]);
       log_mpidump("  data:", data );
     }
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  module = _gcry_module_lookup_id (pubkeys_registered, id);
+  module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (module)
     {
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
-      rc = (*pubkey->sign) (id, resarr, data, skey);
+      pubkey = (gcry_pk_spec_t *) module->spec;
+      rc = (*pubkey->sign) (algorithm, resarr, data, skey);
       _gcry_module_release (module);
       goto ready;
     }
@@ -601,7 +604,7 @@ pubkey_sign (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
   ath_mutex_unlock (&pubkeys_registered_lock);
 
   if (! rc && DBG_CIPHER)
-    for (i = 0; i < pubkey_get_nsig (id); i++)
+    for (i = 0; i < pubkey_get_nsig (algorithm); i++)
       log_mpidump ("   sig:", resarr[i]);
 
   return rc;
@@ -612,30 +615,30 @@ pubkey_sign (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
  * Return 0 if the signature is good
  */
 static gpg_err_code_t
-pubkey_verify (int id, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+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_pubkey_spec_t *pubkey;
-  gcry_module_t *module;
+  gcry_pk_spec_t *pubkey;
+  gcry_module_t module;
   gpg_err_code_t rc;
   int i;
 
   if (DBG_CIPHER)
     {
-      log_debug ("pubkey_verify: algo=%d\n", id);
-      for (i = 0; i < pubkey_get_npkey (id); i++)
+      log_debug ("pubkey_verify: algo=%d\n", algorithm);
+      for (i = 0; i < pubkey_get_npkey (algorithm); i++)
        log_mpidump ("  pkey:", pkey[i]);
-      for (i = 0; i < pubkey_get_nsig (id); i++)
+      for (i = 0; i < pubkey_get_nsig (algorithm); i++)
        log_mpidump ("   sig:", data[i]);
       log_mpidump ("  hash:", hash);
     }
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  module = _gcry_module_lookup_id (pubkeys_registered, id);
+  module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (module)
     {
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
-      rc = (*pubkey->verify) (id, hash, data, pkey, cmp, opaquev);
+      pubkey = (gcry_pk_spec_t *) module->spec;
+      rc = (*pubkey->verify) (algorithm, hash, data, pkey, cmp, opaquev);
       _gcry_module_release (module);
       goto ready;
     }
@@ -714,17 +717,16 @@ sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
  */
 static gpg_err_code_t
 sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
-             gcry_module_t **retalgo)
+             gcry_module_t *retalgo)
 {
     gcry_sexp_t list, l2;
     const char *name;
     size_t n;
-    int algo;
     const char *elems;
     gcry_mpi_t *array;
     gpg_err_code_t err = GPG_ERR_NO_ERROR;
-    gcry_module_t *module;
-    gcry_pubkey_spec_t *pubkey;
+    gcry_module_t module;
+    gcry_pk_spec_t *pubkey;
 
     /* check that the first element is valid */
     list = gcry_sexp_find_token( sexp, want_private? "private-key"
@@ -746,7 +748,7 @@ sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
       name_terminated[n] = 0;
 
       ath_mutex_lock (&pubkeys_registered_lock);
-      module = gcry_pubkey_lookup_name (name_terminated);
+      module = gcry_pk_lookup_name (name_terminated);
       ath_mutex_unlock (&pubkeys_registered_lock);
 
       free (name_terminated);
@@ -758,9 +760,8 @@ sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
        return GPG_ERR_PUBKEY_ALGO; /* unknown algorithm */
       }
     else
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
+      pubkey = (gcry_pk_spec_t *) module->spec;
 
-    algo = pubkey->id;
     elems = want_private ? pubkey->elements_skey : pubkey->elements_pkey;
     array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
     if (! array)
@@ -791,17 +792,16 @@ sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
 
 static gpg_err_code_t
 sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
-            gcry_module_t **retalgo)
+            gcry_module_t *retalgo)
 {
     gcry_sexp_t list, l2;
     const char *name;
     size_t n;
-    int algo;
     const char *elems;
     gcry_mpi_t *array;
     gpg_err_code_t err = GPG_ERR_NO_ERROR;
-    gcry_module_t *module;
-    gcry_pubkey_spec_t *pubkey;
+    gcry_module_t module;
+    gcry_pk_spec_t *pubkey;
 
     /* check that the first element is valid */
     list = gcry_sexp_find_token( sexp, "sig-val" , 0 );
@@ -838,7 +838,7 @@ sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
       name_terminated[n] = 0;
       
       ath_mutex_lock (&pubkeys_registered_lock);
-      module = gcry_pubkey_lookup_name (name_terminated);
+      module = gcry_pk_lookup_name (name_terminated);
       ath_mutex_unlock (&pubkeys_registered_lock);
 
       free (name_terminated);
@@ -851,9 +851,8 @@ sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
        return GPG_ERR_PUBKEY_ALGO; /* unknown algorithm */
       }
     else
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
+      pubkey = (gcry_pk_spec_t *) module->spec;
 
-    algo = pubkey->id;
     elems = pubkey->elements_sig;
     array = gcry_calloc (strlen (elems) + 1 , sizeof (*array));
     if (! array)
@@ -897,12 +896,12 @@ 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
-sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t **retalgo,
+sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
              int *ret_modern, int *ret_want_pkcs1, int *flags)
 {
   gcry_sexp_t list = NULL, l2 = NULL;
-  gcry_pubkey_spec_t *pubkey = NULL;
-  gcry_module_t *module = NULL;
+  gcry_pk_spec_t *pubkey = NULL;
+  gcry_module_t module = NULL;
   const char *name;
   size_t n;
   int parsed_flags = 0;
@@ -985,7 +984,7 @@ sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t **retalgo,
       name_terminated[n] = 0;
 
       ath_mutex_lock (&pubkeys_registered_lock);
-      module = gcry_pubkey_lookup_name (name_terminated);
+      module = gcry_pk_lookup_name (name_terminated);
       ath_mutex_unlock (&pubkeys_registered_lock);
 
       free (name_terminated);
@@ -993,7 +992,7 @@ sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t **retalgo,
       if (! module)
        err = GPG_ERR_PUBKEY_ALGO; /* unknown algorithm */
       else
-       pubkey = (gcry_pubkey_spec_t *) module->spec;
+       pubkey = (gcry_pk_spec_t *) module->spec;
     }
 
   if (! err)
@@ -1305,8 +1304,8 @@ gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
   const char *algo_name, *algo_elems;
   int flags;
   gpg_err_code_t rc;
-  gcry_pubkey_spec_t *pubkey = NULL;
-  gcry_module_t *module = NULL;
+  gcry_pk_spec_t *pubkey = NULL;
+  gcry_module_t module = NULL;
 
   REGISTER_DEFAULT_PUBKEYS;
 
@@ -1316,7 +1315,7 @@ gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
   if (! rc)
     {
       assert (module);
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
+      pubkey = (gcry_pk_spec_t *) module->spec;
       algo_name = pubkey->name;
       algo_elems = pubkey->elements_enc;
       
@@ -1329,7 +1328,7 @@ gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
     {
       /* Now we can encrypt data to ciph */
       ciph = gcry_xcalloc (strlen (algo_elems) + 1, sizeof (*ciph));
-      rc = pubkey_encrypt (pubkey->id, ciph, data, pkey, flags);
+      rc = pubkey_encrypt (module->mod_id, ciph, data, pkey, flags);
       mpi_free (data);
     }
 
@@ -1428,8 +1427,8 @@ 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_module_t *module_enc = NULL, *module_key = NULL;
-  gcry_pubkey_spec_t *pubkey = NULL;
+  gcry_module_t module_enc = NULL, module_key = NULL;
+  gcry_pk_spec_t *pubkey = NULL;
 
   REGISTER_DEFAULT_PUBKEYS;
 
@@ -1441,15 +1440,14 @@ gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
 
   if (! rc)
     {
-      if (((gcry_pubkey_spec_t *) module_key->spec)->id
-         != ((gcry_pubkey_spec_t *) module_enc->spec)->id)
+      if (module_key->mod_id != module_enc->mod_id)
        rc = GPG_ERR_CONFLICT; /* key algo does not match data algo */
       else
-       pubkey = (gcry_pubkey_spec_t *) module_key->spec;
+       pubkey = (gcry_pk_spec_t *) module_key->spec;
     }
 
   if (! rc)
-    rc = pubkey_decrypt (pubkey->id, &plain, data, skey, flags);
+    rc = pubkey_decrypt (module_key->mod_id, &plain, data, skey, flags);
 
   if (! rc)
     {
@@ -1524,8 +1522,8 @@ gpg_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;
-  gcry_pubkey_spec_t *pubkey = NULL;
-  gcry_module_t *module = NULL;
+  gcry_pk_spec_t *pubkey = NULL;
+  gcry_module_t module = NULL;
   const char *key_algo_name, *algo_name, *algo_elems;
   int i;
   gpg_err_code_t rc;
@@ -1539,7 +1537,7 @@ gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
   if (! rc)
     {
       assert (module);
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
+      pubkey = (gcry_pk_spec_t *) module->spec;
       algo_name = key_algo_name = pubkey->name;
 
       algo_elems = pubkey->elements_sig;
@@ -1552,7 +1550,7 @@ gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
   if (! rc)
     {
       result = gcry_xcalloc (strlen (algo_elems) + 1, sizeof (*result));
-      rc = pubkey_sign (pubkey->id, result, hash, skey);
+      rc = pubkey_sign (module->mod_id, result, hash, skey);
     }
 
   if (! rc)
@@ -1624,7 +1622,7 @@ gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
 gpg_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_module_t module_key = NULL, module_sig = NULL;
   gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
   gpg_err_code_t rc;
 
@@ -1635,16 +1633,14 @@ gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
     rc = sexp_to_sig (s_sig, &sig, &module_sig);
 
   if ((! rc)
-      && (((gcry_pubkey_spec_t *) module_key->spec)->id
-         != ((gcry_pubkey_spec_t *) module_sig->spec)->id))
+      && (module_key->mod_id != module_sig->mod_id))
     rc = GPG_ERR_CONFLICT;
 
   if (! rc)
     rc = sexp_data_to_mpi (s_hash, gcry_pk_get_nbits (s_pkey), &hash, 0, 0);
 
   if (! rc)
-    rc = pubkey_verify (((gcry_pubkey_spec_t *) module_key->spec)->id,
-                       hash, sig, pkey, NULL, NULL);
+    rc = pubkey_verify (module_key->mod_id, hash, sig, pkey, NULL, NULL);
 
   if (pkey)
     {
@@ -1684,7 +1680,7 @@ gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
 gpg_error_t
 gcry_pk_testkey (gcry_sexp_t s_key)
 {
-  gcry_module_t *module = NULL;
+  gcry_module_t module = NULL;
   gcry_mpi_t *key = NULL;
   gpg_err_code_t rc;
   
@@ -1694,7 +1690,7 @@ gcry_pk_testkey (gcry_sexp_t s_key)
   rc = sexp_to_key (s_key, 1, &key, &module);
   if (! rc)
     {
-      rc = pubkey_check_secret_key (((gcry_pubkey_spec_t *) module->spec)->id, key);
+      rc = pubkey_check_secret_key (module->mod_id, key);
       release_mpi_array (key);
       gcry_free (key);
     }
@@ -1739,8 +1735,8 @@ gcry_pk_testkey (gcry_sexp_t s_key)
 gpg_error_t
 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
 {
-  gcry_pubkey_spec_t *pubkey = NULL;
-  gcry_module_t *module = NULL;
+  gcry_pk_spec_t *pubkey = NULL;
+  gcry_module_t module = NULL;
   gcry_sexp_t list = NULL, l2 = NULL;
   const char *name;
   size_t n;
@@ -1784,7 +1780,7 @@ gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
       name_terminated[n] = 0;
 
       ath_mutex_lock (&pubkeys_registered_lock);
-      module = gcry_pubkey_lookup_name (name_terminated);
+      module = gcry_pk_lookup_name (name_terminated);
       ath_mutex_unlock (&pubkeys_registered_lock);
 
       free (name_terminated);
@@ -1793,8 +1789,8 @@ gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
        rc = GPG_ERR_PUBKEY_ALGO; /* unknown algorithm */
       else
        {
-         pubkey = (gcry_pubkey_spec_t *) module->spec;
-         algo = pubkey->id;
+         pubkey = (gcry_pk_spec_t *) module->spec;
+         algo = module->mod_id;
          algo_name = pubkey->name;
          pub_elems = pubkey->elements_pkey;
          sec_elems = pubkey->elements_skey;
@@ -1849,7 +1845,7 @@ gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
     }
 
   if (! rc)
-    rc = pubkey_generate (pubkey->id, nbits, use_e, skey, &factors);
+    rc = pubkey_generate (module->mod_id, nbits, use_e, skey, &factors);
 
   if (! rc)
     {
@@ -1963,8 +1959,8 @@ gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
 unsigned int
 gcry_pk_get_nbits (gcry_sexp_t key)
 {
-  gcry_module_t *module = NULL;
-  gcry_pubkey_spec_t *pubkey;
+  gcry_module_t module = NULL;
+  gcry_pk_spec_t *pubkey;
   gcry_mpi_t *keyarr = NULL;
   unsigned int nbits = 0;
   gpg_err_code_t rc;
@@ -1978,8 +1974,8 @@ gcry_pk_get_nbits (gcry_sexp_t key)
     return 0;
   else
     {
-      pubkey = (gcry_pubkey_spec_t *) module->spec;
-      nbits = (*pubkey->get_nbits) (pubkey->id, keyarr);
+      pubkey = (gcry_pk_spec_t *) module->spec;
+      nbits = (*pubkey->get_nbits) (module->mod_id, keyarr);
 
       ath_mutex_lock (&pubkeys_registered_lock);
       _gcry_module_release (module);
@@ -2004,8 +2000,8 @@ unsigned char *
 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
 {
   gcry_sexp_t list = NULL, l2 = NULL;
-  gcry_pubkey_spec_t *pubkey = NULL;
-  gcry_module_t *module = NULL;
+  gcry_pk_spec_t *pubkey = NULL;
+  gcry_module_t module = NULL;
   const char *s, *name;
   size_t n;
   int idx;
@@ -2040,7 +2036,7 @@ gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
     name_terminated[n] = 0;
 
     ath_mutex_lock (&pubkeys_registered_lock);
-    module = gcry_pubkey_lookup_name (name_terminated);
+    module = gcry_pk_lookup_name (name_terminated);
     ath_mutex_unlock (&pubkeys_registered_lock);
 
     free (name_terminated);
@@ -2049,11 +2045,11 @@ gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
   if (! module)
     goto fail; /* unknown algorithm */
   else
-    pubkey = (gcry_pubkey_spec_t *) module->spec;
+    pubkey = (gcry_pk_spec_t *) module->spec;
 
   /* FIXME, special handling should be implemented by the algorithms,
      not by the libgcrypt core.  */
-  is_rsa = pubkey->id == GCRY_PK_RSA;
+  is_rsa = module->mod_id == GCRY_PK_RSA;
   elems = pubkey->elements_grip;
   if (! elems)
     goto fail; /* no grip parameter */
@@ -2159,7 +2155,7 @@ gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
  * the block size)
  */
 gpg_error_t
-gcry_pk_algo_info (int id, int what, void *buffer, size_t *nbytes)
+gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
 
@@ -2170,23 +2166,23 @@ gcry_pk_algo_info (int id, int what, void *buffer, size_t *nbytes)
        int use = nbytes ? *nbytes : 0;
        if (buffer)
          err = GPG_ERR_INV_ARG;
-       else if (check_pubkey_algo (id, use))
+       else if (check_pubkey_algo (algorithm, use))
          err = GPG_ERR_PUBKEY_ALGO;
        break;
       }
 
     case GCRYCTL_GET_ALGO_USAGE:
       {
-       gcry_module_t *pubkey;
+       gcry_module_t pubkey;
        int use = 0;
 
        REGISTER_DEFAULT_PUBKEYS;
 
        ath_mutex_lock (&pubkeys_registered_lock);
-       pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+       pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
        if (pubkey)
          {
-           use = ((gcry_pubkey_spec_t *) pubkey->spec)->use;
+           use = ((gcry_pk_spec_t *) pubkey->spec)->use;
            _gcry_module_release (pubkey);
          }
        ath_mutex_unlock (&pubkeys_registered_lock);
@@ -2198,28 +2194,28 @@ gcry_pk_algo_info (int id, int what, void *buffer, size_t *nbytes)
     case GCRYCTL_GET_ALGO_NPKEY:
       {
        /* FIXME?  */
-       int npkey = pubkey_get_npkey (id);
+       int npkey = pubkey_get_npkey (algorithm);
        *nbytes = npkey;
        break;
       }
     case GCRYCTL_GET_ALGO_NSKEY:
       {
        /* FIXME?  */
-       int nskey = pubkey_get_nskey (id);
+       int nskey = pubkey_get_nskey (algorithm);
        *nbytes = nskey;
        break;
       }
     case GCRYCTL_GET_ALGO_NSIGN:
       {
        /* FIXME?  */
-       int nsign = pubkey_get_nsig (id);
+       int nsign = pubkey_get_nsig (algorithm);
        *nbytes = nsign;
        break;
       }
     case GCRYCTL_GET_ALGO_NENCR:
       {
        /* FIXME?  */
-       int nencr = pubkey_get_nenc (id);
+       int nencr = pubkey_get_nenc (algorithm);
        *nbytes = nencr;
        break;
       }
@@ -2242,15 +2238,15 @@ _gcry_pk_init (void)
 }
 
 gpg_err_code_t
-_gcry_pk_module_lookup (int id, gcry_module_t **module)
+_gcry_pk_module_lookup (int algorithm, gcry_module_t *module)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
-  gcry_module_t *pubkey;
+  gcry_module_t pubkey;
 
   REGISTER_DEFAULT_PUBKEYS;
 
   ath_mutex_lock (&pubkeys_registered_lock);
-  pubkey = _gcry_module_lookup_id (pubkeys_registered, id);
+  pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
   if (pubkey)
     *module = pubkey;
   else
@@ -2261,9 +2257,27 @@ _gcry_pk_module_lookup (int id, gcry_module_t **module)
 }
 
 void
-_gcry_pk_module_release (gcry_module_t *module)
+_gcry_pk_module_release (gcry_module_t module)
 {
   ath_mutex_lock (&pubkeys_registered_lock);
   _gcry_module_release (module);
   ath_mutex_unlock (&pubkeys_registered_lock);
 }
+
+/* Get a list consisting of the IDs of the loaded pubkey modules.  If
+   LIST is zero, write the number of loaded pubkey modules to
+   LIST_LENGTH and return.  If LIST is non-zero, the first
+   *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_pk_list (int *list, int *list_length)
+{
+  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+
+  ath_mutex_lock (&pubkeys_registered_lock);
+  err = _gcry_module_list (pubkeys_registered, list, list_length);
+  ath_mutex_unlock (&pubkeys_registered_lock);
+
+  return err;
+}
index 3943d9a..1aa9e22 100644 (file)
@@ -2133,18 +2133,18 @@ selftest (void)
 
 gcry_cipher_spec_t cipher_spec_aes =
   {
-    "AES", GCRY_CIPHER_AES, 16, 128, sizeof (RIJNDAEL_context),
+    "AES", 16, 128, sizeof (RIJNDAEL_context),
     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
   };
 
 gcry_cipher_spec_t cipher_spec_aes192 =
   {
-    "AES192", GCRY_CIPHER_AES192, 16, 192, sizeof (RIJNDAEL_context),
+    "AES192", 16, 192, sizeof (RIJNDAEL_context),
     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
   };
 
 gcry_cipher_spec_t cipher_spec_aes256 =
   {
-    "AES256", GCRY_CIPHER_AES256, 16, 256, sizeof (RIJNDAEL_context),
+    "AES256", 16, 256, sizeof (RIJNDAEL_context),
     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
   };
index 01df1d2..b06702b 100644 (file)
@@ -543,9 +543,9 @@ static byte asn[15] = /* Object ID is 1.3.36.3.2.1 */
   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
 
-gcry_digest_spec_t digest_spec_rmd160 =
+gcry_md_spec_t digest_spec_rmd160 =
   {
-    "RIPEMD160", GCRY_MD_RMD160, asn, DIM (asn), 20,
+    "RIPEMD160", asn, DIM (asn), 20,
     _gcry_rmd160_init, rmd160_write, rmd160_final, rmd160_read,
     sizeof (RMD160_CONTEXT)
   };
index c16ccc0..1a5a8dc 100644 (file)
@@ -611,9 +611,9 @@ static char *rsa_names[] =
     NULL,
   };
 
-gcry_pubkey_spec_t pubkey_spec_rsa =
+gcry_pk_spec_t pubkey_spec_rsa =
   {
-    "RSA", rsa_names, GCRY_PK_RSA,
+    "RSA", rsa_names,
     "ne", "nedpqu", "a", "s", "n",
     GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR,
     _gcry_rsa_generate,
index 1c382a9..bb22364 100644 (file)
@@ -319,9 +319,9 @@ static byte asn[15] = /* Object ID is 1.3.14.3.2.26 */
   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
 
-gcry_digest_spec_t digest_spec_sha1 =
+gcry_md_spec_t digest_spec_sha1 =
   {
-    "SHA1", GCRY_MD_SHA1, asn, DIM (asn), 20,
+    "SHA1", asn, DIM (asn), 20,
     sha1_init, sha1_write, sha1_final, sha1_read,
     sizeof (SHA1_CONTEXT)
   };
index 6b3b498..8b92d31 100644 (file)
@@ -293,9 +293,9 @@ static byte asn[19] = /* Object ID is  2.16.840.1.101.3.4.2.1 */
     0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
     0x00, 0x04, 0x20 };
 
-gcry_digest_spec_t digest_spec_sha256 =
+gcry_md_spec_t digest_spec_sha256 =
   {
-    "SHA256", GCRY_MD_SHA256, asn, DIM (asn), 32,
+    "SHA256", asn, DIM (asn), 32,
     sha256_init, sha256_write, sha256_final, sha256_read,
     sizeof (SHA256_CONTEXT)
   };
index d2e0e3a..7daca35 100644 (file)
@@ -367,8 +367,8 @@ static byte sha512_asn[] =  /* Object ID is 2.16.840.1.101.3.4.2.3 */
   0x00, 0x04, 0x40
 };
 
-gcry_digest_spec_t digest_spec_sha512 = {
-  "SHA512", GCRY_MD_SHA512, sha512_asn, DIM (sha512_asn), 64,
+gcry_md_spec_t digest_spec_sha512 = {
+  "SHA512", sha512_asn, DIM (sha512_asn), 64,
   sha512_init, sha512_write, sha512_final, sha512_read,
   sizeof (SHA512_CONTEXT),
 };
@@ -380,8 +380,8 @@ static byte sha384_asn[] =  /* Object ID is 2.16.840.1.101.3.4.2.2 */
   0x00, 0x04, 0x30
 };
 
-gcry_digest_spec_t digest_spec_sha384 = {
-  "SHA384", GCRY_MD_SHA384, sha384_asn, DIM (sha384_asn), 48,
+gcry_md_spec_t digest_spec_sha384 = {
+  "SHA384", sha384_asn, DIM (sha384_asn), 48,
   sha384_init, sha512_write, sha512_final, sha512_read,
   sizeof (SHA512_CONTEXT),
 };
index 2aaeadb..2115e96 100644 (file)
@@ -827,9 +827,9 @@ static byte asn[19] = /* Object ID is 1.3.6.1.4.1.11591.12.2 */
     0x05, 0x00, 0x04, 0x18 };
 
 
-gcry_digest_spec_t digest_spec_tiger =
+gcry_md_spec_t digest_spec_tiger =
   {
-    "TIGER192", GCRY_MD_TIGER, asn, DIM (asn), 24,
+    "TIGER192", asn, DIM (asn), 24,
     tiger_init, tiger_write, tiger_final, tiger_read,
     sizeof (TIGER_CONTEXT)
   };
index a5a2aa4..ac70051 100644 (file)
@@ -1021,12 +1021,12 @@ main()
 
 gcry_cipher_spec_t cipher_spec_twofish =
   {
-    "TWOFISH", GCRY_CIPHER_TWOFISH, 16, 256, sizeof (TWOFISH_context),
+    "TWOFISH", 16, 256, sizeof (TWOFISH_context),
     twofish_setkey, twofish_encrypt, twofish_decrypt,
   };
 
 gcry_cipher_spec_t cipher_spec_twofish128 =
   {
-    "TWOFISH128", GCRY_CIPHER_TWOFISH, 16, 128, sizeof (TWOFISH_context),
+    "TWOFISH128", 16, 128, sizeof (TWOFISH_context),
     twofish_setkey, twofish_encrypt, twofish_decrypt,
   };