Removed the module registration interface
[libgcrypt.git] / src / visibility.c
index 43f7730..2d3edbc 100644 (file)
@@ -1,5 +1,5 @@
 /* visibility.c - Wrapper for all public functions.
- * Copyright (C) 2007  Free Software Foundation, Inc.
+ * Copyright (C) 2007, 2008, 2011  Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
 #include <config.h>
 #include <stdarg.h>
 
-#define _GCRY_INCLUDED_BY_VISIBILITY_C 
+#define _GCRY_INCLUDED_BY_VISIBILITY_C
 #include "g10lib.h"
+#include "cipher-proto.h"
+
 
 
 const char *
@@ -36,7 +38,7 @@ gcry_strsource (gcry_error_t err)
   return _gcry_strsource (err);
 }
 
-gcry_err_code_t 
+gcry_err_code_t
 gcry_err_code_from_errno (int err)
 {
   return _gcry_err_code_from_errno (err);
@@ -48,13 +50,13 @@ gcry_err_code_to_errno (gcry_err_code_t code)
   return _gcry_err_code_to_errno (code);
 }
 
-gcry_error_t 
+gcry_error_t
 gcry_err_make_from_errno (gcry_err_source_t source, int err)
 {
   return _gcry_err_make_from_errno (source, err);
 }
 
-gcry_err_code_t 
+gcry_err_code_t
 gcry_error_from_errno (int err)
 {
   return _gcry_error_from_errno (err);
@@ -66,19 +68,19 @@ gcry_check_version (const char *req_version)
   return _gcry_check_version (req_version);
 }
 
-gcry_error_t 
+gcry_error_t
 gcry_control (enum gcry_ctl_cmds cmd, ...)
 {
   gcry_error_t err;
   va_list arg_ptr;
-  
+
   va_start (arg_ptr, cmd);
   err = _gcry_vcontrol (cmd, arg_ptr);
   va_end(arg_ptr);
   return err;
 }
 
-gcry_error_t 
+gcry_error_t
 gcry_sexp_new (gcry_sexp_t *retsexp,
                const void *buffer, size_t length,
                int autodetect)
@@ -86,7 +88,7 @@ gcry_sexp_new (gcry_sexp_t *retsexp,
   return _gcry_sexp_new (retsexp, buffer, length, autodetect);
 }
 
-gcry_error_t 
+gcry_error_t
 gcry_sexp_create (gcry_sexp_t *retsexp,
                   void *buffer, size_t length,
                   int autodetect, void (*freefnc) (void *))
@@ -95,53 +97,53 @@ gcry_sexp_create (gcry_sexp_t *retsexp,
                             autodetect, freefnc);
 }
 
-gcry_error_t 
+gcry_error_t
 gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
                  const char *buffer, size_t length)
 {
   return _gcry_sexp_sscan (retsexp, erroff, buffer, length);
 }
 
-gcry_error_t 
+gcry_error_t
 gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
                  const char *format, ...)
 {
   gcry_error_t err;
   va_list arg_ptr;
-  
+
   va_start (arg_ptr, format);
   err = _gcry_sexp_vbuild (retsexp, erroff, format, arg_ptr);
   va_end (arg_ptr);
   return err;
 }
 
-gcry_error_t 
+gcry_error_t
 gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
                        const char *format, void **arg_list)
 {
   return _gcry_sexp_build_array (retsexp, erroff, format, arg_list);
 }
 
-void 
+void
 gcry_sexp_release (gcry_sexp_t sexp)
 {
   _gcry_sexp_release (sexp);
 }
 
-size_t 
-gcry_sexp_canon_len (const unsigned char *buffer, size_t length, 
+size_t
+gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
                      size_t *erroff, gcry_error_t *errcode)
 {
   return _gcry_sexp_canon_len (buffer, length, erroff, errcode);
 }
 
-size_t 
+size_t
 gcry_sexp_sprint (gcry_sexp_t sexp, int mode, void *buffer, size_t maxlength)
 {
   return _gcry_sexp_sprint (sexp, mode, buffer, maxlength);
 }
 
-void 
+void
 gcry_sexp_dump (const gcry_sexp_t a)
 {
   _gcry_sexp_dump (a);
@@ -247,7 +249,7 @@ gcry_mpi_snew (unsigned int nbits)
   return _gcry_mpi_snew (nbits);
 }
 
-void 
+void
 gcry_mpi_release (gcry_mpi_t a)
 {
   _gcry_mpi_release (a);
@@ -291,7 +293,7 @@ gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v)
 
 gcry_error_t
 gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
-               const void *buffer, size_t buflen, 
+               const void *buffer, size_t buflen,
                size_t *nscanned)
 {
   return _gcry_mpi_scan (ret_mpi, format, buffer, buflen, nscanned);
@@ -455,6 +457,12 @@ gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
   _gcry_mpi_rshift (x, a, n);
 }
 
+void
+gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
+{
+  _gcry_mpi_lshift (x, a, n);
+}
+
 gcry_mpi_t
 gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits)
 {
@@ -489,6 +497,12 @@ gcry_error_t
 gcry_cipher_open (gcry_cipher_hd_t *handle,
                   int algo, int mode, unsigned int flags)
 {
+  if (!fips_is_operational ())
+    {
+      *handle = NULL;
+      return gpg_error (fips_not_operational ());
+    }
+
   return _gcry_cipher_open (handle, algo, mode, flags);
 }
 
@@ -499,8 +513,39 @@ gcry_cipher_close (gcry_cipher_hd_t h)
 }
 
 gcry_error_t
+gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
+{
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
+
+  return _gcry_cipher_setkey (hd, key, keylen);
+}
+
+gcry_error_t
+gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
+{
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
+
+  return _gcry_cipher_setiv (hd, iv, ivlen);
+}
+
+gpg_error_t
+gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
+{
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
+
+  return _gcry_cipher_setctr (hd, ctr, ctrlen);
+}
+
+
+gcry_error_t
 gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
+
   return _gcry_cipher_ctl (h, cmd, buffer, buflen);
 }
 
@@ -513,6 +558,9 @@ gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer, size_t *nbytes)
 gcry_error_t
 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
+
   return _gcry_cipher_algo_info (algo, what, buffer, nbytes);
 }
 
@@ -539,6 +587,14 @@ gcry_cipher_encrypt (gcry_cipher_hd_t h,
                      void *out, size_t outsize,
                      const void *in, size_t inlen)
 {
+  if (!fips_is_operational ())
+    {
+      /* Make sure that the plaintext will never make it to OUT. */
+      if (out)
+        memset (out, 0x42, outsize);
+      return gpg_error (fips_not_operational ());
+    }
+
   return _gcry_cipher_encrypt (h, out, outsize, in, inlen);
 }
 
@@ -547,8 +603,10 @@ gcry_cipher_decrypt (gcry_cipher_hd_t h,
                      void *out, size_t outsize,
                      const void *in, size_t inlen)
 {
-  return _gcry_cipher_decrypt (h, out, outsize, in, inlen);
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
 
+  return _gcry_cipher_decrypt (h, out, outsize, in, inlen);
 }
 
 size_t
@@ -564,44 +622,62 @@ gcry_cipher_get_algo_blklen (int algo)
 }
 
 gcry_error_t
-gcry_cipher_list (int *list, int *list_length)
-{
-  return _gcry_cipher_list (list, list_length);
-}
-
-gcry_error_t
 gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey)
 {
+  if (!fips_is_operational ())
+    {
+      *result = NULL;
+      return gpg_error (fips_not_operational ());
+    }
   return _gcry_pk_encrypt (result, data, pkey);
 }
 
 gcry_error_t
 gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
 {
+  if (!fips_is_operational ())
+    {
+      *result = NULL;
+      return gpg_error (fips_not_operational ());
+    }
   return _gcry_pk_decrypt (result, data, skey);
 }
 
 gcry_error_t
 gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
 {
+  if (!fips_is_operational ())
+    {
+      *result = NULL;
+      return gpg_error (fips_not_operational ());
+    }
   return _gcry_pk_sign (result, data, skey);
 }
 
 gcry_error_t
 gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
   return _gcry_pk_verify (sigval, data, pkey);
 }
 
 gcry_error_t
 gcry_pk_testkey (gcry_sexp_t key)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
   return _gcry_pk_testkey (key);
 }
 
 gcry_error_t
 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
 {
+  if (!fips_is_operational ())
+    {
+      *r_key = NULL;
+      return gpg_error (fips_not_operational ());
+    }
   return _gcry_pk_genkey (r_key, s_parms);
 }
 
@@ -614,6 +690,9 @@ gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
 gcry_error_t
 gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
+
   return _gcry_pk_algo_info (algo, what, buffer, nbytes);
 }
 
@@ -632,28 +711,61 @@ gcry_pk_map_name (const char *name)
 unsigned int
 gcry_pk_get_nbits (gcry_sexp_t key)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      return 0;
+    }
+
   return _gcry_pk_get_nbits (key);
 }
 
 unsigned char *
 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      return NULL;
+    }
   return _gcry_pk_get_keygrip (key, array);
 }
 
-gcry_error_t
-gcry_pk_list (int *list, int *list_length)
+const char *
+gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
+{
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      return NULL;
+    }
+  return _gcry_pk_get_curve (key, iterator, r_nbits);
+}
+
+gcry_sexp_t
+gcry_pk_get_param (int algo, const char *name)
 {
-  return _gcry_pk_list (list, list_length);
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      return NULL;
+    }
+  return _gcry_pk_get_param (algo, name);
 }
 
 gcry_error_t
 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
 {
+  if (!fips_is_operational ())
+    {
+      *h = NULL;
+      return gpg_error (fips_not_operational ());
+    }
+
   return _gcry_md_open (h, algo, flags);
 }
 
-void 
+void
 gcry_md_close (gcry_md_hd_t hd)
 {
   _gcry_md_close (hd);
@@ -662,12 +774,19 @@ gcry_md_close (gcry_md_hd_t hd)
 gcry_error_t
 gcry_md_enable (gcry_md_hd_t hd, int algo)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
   return _gcry_md_enable (hd, algo);
 }
 
 gcry_error_t
 gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd)
 {
+  if (!fips_is_operational ())
+    {
+      *bhd = NULL;
+      return gpg_error (fips_not_operational ());
+    }
   return _gcry_md_copy (bhd, ahd);
 }
 
@@ -680,12 +799,19 @@ gcry_md_reset (gcry_md_hd_t hd)
 gcry_error_t
 gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
   return _gcry_md_ctl (hd, cmd, buffer, buflen);
 }
 
 void
 gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      return;
+    }
   _gcry_md_write (hd, buffer, length);
 }
 
@@ -695,16 +821,27 @@ gcry_md_read (gcry_md_hd_t hd, int algo)
   return _gcry_md_read (hd, algo);
 }
 
-void 
+void
 gcry_md_hash_buffer (int algo, void *digest,
                      const void *buffer, size_t length)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      fips_signal_error ("called in non-operational state");
+    }
   _gcry_md_hash_buffer (algo, digest, buffer, length);
 }
 
 int
 gcry_md_get_algo (gcry_md_hd_t hd)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      fips_signal_error ("used in non-operational state");
+      return 0;
+    }
   return _gcry_md_get_algo (hd);
 }
 
@@ -717,6 +854,12 @@ gcry_md_get_algo_dlen (int algo)
 int
 gcry_md_is_enabled (gcry_md_hd_t a, int algo)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      return 0;
+    }
+
   return _gcry_md_is_enabled (a, algo);
 }
 
@@ -729,6 +872,9 @@ gcry_md_is_secure (gcry_md_hd_t a)
 gcry_error_t
 gcry_md_info (gcry_md_hd_t h, int what, void *buffer, size_t *nbytes)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
+
   return _gcry_md_info (h, what, buffer, nbytes);
 }
 
@@ -753,6 +899,8 @@ gcry_md_map_name (const char* name)
 gcry_error_t
 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
   return _gcry_md_setkey (hd, key, keylen);
 }
 
@@ -762,315 +910,60 @@ gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
   _gcry_md_debug (hd, suffix);
 }
 
-gcry_error_t
-gcry_md_list (int *list, int *list_length)
-{
-  return _gcry_md_list (list, list_length);
-}
-
-gcry_error_t
-gcry_ac_data_new (gcry_ac_data_t *data)
-{
-  return _gcry_ac_data_new (data);
-}
-
-void
-gcry_ac_data_destroy (gcry_ac_data_t data)
-{
-  _gcry_ac_data_destroy (data);
-}
-
-gcry_error_t
-gcry_ac_data_copy (gcry_ac_data_t *data_cp, gcry_ac_data_t data)
-{
-  return _gcry_ac_data_copy (data_cp, data);
-}
-
-unsigned int
-gcry_ac_data_length (gcry_ac_data_t data)
-{
-  return _gcry_ac_data_length (data);
-}
-
-void
-gcry_ac_data_clear (gcry_ac_data_t data)
-{
-  _gcry_ac_data_clear (data);
-}
-
-gcry_error_t
-gcry_ac_data_set (gcry_ac_data_t data, unsigned int flags,
-                  const char *name, gcry_mpi_t mpi)
-{
-  return _gcry_ac_data_set (data, flags, name, mpi);
-}
-
-gcry_error_t
-gcry_ac_data_get_name (gcry_ac_data_t data, unsigned int flags,
-                       const char *name, gcry_mpi_t *mpi)
-{
-  return _gcry_ac_data_get_name (data, flags, name, mpi);
-}
-
-gcry_error_t
-gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int flags,
-                        unsigned int idx, const char **name, gcry_mpi_t *mpi)
-{
-  return _gcry_ac_data_get_index (data, flags, idx, name, mpi);
-}
-
-gcry_error_t
-gcry_ac_data_to_sexp (gcry_ac_data_t data, gcry_sexp_t *sexp,
-                      const char **identifiers)
-{
-  return _gcry_ac_data_to_sexp (data, sexp, identifiers);
-}
-
-gcry_error_t
-gcry_ac_data_from_sexp (gcry_ac_data_t *data, gcry_sexp_t sexp,
-                        const char **identifiers)
-{
-  return _gcry_ac_data_from_sexp (data, sexp, identifiers);
-}
-
-void
-gcry_ac_io_init (gcry_ac_io_t *ac_io, gcry_ac_io_mode_t mode,
-                 gcry_ac_io_type_t type, ...)
-{
-  va_list arg_ptr;
-
-  va_start (arg_ptr, type);
-  _gcry_ac_io_init_va (ac_io, mode, type, arg_ptr);
-  va_end (arg_ptr);
-}
-
-void
-gcry_ac_io_init_va (gcry_ac_io_t *ac_io, gcry_ac_io_mode_t mode,
-                    gcry_ac_io_type_t type, va_list ap)
-{
-  _gcry_ac_io_init_va (ac_io, mode, type, ap);
-}
-
-gcry_error_t
-gcry_ac_open (gcry_ac_handle_t *handle,
-              gcry_ac_id_t algorithm, unsigned int flags)
-{
-  return _gcry_ac_open (handle, algorithm, flags);
-}
-
-void
-gcry_ac_close (gcry_ac_handle_t handle)
-{
-  _gcry_ac_close (handle);
-}
-
-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)
-{
-  return _gcry_ac_key_init (key, handle, type, data);
-}
-
-gcry_error_t
-gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
-                           unsigned int nbits, void *spec,
-                           gcry_ac_key_pair_t *key_pair,
-                           gcry_mpi_t **miscdata)
-{
-  return _gcry_ac_key_pair_generate ( handle, nbits, spec, key_pair, miscdata);
-}
-
-gcry_ac_key_t
-gcry_ac_key_pair_extract (gcry_ac_key_pair_t keypair, gcry_ac_key_type_t which)
+gpg_error_t
+gcry_kdf_derive (const void *passphrase, size_t passphraselen,
+                 int algo, int hashalgo,
+                 const void *salt, size_t saltlen,
+                 unsigned long iterations,
+                 size_t keysize, void *keybuffer)
 {
-  return _gcry_ac_key_pair_extract (keypair, which);
-}
-
-gcry_ac_data_t
-gcry_ac_key_data_get (gcry_ac_key_t key)
-{
-  return _gcry_ac_key_data_get (key);
-}
-
-gcry_error_t
-gcry_ac_key_test (gcry_ac_handle_t handle, gcry_ac_key_t key)
-{
-  return _gcry_ac_key_test (handle, key);
-}
-
-gcry_error_t
-gcry_ac_key_get_nbits (gcry_ac_handle_t handle,
-                       gcry_ac_key_t key, unsigned int *nbits)
-{
-  return _gcry_ac_key_get_nbits (handle, key, nbits);
-}
-
-gcry_error_t
-gcry_ac_key_get_grip (gcry_ac_handle_t handle, gcry_ac_key_t key,
-                      unsigned char *key_grip)
-{
-  return _gcry_ac_key_get_grip (handle, key, key_grip);
-}
-
-void
-gcry_ac_key_destroy (gcry_ac_key_t key)
-{
-  _gcry_ac_key_destroy (key);
-}
-
-void
-gcry_ac_key_pair_destroy (gcry_ac_key_pair_t key_pair)
-{
-  _gcry_ac_key_pair_destroy (key_pair);
-}
-
-gcry_error_t
-gcry_ac_data_encode (gcry_ac_em_t method, unsigned int flags, void *options,
-                     gcry_ac_io_t *io_read, gcry_ac_io_t *io_write)
-{
-  return _gcry_ac_data_encode (method, flags, options, io_read, io_write);
-}
-
-gcry_error_t
-gcry_ac_data_decode (gcry_ac_em_t method, unsigned int flags, void *options,
-                     gcry_ac_io_t *io_read, gcry_ac_io_t *io_write)
-{
-  return _gcry_ac_data_decode (method, flags, options, io_read,  io_write);
-}
-
-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)
-{
-  return _gcry_ac_data_encrypt (handle, flags, key, 
-                                data_plain, data_encrypted);
-}
-
-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)
-{
-  return _gcry_ac_data_decrypt (handle, flags, key,
-                                data_plain, data_encrypted);
-}
-
-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)
-{
-  return _gcry_ac_data_sign (handle, key, data, data_signature);
-}
-
-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)
-{
-  return _gcry_ac_data_verify (handle, key, data, data_signature);
-}
-
-gcry_error_t
-gcry_ac_data_encrypt_scheme (gcry_ac_handle_t handle,
-                             gcry_ac_scheme_t scheme,
-                             unsigned int flags, void *opts,
-                             gcry_ac_key_t key,
-                             gcry_ac_io_t *io_message,
-                             gcry_ac_io_t *io_cipher)
-{
-  return _gcry_ac_data_encrypt_scheme (handle, scheme, flags, opts, key,
-                                       io_message, io_cipher);
-}
-
-gcry_error_t
-gcry_ac_data_decrypt_scheme (gcry_ac_handle_t handle,
-                             gcry_ac_scheme_t scheme,
-                             unsigned int flags, void *opts,
-                             gcry_ac_key_t key,
-                             gcry_ac_io_t *io_cipher,
-                             gcry_ac_io_t *io_message)
-{
-  return _gcry_ac_data_decrypt_scheme (handle, scheme, flags, opts, key,
-                                       io_cipher, io_message);
-}
-
-gcry_error_t
-gcry_ac_data_sign_scheme (gcry_ac_handle_t handle,
-                          gcry_ac_scheme_t scheme,
-                          unsigned int flags, void *opts,
-                          gcry_ac_key_t key,
-                          gcry_ac_io_t *io_message,
-                          gcry_ac_io_t *io_signature)
-{
-  return _gcry_ac_data_sign_scheme (handle, scheme, flags, opts, key,
-                                    io_message, io_signature);
-}
-
-gcry_error_t
-gcry_ac_data_verify_scheme (gcry_ac_handle_t handle,
-                            gcry_ac_scheme_t scheme,
-                            unsigned int flags, void *opts,
-                            gcry_ac_key_t key,
-                            gcry_ac_io_t *io_message,
-                            gcry_ac_io_t *io_signature)
-{
-  return _gcry_ac_data_verify_scheme (handle, scheme, flags, opts, key,
-                                      io_message, io_signature);
-}
-
-gcry_error_t
-gcry_ac_id_to_name (gcry_ac_id_t algorithm, const char **name) 
-{
-  /* This function is deprecated.  We implement it in terms of the
-     suggested replacement.  */
-  const char *tmp = _gcry_pk_algo_name (algorithm);
-  if (!*tmp)
-    return gcry_error (GPG_ERR_PUBKEY_ALGO);
-  *name = tmp;
-  return 0;
-}
-
-gcry_error_t
-gcry_ac_name_to_id (const char *name, gcry_ac_id_t *algorithm)
-{
-  /* This function is deprecated.  We implement it in terms of the
-     suggested replacement.  */
-  int algo = _gcry_pk_map_name (name);
-  if (!algo)
-    return gcry_error (GPG_ERR_PUBKEY_ALGO);
-  *algorithm = algo;
-  return 0;
+  return _gcry_kdf_derive (passphrase, passphraselen, algo, hashalgo,
+                           salt, saltlen, iterations, keysize, keybuffer);
 }
 
 void
 gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      fips_signal_fatal_error ("called in non-operational state");
+      fips_noreturn ();
+    }
   _gcry_randomize (buffer, length, level);
 }
 
 gcry_error_t
 gcry_random_add_bytes (const void *buffer, size_t length, int quality)
 {
+  if (!fips_is_operational ())
+    return gpg_error (fips_not_operational ());
   return _gcry_random_add_bytes (buffer, length, quality);
 }
 
 void *
 gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      fips_signal_fatal_error ("called in non-operational state");
+      fips_noreturn ();
+    }
+
   return _gcry_random_bytes (nbytes,level);
 }
 
 void *
 gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      fips_signal_fatal_error ("called in non-operational state");
+      fips_noreturn ();
+    }
+
   return _gcry_random_bytes_secure (nbytes, level);
 }
 
@@ -1084,6 +977,12 @@ gcry_mpi_randomize (gcry_mpi_t w,
 void
 gcry_create_nonce (void *buffer, size_t length)
 {
+  if (!fips_is_operational ())
+    {
+      (void)fips_not_operational ();
+      fips_signal_fatal_error ("called in non-operational state");
+      fips_noreturn ();
+    }
   _gcry_create_nonce (buffer, length);
 }
 
@@ -1245,43 +1144,3 @@ gcry_is_secure (const void *a)
 {
   return _gcry_is_secure (a);
 }
-
-
-gcry_error_t
-gcry_cipher_register (gcry_cipher_spec_t *cipher, int *algorithm_id,
-                      gcry_module_t *module)
-{
-  return _gcry_cipher_register (cipher, algorithm_id, module);
-}
-
-void
-gcry_cipher_unregister (gcry_module_t module)
-{
-  _gcry_cipher_unregister (module);
-}
-
-gcry_error_t
-gcry_pk_register (gcry_pk_spec_t *pubkey, unsigned int *algorithm_id,
-                  gcry_module_t *module)
-{
-  return _gcry_pk_register (pubkey, algorithm_id, module);
-}
-
-void
-gcry_pk_unregister (gcry_module_t module)
-{
-  _gcry_pk_unregister (module);
-}
-
-gcry_error_t
-gcry_md_register (gcry_md_spec_t *digest, unsigned int *algorithm_id,
-                  gcry_module_t *module)
-{
-  return _gcry_md_register (digest, algorithm_id, module);
-}
-
-void
-gcry_md_unregister (gcry_module_t module)
-{
-  _gcry_md_unregister (module);
-}