1 files changed, 175 insertions, 492 deletions

diff --git a/src/util/denom.c b/src/util/denom.c
index c1c3cdf5a..cb232c4a3 100644
--- a/src/util/denom.c
+++ b/src/util/denom.c
@@ -1,6 +1,6 @@
 /*
   This file is part of TALER
-  Copyright (C) 2021, 2022 Taler Systems SA
+  Copyright (C) 2021, 2022, 2023 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU General Public License as published by the Free Software
@@ -25,60 +25,27 @@
 enum GNUNET_GenericReturnValue
 TALER_denom_priv_create (struct TALER_DenominationPrivateKey *denom_priv,
                          struct TALER_DenominationPublicKey *denom_pub,
-                         enum TALER_DenominationCipher cipher,
+                         enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher,
                          ...)
 {
-  memset (denom_priv,
-          0,
-          sizeof (*denom_priv));
+  enum GNUNET_GenericReturnValue ret;
+  va_list ap;
+
   memset (denom_pub,
           0,
           sizeof (*denom_pub));
-
-  switch (cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  case TALER_DENOMINATION_RSA:
-    {
-      va_list ap;
-      unsigned int bits;
-
-      va_start (ap, cipher);
-      bits = va_arg (ap, unsigned int);
-      va_end (ap);
-      if (bits < 512)
-      {
-        GNUNET_break (0);
-        return GNUNET_SYSERR;
-      }
-      denom_priv->details.rsa_private_key
-        = GNUNET_CRYPTO_rsa_private_key_create (bits);
-    }
-    if (NULL == denom_priv->details.rsa_private_key)
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    denom_pub->details.rsa_public_key
-      = GNUNET_CRYPTO_rsa_private_key_get_public (
-          denom_priv->details.rsa_private_key);
-    denom_priv->cipher = TALER_DENOMINATION_RSA;
-    denom_pub->cipher = TALER_DENOMINATION_RSA;
-    return GNUNET_OK;
-  case TALER_DENOMINATION_CS:
-    GNUNET_CRYPTO_cs_private_key_generate (&denom_priv->details.cs_private_key);
-    GNUNET_CRYPTO_cs_private_key_get_public (
-      &denom_priv->details.cs_private_key,
-      &denom_pub->details.cs_public_key);
-    denom_priv->cipher = TALER_DENOMINATION_CS;
-    denom_pub->cipher = TALER_DENOMINATION_CS;
-    return GNUNET_OK;
-  default:
-    GNUNET_break (0);
-  }
-  return GNUNET_SYSERR;
+  memset (denom_priv,
+          0,
+          sizeof (*denom_priv));
+  va_start (ap,
+            cipher);
+  ret = GNUNET_CRYPTO_blind_sign_keys_create_va (
+    &denom_priv->bsign_priv_key,
+    &denom_pub->bsign_pub_key,
+    cipher,
+    ap);
+  va_end (ap);
+  return ret;
 }
 
 
@@ -88,57 +55,13 @@ TALER_denom_sign_blinded (struct TALER_BlindedDenominationSignature *denom_sig,
                           bool for_melt,
                           const struct TALER_BlindedPlanchet *blinded_planchet)
 {
-  memset (denom_sig,
-          0,
-          sizeof (*denom_sig));
-  if (blinded_planchet->cipher != denom_priv->cipher)
-  {
-    GNUNET_break (0);
+  denom_sig->blinded_sig
+    = GNUNET_CRYPTO_blind_sign (denom_priv->bsign_priv_key,
+                                for_melt ? "rm" : "rw",
+                                blinded_planchet->blinded_message);
+  if (NULL == denom_sig->blinded_sig)
     return GNUNET_SYSERR;
-  }
-  switch (denom_priv->cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  case TALER_DENOMINATION_RSA:
-    denom_sig->details.blinded_rsa_signature
-      = GNUNET_CRYPTO_rsa_sign_blinded (
-          denom_priv->details.rsa_private_key,
-          blinded_planchet->details.rsa_blinded_planchet.blinded_msg,
-          blinded_planchet->details.rsa_blinded_planchet.blinded_msg_size);
-    if (NULL == denom_sig->details.blinded_rsa_signature)
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    denom_sig->cipher = TALER_DENOMINATION_RSA;
-    return GNUNET_OK;
-  case TALER_DENOMINATION_CS:
-    {
-      struct GNUNET_CRYPTO_CsRSecret r[2];
-
-      GNUNET_CRYPTO_cs_r_derive (
-        &blinded_planchet->details.cs_blinded_planchet.nonce.nonce,
-        for_melt ? "rm" : "rw",
-        &denom_priv->details.cs_private_key,
-        r);
-      denom_sig->details.blinded_cs_answer.b =
-        GNUNET_CRYPTO_cs_sign_derive (&denom_priv->details.cs_private_key,
-                                      r,
-                                      blinded_planchet->details.
-                                      cs_blinded_planchet.c,
-                                      &blinded_planchet->details.
-                                      cs_blinded_planchet.nonce.nonce,
-                                      &denom_sig->details.blinded_cs_answer.
-                                      s_scalar);
-      denom_sig->cipher = TALER_DENOMINATION_CS;
-    }
-    return GNUNET_OK;
-  default:
-    GNUNET_break (0);
-  }
-  return GNUNET_SYSERR;
+  return GNUNET_OK;
 }
 
 
@@ -146,82 +69,24 @@ enum GNUNET_GenericReturnValue
 TALER_denom_sig_unblind (
   struct TALER_DenominationSignature *denom_sig,
   const struct TALER_BlindedDenominationSignature *bdenom_sig,
-  const union TALER_DenominationBlindingKeyP *bks,
+  const union GNUNET_CRYPTO_BlindingSecretP *bks,
   const struct TALER_CoinPubHashP *c_hash,
   const struct TALER_ExchangeWithdrawValues *alg_values,
   const struct TALER_DenominationPublicKey *denom_pub)
 {
-  if (bdenom_sig->cipher != denom_pub->cipher)
+  denom_sig->unblinded_sig
+    = GNUNET_CRYPTO_blind_sig_unblind (bdenom_sig->blinded_sig,
+                                       bks,
+                                       c_hash,
+                                       sizeof (*c_hash),
+                                       alg_values->blinding_inputs,
+                                       denom_pub->bsign_pub_key);
+  if (NULL == denom_sig->unblinded_sig)
   {
-    GNUNET_break (0);
+    GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-  switch (denom_pub->cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  case TALER_DENOMINATION_RSA:
-    denom_sig->details.rsa_signature
-      = GNUNET_CRYPTO_rsa_unblind (
-          bdenom_sig->details.blinded_rsa_signature,
-          &bks->rsa_bks,
-          denom_pub->details.rsa_public_key);
-    if (NULL == denom_sig->details.rsa_signature)
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    denom_sig->cipher = TALER_DENOMINATION_RSA;
-    return GNUNET_OK;
-  case TALER_DENOMINATION_CS:
-    {
-      struct GNUNET_CRYPTO_CsBlindingSecret bs[2];
-      struct GNUNET_CRYPTO_CsC c[2];
-      struct TALER_DenominationCSPublicRPairP r_pub_blind;
-
-      GNUNET_CRYPTO_cs_blinding_secrets_derive (&bks->nonce,
-                                                bs);
-      GNUNET_CRYPTO_cs_calc_blinded_c (
-        bs,
-        alg_values->details.cs_values.r_pub,
-        &denom_pub->details.cs_public_key,
-        &c_hash->hash,
-        sizeof(struct GNUNET_HashCode),
-        c,
-        r_pub_blind.r_pub);
-      denom_sig->details.cs_signature.r_point
-        = r_pub_blind.r_pub[bdenom_sig->details.blinded_cs_answer.b];
-      GNUNET_CRYPTO_cs_unblind (&bdenom_sig->details.blinded_cs_answer.s_scalar,
-                                &bs[bdenom_sig->details.blinded_cs_answer.b],
-                                &denom_sig->details.cs_signature.s_scalar);
-      denom_sig->cipher = TALER_DENOMINATION_CS;
-      return GNUNET_OK;
-    }
-  default:
-    GNUNET_break (0);
-  }
-  return GNUNET_SYSERR;
-}
-
-
-void
-TALER_rsa_pub_hash (const struct GNUNET_CRYPTO_RsaPublicKey *rsa,
-                    struct TALER_RsaPubHashP *h_rsa)
-{
-  GNUNET_CRYPTO_rsa_public_key_hash (rsa,
-                                     &h_rsa->hash);
-
-}
-
-
-void
-TALER_cs_pub_hash (const struct GNUNET_CRYPTO_CsPublicKey *cs,
-                   struct TALER_CsPubHashP *h_cs)
-{
-  GNUNET_CRYPTO_hash (cs,
-                      sizeof(*cs),
-                      &h_cs->hash);
+  return GNUNET_OK;
 }
 
 
@@ -229,9 +94,11 @@ void
 TALER_denom_pub_hash (const struct TALER_DenominationPublicKey *denom_pub,
                       struct TALER_DenominationHashP *denom_hash)
 {
+  struct GNUNET_CRYPTO_BlindSignPublicKey *bsp
+    = denom_pub->bsign_pub_key;
   uint32_t opt[2] = {
     htonl (denom_pub->age_mask.bits),
-    htonl ((uint32_t) denom_pub->cipher)
+    htonl ((uint32_t) bsp->cipher)
   };
   struct GNUNET_HashContext *hc;
 
@@ -239,15 +106,15 @@ TALER_denom_pub_hash (const struct TALER_DenominationPublicKey *denom_pub,
   GNUNET_CRYPTO_hash_context_read (hc,
                                    opt,
                                    sizeof (opt));
-  switch (denom_pub->cipher)
+  switch (bsp->cipher)
   {
-  case TALER_DENOMINATION_RSA:
+  case GNUNET_CRYPTO_BSA_RSA:
     {
       void *buf;
       size_t blen;
 
       blen = GNUNET_CRYPTO_rsa_public_key_encode (
-        denom_pub->details.rsa_public_key,
+        bsp->details.rsa_public_key,
         &buf);
       GNUNET_CRYPTO_hash_context_read (hc,
                                        buf,
@@ -255,10 +122,10 @@ TALER_denom_pub_hash (const struct TALER_DenominationPublicKey *denom_pub,
       GNUNET_free (buf);
     }
     break;
-  case TALER_DENOMINATION_CS:
+  case GNUNET_CRYPTO_BSA_CS:
     GNUNET_CRYPTO_hash_context_read (hc,
-                                     &denom_pub->details.cs_public_key,
-                                     sizeof(denom_pub->details.cs_public_key));
+                                     &bsp->details.cs_public_key,
+                                     sizeof(bsp->details.cs_public_key));
     break;
   default:
     GNUNET_assert (0);
@@ -268,37 +135,24 @@ TALER_denom_pub_hash (const struct TALER_DenominationPublicKey *denom_pub,
 }
 
 
-void
-TALER_denom_priv_to_pub (const struct TALER_DenominationPrivateKey *denom_priv,
-                         const struct TALER_AgeMask age_mask,
-                         struct TALER_DenominationPublicKey *denom_pub)
+const struct TALER_ExchangeWithdrawValues *
+TALER_denom_ewv_rsa_singleton ()
 {
-  switch (denom_priv->cipher)
-  {
-  case TALER_DENOMINATION_RSA:
-    denom_pub->cipher = TALER_DENOMINATION_RSA;
-    denom_pub->age_mask = age_mask;
-    denom_pub->details.rsa_public_key
-      = GNUNET_CRYPTO_rsa_private_key_get_public (
-          denom_priv->details.rsa_private_key);
-    return;
-  case TALER_DENOMINATION_CS:
-    denom_pub->cipher = TALER_DENOMINATION_CS;
-    denom_pub->age_mask = age_mask;
-    GNUNET_CRYPTO_cs_private_key_get_public (
-      &denom_priv->details.cs_private_key,
-      &denom_pub->details.cs_public_key);
-    return;
-  default:
-    GNUNET_assert (0);
-  }
+  static struct GNUNET_CRYPTO_BlindingInputValues bi = {
+    .cipher = GNUNET_CRYPTO_BSA_RSA
+  };
+  static struct TALER_ExchangeWithdrawValues alg_values = {
+    .blinding_inputs = &bi
+  };
+  return &alg_values;
 }
 
 
 enum GNUNET_GenericReturnValue
 TALER_denom_blind (
   const struct TALER_DenominationPublicKey *dk,
-  const union TALER_DenominationBlindingKeyP *coin_bks,
+  const union GNUNET_CRYPTO_BlindingSecretP *coin_bks,
+  const union GNUNET_CRYPTO_BlindSessionNonce *nonce,
   const struct TALER_AgeCommitmentHash *ach,
   const struct TALER_CoinSpendPublicKeyP *coin_pub,
   const struct TALER_ExchangeWithdrawValues *alg_values,
@@ -308,44 +162,16 @@ TALER_denom_blind (
   TALER_coin_pub_hash (coin_pub,
                        ach,
                        c_hash);
-  switch (dk->cipher)
-  {
-  case TALER_DENOMINATION_RSA:
-    blinded_planchet->cipher = dk->cipher;
-    if (GNUNET_YES !=
-        GNUNET_CRYPTO_rsa_blind (
-          &c_hash->hash,
-          &coin_bks->rsa_bks,
-          dk->details.rsa_public_key,
-          &blinded_planchet->details.rsa_blinded_planchet.blinded_msg,
-          &blinded_planchet->details.rsa_blinded_planchet.blinded_msg_size))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    return GNUNET_OK;
-  case TALER_DENOMINATION_CS:
-    {
-      struct TALER_DenominationCSPublicRPairP blinded_r_pub;
-      struct GNUNET_CRYPTO_CsBlindingSecret bs[2];
-
-      blinded_planchet->cipher = TALER_DENOMINATION_CS;
-      GNUNET_CRYPTO_cs_blinding_secrets_derive (&coin_bks->nonce,
-                                                bs);
-      GNUNET_CRYPTO_cs_calc_blinded_c (
-        bs,
-        alg_values->details.cs_values.r_pub,
-        &dk->details.cs_public_key,
-        c_hash,
-        sizeof(*c_hash),
-        blinded_planchet->details.cs_blinded_planchet.c,
-        blinded_r_pub.r_pub);
-      return GNUNET_OK;
-    }
-  default:
-    GNUNET_break (0);
+  blinded_planchet->blinded_message
+    = GNUNET_CRYPTO_message_blind_to_sign (dk->bsign_pub_key,
+                                           coin_bks,
+                                           nonce,
+                                           c_hash,
+                                           sizeof (*c_hash),
+                                           alg_values->blinding_inputs);
+  if (NULL == blinded_planchet->blinded_message)
     return GNUNET_SYSERR;
-  }
+  return GNUNET_OK;
 }
 
 
@@ -354,64 +180,20 @@ TALER_denom_pub_verify (const struct TALER_DenominationPublicKey *denom_pub,
                         const struct TALER_DenominationSignature *denom_sig,
                         const struct TALER_CoinPubHashP *c_hash)
 {
-  if (denom_pub->cipher != denom_sig->cipher)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  switch (denom_pub->cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    GNUNET_break (0);
-    return GNUNET_NO;
-  case TALER_DENOMINATION_RSA:
-    if (GNUNET_OK !=
-        GNUNET_CRYPTO_rsa_verify (&c_hash->hash,
-                                  denom_sig->details.rsa_signature,
-                                  denom_pub->details.rsa_public_key))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Coin signature is invalid\n");
-      return GNUNET_NO;
-    }
-    return GNUNET_YES;
-  case TALER_DENOMINATION_CS:
-    if (GNUNET_OK !=
-        GNUNET_CRYPTO_cs_verify (&denom_sig->details.cs_signature,
-                                 &denom_pub->details.cs_public_key,
-                                 &c_hash->hash,
-                                 sizeof(struct GNUNET_HashCode)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Coin signature is invalid\n");
-      return GNUNET_NO;
-    }
-    return GNUNET_YES;
-  default:
-    GNUNET_assert (0);
-  }
+  return GNUNET_CRYPTO_blind_sig_verify (denom_pub->bsign_pub_key,
+                                         denom_sig->unblinded_sig,
+                                         c_hash,
+                                         sizeof (*c_hash));
 }
 
 
 void
 TALER_denom_pub_free (struct TALER_DenominationPublicKey *denom_pub)
 {
-  switch (denom_pub->cipher)
+  if (NULL != denom_pub->bsign_pub_key)
   {
-  case TALER_DENOMINATION_INVALID:
-    return;
-  case TALER_DENOMINATION_RSA:
-    if (NULL != denom_pub->details.rsa_public_key)
-    {
-      GNUNET_CRYPTO_rsa_public_key_free (denom_pub->details.rsa_public_key);
-      denom_pub->details.rsa_public_key = NULL;
-    }
-    denom_pub->cipher = TALER_DENOMINATION_INVALID;
-    return;
-  case TALER_DENOMINATION_CS:
-    return;
-  default:
-    GNUNET_assert (0);
+    GNUNET_CRYPTO_blind_sign_pub_decref (denom_pub->bsign_pub_key);
+    denom_pub->bsign_pub_key = NULL;
   }
 }
 
@@ -419,22 +201,10 @@ TALER_denom_pub_free (struct TALER_DenominationPublicKey *denom_pub)
 void
 TALER_denom_priv_free (struct TALER_DenominationPrivateKey *denom_priv)
 {
-  switch (denom_priv->cipher)
+  if (NULL != denom_priv->bsign_priv_key)
   {
-  case TALER_DENOMINATION_INVALID:
-    return;
-  case TALER_DENOMINATION_RSA:
-    if (NULL != denom_priv->details.rsa_private_key)
-    {
-      GNUNET_CRYPTO_rsa_private_key_free (denom_priv->details.rsa_private_key);
-      denom_priv->details.rsa_private_key = NULL;
-    }
-    denom_priv->cipher = TALER_DENOMINATION_INVALID;
-    return;
-  case TALER_DENOMINATION_CS:
-    return;
-  default:
-    GNUNET_assert (0);
+    GNUNET_CRYPTO_blind_sign_priv_decref (denom_priv->bsign_priv_key);
+    denom_priv->bsign_priv_key = NULL;
   }
 }
 
@@ -442,22 +212,10 @@ TALER_denom_priv_free (struct TALER_DenominationPrivateKey *denom_priv)
 void
 TALER_denom_sig_free (struct TALER_DenominationSignature *denom_sig)
 {
-  switch (denom_sig->cipher)
+  if (NULL != denom_sig->unblinded_sig)
   {
-  case TALER_DENOMINATION_INVALID:
-    return;
-  case TALER_DENOMINATION_RSA:
-    if (NULL != denom_sig->details.rsa_signature)
-    {
-      GNUNET_CRYPTO_rsa_signature_free (denom_sig->details.rsa_signature);
-      denom_sig->details.rsa_signature = NULL;
-    }
-    denom_sig->cipher = TALER_DENOMINATION_INVALID;
-    return;
-  case TALER_DENOMINATION_CS:
-    return;
-  default:
-    GNUNET_assert (0);
+    GNUNET_CRYPTO_unblinded_sig_decref (denom_sig->unblinded_sig);
+    denom_sig->unblinded_sig = NULL;
   }
 }
 
@@ -466,89 +224,73 @@ void
 TALER_blinded_denom_sig_free (
   struct TALER_BlindedDenominationSignature *denom_sig)
 {
-  switch (denom_sig->cipher)
+  if (NULL != denom_sig->blinded_sig)
   {
-  case TALER_DENOMINATION_INVALID:
-    return;
-  case TALER_DENOMINATION_RSA:
-    if (NULL != denom_sig->details.blinded_rsa_signature)
-    {
-      GNUNET_CRYPTO_rsa_signature_free (
-        denom_sig->details.blinded_rsa_signature);
-      denom_sig->details.blinded_rsa_signature = NULL;
-    }
-    denom_sig->cipher = TALER_DENOMINATION_INVALID;
-    return;
-  case TALER_DENOMINATION_CS:
-    return;
-  default:
-    GNUNET_assert (0);
+    GNUNET_CRYPTO_blinded_sig_decref (denom_sig->blinded_sig);
+    denom_sig->blinded_sig = NULL;
   }
 }
 
 
 void
-TALER_denom_pub_deep_copy (struct TALER_DenominationPublicKey *denom_dst,
-                           const struct TALER_DenominationPublicKey *denom_src)
+TALER_denom_ewv_free (struct TALER_ExchangeWithdrawValues *ewv)
 {
-  *denom_dst = *denom_src; /* shallow copy */
-  switch (denom_src->cipher)
-  {
-  case TALER_DENOMINATION_RSA:
-    denom_dst->details.rsa_public_key
-      = GNUNET_CRYPTO_rsa_public_key_dup (
-          denom_src->details.rsa_public_key);
+  if (ewv == TALER_denom_ewv_rsa_singleton ())
     return;
-  case TALER_DENOMINATION_CS:
+  if (ewv->blinding_inputs ==
+      TALER_denom_ewv_rsa_singleton ()->blinding_inputs)
+  {
+    ewv->blinding_inputs = NULL;
     return;
-  default:
-    GNUNET_assert (0);
+  }
+  if (NULL != ewv->blinding_inputs)
+  {
+    GNUNET_CRYPTO_blinding_input_values_decref (ewv->blinding_inputs);
+    ewv->blinding_inputs = NULL;
   }
 }
 
 
 void
-TALER_denom_sig_deep_copy (struct TALER_DenominationSignature *denom_dst,
-                           const struct TALER_DenominationSignature *denom_src)
+TALER_denom_ewv_copy (struct TALER_ExchangeWithdrawValues *bi_dst,
+                      const struct TALER_ExchangeWithdrawValues *bi_src)
 {
-  *denom_dst = *denom_src; /* shallow copy */
-  switch (denom_src->cipher)
+  if (bi_src == TALER_denom_ewv_rsa_singleton ())
   {
-  case TALER_DENOMINATION_INVALID:
-    return;
-  case TALER_DENOMINATION_RSA:
-    denom_dst->details.rsa_signature
-      = GNUNET_CRYPTO_rsa_signature_dup (
-          denom_src->details.rsa_signature);
-    return;
-  case TALER_DENOMINATION_CS:
+    *bi_dst = *bi_src;
     return;
-  default:
-    GNUNET_assert (0);
   }
+  bi_dst->blinding_inputs
+    = GNUNET_CRYPTO_blinding_input_values_incref (bi_src->blinding_inputs);
+}
+
+
+void
+TALER_denom_pub_copy (struct TALER_DenominationPublicKey *denom_dst,
+                      const struct TALER_DenominationPublicKey *denom_src)
+{
+  denom_dst->age_mask = denom_src->age_mask;
+  denom_dst->bsign_pub_key
+    = GNUNET_CRYPTO_bsign_pub_incref (denom_src->bsign_pub_key);
 }
 
 
 void
-TALER_blinded_denom_sig_deep_copy (
+TALER_denom_sig_copy (struct TALER_DenominationSignature *denom_dst,
+                      const struct TALER_DenominationSignature *denom_src)
+{
+  denom_dst->unblinded_sig
+    = GNUNET_CRYPTO_ub_sig_incref (denom_src->unblinded_sig);
+}
+
+
+void
+TALER_blinded_denom_sig_copy (
   struct TALER_BlindedDenominationSignature *denom_dst,
   const struct TALER_BlindedDenominationSignature *denom_src)
 {
-  *denom_dst = *denom_src; /* shallow copy */
-  switch (denom_src->cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    return;
-  case TALER_DENOMINATION_RSA:
-    denom_dst->details.blinded_rsa_signature
-      = GNUNET_CRYPTO_rsa_signature_dup (
-          denom_src->details.blinded_rsa_signature);
-    return;
-  case TALER_DENOMINATION_CS:
-    return;
-  default:
-    GNUNET_assert (0);
-  }
+  denom_dst->blinded_sig
+    = GNUNET_CRYPTO_blind_sig_incref (denom_src->blinded_sig);
 }
 
 
@@ -556,24 +298,14 @@ int
 TALER_denom_pub_cmp (const struct TALER_DenominationPublicKey *denom1,
                      const struct TALER_DenominationPublicKey *denom2)
 {
-  if (denom1->cipher != denom2->cipher)
-    return (denom1->cipher > denom2->cipher) ? 1 : -1;
+  if (denom1->bsign_pub_key->cipher !=
+      denom2->bsign_pub_key->cipher)
+    return (denom1->bsign_pub_key->cipher >
+            denom2->bsign_pub_key->cipher) ? 1 : -1;
   if (denom1->age_mask.bits != denom2->age_mask.bits)
     return (denom1->age_mask.bits > denom2->age_mask.bits) ? 1 : -1;
-  switch (denom1->cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    return 0;
-  case TALER_DENOMINATION_RSA:
-    return GNUNET_CRYPTO_rsa_public_key_cmp (denom1->details.rsa_public_key,
-                                             denom2->details.rsa_public_key);
-  case TALER_DENOMINATION_CS:
-    return GNUNET_memcmp (&denom1->details.cs_public_key,
-                          &denom2->details.cs_public_key);
-  default:
-    GNUNET_assert (0);
-  }
-  return -2;
+  return GNUNET_CRYPTO_bsign_pub_cmp (denom1->bsign_pub_key,
+                                      denom2->bsign_pub_key);
 }
 
 
@@ -581,22 +313,8 @@ int
 TALER_denom_sig_cmp (const struct TALER_DenominationSignature *sig1,
                      const struct TALER_DenominationSignature *sig2)
 {
-  if (sig1->cipher != sig2->cipher)
-    return (sig1->cipher > sig2->cipher) ? 1 : -1;
-  switch (sig1->cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    return 0;
-  case TALER_DENOMINATION_RSA:
-    return GNUNET_CRYPTO_rsa_signature_cmp (sig1->details.rsa_signature,
-                                            sig2->details.rsa_signature);
-  case TALER_DENOMINATION_CS:
-    return GNUNET_memcmp (&sig1->details.cs_signature,
-                          &sig2->details.cs_signature);
-  default:
-    GNUNET_assert (0);
-  }
-  return -2;
+  return GNUNET_CRYPTO_ub_sig_cmp (sig1->unblinded_sig,
+                                   sig1->unblinded_sig);
 }
 
 
@@ -605,27 +323,8 @@ TALER_blinded_planchet_cmp (
   const struct TALER_BlindedPlanchet *bp1,
   const struct TALER_BlindedPlanchet *bp2)
 {
-  if (bp1->cipher != bp2->cipher)
-    return (bp1->cipher > bp2->cipher) ? 1 : -1;
-  switch (bp1->cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    return 0;
-  case TALER_DENOMINATION_RSA:
-    if (bp1->details.rsa_blinded_planchet.blinded_msg_size !=
-        bp2->details.rsa_blinded_planchet.blinded_msg_size)
-      return (bp1->details.rsa_blinded_planchet.blinded_msg_size >
-              bp2->details.rsa_blinded_planchet.blinded_msg_size) ? 1 : -1;
-    return memcmp (bp1->details.rsa_blinded_planchet.blinded_msg,
-                   bp2->details.rsa_blinded_planchet.blinded_msg,
-                   bp1->details.rsa_blinded_planchet.blinded_msg_size);
-  case TALER_DENOMINATION_CS:
-    return GNUNET_memcmp (&bp1->details.cs_blinded_planchet,
-                          &bp2->details.cs_blinded_planchet);
-  default:
-    GNUNET_assert (0);
-  }
-  return -2;
+  return GNUNET_CRYPTO_blinded_message_cmp (bp1->blinded_message,
+                                            bp2->blinded_message);
 }
 
 
@@ -634,22 +333,8 @@ TALER_blinded_denom_sig_cmp (
   const struct TALER_BlindedDenominationSignature *sig1,
   const struct TALER_BlindedDenominationSignature *sig2)
 {
-  if (sig1->cipher != sig2->cipher)
-    return (sig1->cipher > sig2->cipher) ? 1 : -1;
-  switch (sig1->cipher)
-  {
-  case TALER_DENOMINATION_INVALID:
-    return 0;
-  case TALER_DENOMINATION_RSA:
-    return GNUNET_CRYPTO_rsa_signature_cmp (sig1->details.blinded_rsa_signature,
-                                            sig2->details.blinded_rsa_signature);
-  case TALER_DENOMINATION_CS:
-    return GNUNET_memcmp (&sig1->details.blinded_cs_answer,
-                          &sig2->details.blinded_cs_answer);
-  default:
-    GNUNET_assert (0);
-  }
-  return -2;
+  return GNUNET_CRYPTO_blind_sig_cmp (sig1->blinded_sig,
+                                      sig1->blinded_sig);
 }
 
 
@@ -657,31 +342,31 @@ void
 TALER_blinded_planchet_hash_ (const struct TALER_BlindedPlanchet *bp,
                               struct GNUNET_HashContext *hash_context)
 {
-  uint32_t cipher = htonl (bp->cipher);
+  const struct GNUNET_CRYPTO_BlindedMessage *bm = bp->blinded_message;
+  uint32_t cipher = htonl (bm->cipher);
 
   GNUNET_CRYPTO_hash_context_read (hash_context,
                                    &cipher,
                                    sizeof (cipher));
-  switch (bp->cipher)
+  switch (bm->cipher)
   {
-  case TALER_DENOMINATION_INVALID:
-    break;
-  case TALER_DENOMINATION_RSA:
+  case GNUNET_CRYPTO_BSA_INVALID:
+    GNUNET_break (0);
+    return;
+  case GNUNET_CRYPTO_BSA_RSA:
     GNUNET_CRYPTO_hash_context_read (
       hash_context,
-      bp->details.rsa_blinded_planchet.blinded_msg,
-      bp->details.rsa_blinded_planchet.blinded_msg_size);
-    break;
-  case TALER_DENOMINATION_CS:
+      bm->details.rsa_blinded_message.blinded_msg,
+      bm->details.rsa_blinded_message.blinded_msg_size);
+    return;
+  case GNUNET_CRYPTO_BSA_CS:
     GNUNET_CRYPTO_hash_context_read (
       hash_context,
-      &bp->details.cs_blinded_planchet,
-      sizeof (bp->details.cs_blinded_planchet));
-    break;
-  default:
-    GNUNET_assert (0);
-    break;
+      &bm->details.cs_blinded_message,
+      sizeof (bm->details.cs_blinded_message));
+    return;
   }
+  GNUNET_assert (0);
 }
 
 
@@ -689,14 +374,17 @@ void
 TALER_planchet_blinding_secret_create (
   const struct TALER_PlanchetMasterSecretP *ps,
   const struct TALER_ExchangeWithdrawValues *alg_values,
-  union TALER_DenominationBlindingKeyP *bks)
+  union GNUNET_CRYPTO_BlindingSecretP *bks)
 {
-  switch (alg_values->cipher)
+  const struct GNUNET_CRYPTO_BlindingInputValues *bi =
+    alg_values->blinding_inputs;
+
+  switch (bi->cipher)
   {
-  case TALER_DENOMINATION_INVALID:
+  case GNUNET_CRYPTO_BSA_INVALID:
     GNUNET_break (0);
     return;
-  case TALER_DENOMINATION_RSA:
+  case GNUNET_CRYPTO_BSA_RSA:
     GNUNET_assert (GNUNET_YES ==
                    GNUNET_CRYPTO_kdf (&bks->rsa_bks,
                                       sizeof (bks->rsa_bks),
@@ -707,7 +395,7 @@ TALER_planchet_blinding_secret_create (
                                       NULL,
                                       0));
     return;
-  case TALER_DENOMINATION_CS:
+  case GNUNET_CRYPTO_BSA_CS:
     GNUNET_assert (GNUNET_YES ==
                    GNUNET_CRYPTO_kdf (&bks->nonce,
                                       sizeof (bks->nonce),
@@ -715,14 +403,13 @@ TALER_planchet_blinding_secret_create (
                                       strlen ("bseed"),
                                       ps,
                                       sizeof(*ps),
-                                      &alg_values->details.cs_values,
-                                      sizeof(alg_values->details.cs_values),
+                                      &bi->details.cs_values,
+                                      sizeof(bi->details.cs_values),
                                       NULL,
                                       0));
     return;
-  default:
-    GNUNET_break (0);
   }
+  GNUNET_assert (0);
 }
 
 
@@ -732,9 +419,18 @@ TALER_planchet_setup_coin_priv (
   const struct TALER_ExchangeWithdrawValues *alg_values,
   struct TALER_CoinSpendPrivateKeyP *coin_priv)
 {
-  switch (alg_values->cipher)
+  const struct GNUNET_CRYPTO_BlindingInputValues *bi
+    = alg_values->blinding_inputs;
+
+  switch (bi->cipher)
   {
-  case TALER_DENOMINATION_RSA:
+  case GNUNET_CRYPTO_BSA_INVALID:
+    GNUNET_break (0);
+    memset (coin_priv,
+            0,
+            sizeof (*coin_priv));
+    return;
+  case GNUNET_CRYPTO_BSA_RSA:
     GNUNET_assert (GNUNET_YES ==
                    GNUNET_CRYPTO_kdf (coin_priv,
                                       sizeof (*coin_priv),
@@ -744,8 +440,8 @@ TALER_planchet_setup_coin_priv (
                                       sizeof(*ps),
                                       NULL,
                                       0));
-    break;
-  case TALER_DENOMINATION_CS:
+    return;
+  case GNUNET_CRYPTO_BSA_CS:
     GNUNET_assert (GNUNET_YES ==
                    GNUNET_CRYPTO_kdf (coin_priv,
                                       sizeof (*coin_priv),
@@ -753,37 +449,24 @@ TALER_planchet_setup_coin_priv (
                                       strlen ("coin"),
                                       ps,
                                       sizeof(*ps),
-                                      &alg_values->details.cs_values,
-                                      sizeof(alg_values->details.cs_values),
+                                      &bi->details.cs_values,
+                                      sizeof(bi->details.cs_values),
                                       NULL,
                                       0));
-    break;
-  default:
-    GNUNET_break (0);
     return;
   }
+  GNUNET_assert (0);
 }
 
 
 void
 TALER_blinded_planchet_free (struct TALER_BlindedPlanchet *blinded_planchet)
 {
-  switch (blinded_planchet->cipher)
+  if (NULL != blinded_planchet->blinded_message)
   {
-  case TALER_DENOMINATION_INVALID:
-    GNUNET_break (0);
-    return;
-  case TALER_DENOMINATION_RSA:
-    GNUNET_free (blinded_planchet->details.rsa_blinded_planchet.blinded_msg);
-    return;
-  case TALER_DENOMINATION_CS:
-    memset (blinded_planchet,
-            0,
-            sizeof (*blinded_planchet));
-    /* nothing to do for CS */
-    return;
+    GNUNET_CRYPTO_blinded_message_decref (blinded_planchet->blinded_message);
+    blinded_planchet->blinded_message = NULL;
   }
-  GNUNET_assert (0);
 }