exchange

Base system with REST service to issue digital coins, run by the payment service provider
Log | Files | Refs | Submodules | README | LICENSE

exchange_api_refresh_common.c (11673B)


      1 /*
      2   This file is part of TALER
      3   Copyright (C) 2015-2025 Taler Systems SA
      4 
      5   TALER is free software; you can redistribute it and/or modify it under the
      6   terms of the GNU General Public License as published by the Free Software
      7   Foundation; either version 3, or (at your option) any later version.
      8 
      9   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
     10   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
     11   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
     12 
     13   You should have received a copy of the GNU General Public License along with
     14   TALER; see the file COPYING.  If not, see
     15   <http://www.gnu.org/licenses/>
     16 */
     17 /**
     18  * @file lib/exchange_api_refresh_common.c
     19  * @brief Serialization logic shared between melt and reveal steps during refreshing
     20  * @author Christian Grothoff
     21  * @author Özgür Kesim
     22  */
     23 #include "exchange_api_refresh_common.h"
     24 
     25 
     26 void
     27 TALER_EXCHANGE_free_melt_data (struct MeltData *md)
     28 {
     29   for (unsigned int k = 0; k < TALER_CNC_KAPPA; k++)
     30   {
     31     if (NULL != md->kappa_blinded_planchets[k])
     32       for (unsigned int i = 0; i < md->num_fresh_coins; i++)
     33         TALER_blinded_planchet_free (&md->kappa_blinded_planchets[k][i]);
     34     GNUNET_free (md->kappa_blinded_planchets[k]);
     35     GNUNET_free (md->kappa_transfer_pubs[k]);
     36   }
     37   GNUNET_free (md->denoms_h);
     38   GNUNET_free (md->denom_pubs);
     39   TALER_denom_pub_free (&md->melted_coin.pub_key);
     40   TALER_denom_sig_free (&md->melted_coin.sig);
     41   if (NULL != md->fcds)
     42   {
     43     for (unsigned int j = 0; j<md->num_fresh_coins; j++)
     44     {
     45       struct FreshCoinData *fcd = &md->fcds[j];
     46 
     47       TALER_denom_pub_free (&fcd->fresh_pk);
     48       for (size_t i = 0; i < TALER_CNC_KAPPA; i++)
     49       {
     50         TALER_age_commitment_proof_free (fcd->age_commitment_proofs[i]);
     51         GNUNET_free (fcd->age_commitment_proofs[i]);
     52       }
     53     }
     54     GNUNET_free (md->fcds);
     55   }
     56   /* Finally, clean up a bit... */
     57   GNUNET_CRYPTO_zero_keys (md,
     58                            sizeof (struct MeltData));
     59 }
     60 
     61 
     62 enum GNUNET_GenericReturnValue
     63 TALER_EXCHANGE_get_melt_data (
     64   const struct TALER_PublicRefreshMasterSeedP *rms,
     65   const struct TALER_EXCHANGE_MeltInput *rd,
     66   const struct TALER_BlindingMasterSeedP *blinding_seed,
     67   const struct TALER_ExchangeBlindingValues *blinding_values,
     68   enum TALER_RefreshCommitmentVersion rc_version,
     69   struct MeltData *md)
     70 {
     71   struct TALER_Amount total;
     72   struct TALER_CoinSpendPublicKeyP coin_pub;
     73   struct TALER_KappaHashBlindedPlanchetsP k_h_bps;
     74   union GNUNET_CRYPTO_BlindSessionNonce nonces[rd->num_fresh_denom_pubs];
     75   bool is_cs[rd->num_fresh_denom_pubs];
     76   bool uses_cs = false;
     77 
     78   GNUNET_CRYPTO_eddsa_key_get_public (&rd->melt_priv.eddsa_priv,
     79                                       &coin_pub.eddsa_pub);
     80   switch (rc_version)
     81   {
     82   case TALER_REFRESH_COMMITMENT_VERSION_LEGACY_VDOLDPLUS_BROKEN:
     83   case TALER_REFRESH_COMMITMENT_VERSION_CURRENT:
     84     break;
     85   default:
     86     /* v27 is not implemented by this library */
     87     GNUNET_break (0);
     88     return GNUNET_SYSERR;
     89   }
     90   memset (md,
     91           0,
     92           sizeof (*md));
     93   /* build up melt data structure */
     94   md->rc_version = rc_version;
     95   md->refresh_seed = *rms;
     96   md->num_fresh_coins = rd->num_fresh_denom_pubs;
     97   md->melted_coin.coin_priv = rd->melt_priv;
     98   md->melted_coin.melt_amount_with_fee = rd->melt_amount;
     99   md->melted_coin.fee_melt = rd->melt_pk.fees.refresh;
    100   md->melted_coin.original_value = rd->melt_pk.value;
    101   md->melted_coin.expire_deposit = rd->melt_pk.expire_deposit;
    102   md->melted_coin.age_commitment_proof = rd->melt_age_commitment_proof;
    103   md->melted_coin.h_age_commitment = rd->melt_h_age_commitment;
    104   md->no_blinding_seed = (NULL == blinding_seed);
    105   if (NULL != blinding_seed)
    106     md->blinding_seed = *blinding_seed;
    107 
    108   GNUNET_assert (GNUNET_OK ==
    109                  TALER_amount_set_zero (rd->melt_amount.currency,
    110                                         &total));
    111   TALER_denom_pub_copy (&md->melted_coin.pub_key,
    112                         &rd->melt_pk.key);
    113   TALER_denom_sig_copy (&md->melted_coin.sig,
    114                         &rd->melt_sig);
    115   md->fcds = GNUNET_new_array (md->num_fresh_coins,
    116                                struct FreshCoinData);
    117   md->denoms_h =
    118     GNUNET_new_array (md->num_fresh_coins,
    119                       struct  TALER_DenominationHashP);
    120   md->denom_pubs =
    121     GNUNET_new_array (md->num_fresh_coins,
    122                       const struct  TALER_DenominationPublicKey*);
    123 
    124   for (unsigned int j = 0; j<md->num_fresh_coins; j++)
    125   {
    126     struct FreshCoinData *fcd = &md->fcds[j];
    127 
    128     md->denoms_h[j] = rd->fresh_denom_pubs[j].h_key;
    129     md->denom_pubs[j] = &rd->fresh_denom_pubs[j].key;
    130 
    131     TALER_denom_pub_copy (&fcd->fresh_pk,
    132                           &rd->fresh_denom_pubs[j].key);
    133     GNUNET_assert (NULL != fcd->fresh_pk.bsign_pub_key);
    134     if (blinding_values[j].blinding_inputs->cipher !=
    135         fcd->fresh_pk.bsign_pub_key->cipher)
    136     {
    137       GNUNET_break (0);
    138       TALER_EXCHANGE_free_melt_data (md);
    139       return GNUNET_SYSERR;
    140     }
    141     switch (fcd->fresh_pk.bsign_pub_key->cipher)
    142     {
    143     case GNUNET_CRYPTO_BSA_INVALID:
    144       GNUNET_break (0);
    145       TALER_EXCHANGE_free_melt_data (md);
    146       return GNUNET_SYSERR;
    147     case GNUNET_CRYPTO_BSA_RSA:
    148       is_cs[j] = false;
    149       break;
    150     case GNUNET_CRYPTO_BSA_CS:
    151       uses_cs = true;
    152       is_cs[j] = true;
    153       break;
    154     }
    155     if ( (0 >
    156           TALER_amount_add (&total,
    157                             &total,
    158                             &rd->fresh_denom_pubs[j].value)) ||
    159          (0 >
    160           TALER_amount_add (&total,
    161                             &total,
    162                             &rd->fresh_denom_pubs[j].fees.withdraw)) )
    163     {
    164       GNUNET_break (0);
    165       TALER_EXCHANGE_free_melt_data (md);
    166       return GNUNET_SYSERR;
    167     }
    168   }
    169 
    170   /* verify that melt_amount is above total cost */
    171   if (1 ==
    172       TALER_amount_cmp (&total,
    173                         &rd->melt_amount) )
    174   {
    175     /* Eh, this operation is more expensive than the
    176        @a melt_amount. This is not OK. */
    177     GNUNET_break (0);
    178     TALER_EXCHANGE_free_melt_data (md);
    179     return GNUNET_SYSERR;
    180   }
    181   /**
    182    * Generate the blinding seeds and nonces for CS.
    183    * Note that blinding_seed was prepared upstream,
    184    * in TALER_EXCHANGE_melt(), as preparation for
    185    * the request to `/blinding-prepare`.
    186    */
    187   memset (nonces,
    188           0,
    189           sizeof(nonces[0]) * rd->num_fresh_denom_pubs);
    190   if (uses_cs)
    191   {
    192     GNUNET_assert (! md->no_blinding_seed);
    193     TALER_cs_derive_blind_nonces_from_seed (
    194       blinding_seed,
    195       true, /* for melt */
    196       md->num_fresh_coins,
    197       is_cs,
    198       nonces);
    199   }
    200   /**
    201    * Generate the kappa private seeds for the batches.
    202    */
    203   TALER_refresh_expand_seed_to_kappa_batch_seeds (
    204     &md->refresh_seed,
    205     &rd->melt_priv,
    206     &md->kappa_batch_seeds);
    207   /**
    208    * Build up all candidates for coin planchets
    209    */
    210   for (unsigned int k = 0; k<TALER_CNC_KAPPA; k++)
    211   {
    212     struct TALER_PlanchetMasterSecretP
    213       planchet_secrets[md->num_fresh_coins];
    214     struct TALER_PlanchetDetail planchet_details[md->num_fresh_coins];
    215 
    216     md->kappa_blinded_planchets[k] =
    217       GNUNET_new_array (md->num_fresh_coins,
    218                         struct TALER_BlindedPlanchet);
    219     md->kappa_transfer_pubs[k] =
    220       GNUNET_new_array (md->num_fresh_coins,
    221                         struct TALER_TransferPublicKeyP);
    222 
    223     TALER_refresh_expand_batch_seed_to_transfer_data (
    224       &md->kappa_batch_seeds.tuple[k],
    225       &coin_pub,
    226       md->num_fresh_coins,
    227       planchet_secrets,
    228       md->kappa_transfer_pubs[k]);
    229 
    230     for (unsigned int j = 0; j<md->num_fresh_coins; j++)
    231     {
    232       struct FreshCoinData *fcd = &md->fcds[j];
    233       struct TALER_CoinSpendPrivateKeyP *coin_priv = &fcd->coin_priv;
    234       union GNUNET_CRYPTO_BlindingSecretP *bks = &fcd->bks[k];
    235       struct TALER_CoinPubHashP c_hash;
    236       struct TALER_AgeCommitmentHashP ach;
    237       struct TALER_AgeCommitmentHashP *pah;
    238 
    239       fcd->ps[k] = planchet_secrets[j];
    240       TALER_planchet_setup_coin_priv (&planchet_secrets[j],
    241                                       &blinding_values[j],
    242                                       coin_priv);
    243       TALER_planchet_blinding_secret_create (&planchet_secrets[j],
    244                                              &blinding_values[j],
    245                                              bks);
    246       if (NULL != rd->melt_age_commitment_proof)
    247       {
    248         fcd->age_commitment_proofs[k] =
    249           GNUNET_new (struct TALER_AgeCommitmentProof);
    250         GNUNET_assert (GNUNET_OK ==
    251                        TALER_age_commitment_proof_derive_from_secret (
    252                          md->melted_coin.age_commitment_proof,
    253                          &planchet_secrets[j],
    254                          fcd->age_commitment_proofs[k]));
    255         TALER_age_commitment_hash (
    256           &fcd->age_commitment_proofs[k]->commitment,
    257           &ach);
    258         pah = &ach;
    259       }
    260       else
    261       {
    262         pah = NULL;
    263       }
    264 
    265       if (GNUNET_OK !=
    266           TALER_planchet_prepare (&fcd->fresh_pk,
    267                                   &blinding_values[j],
    268                                   bks,
    269                                   is_cs[j] ? &nonces[j] : NULL,
    270                                   coin_priv,
    271                                   pah,
    272                                   &c_hash,
    273                                   &planchet_details[j]))
    274       {
    275         GNUNET_break_op (0);
    276         TALER_EXCHANGE_free_melt_data (md);
    277         return GNUNET_SYSERR;
    278       }
    279       md->kappa_blinded_planchets[k][j] =
    280         planchet_details[j].blinded_planchet;
    281     }
    282     /**
    283      * Compute the hash of this batch of blinded planchets
    284      */
    285     TALER_wallet_blinded_planchet_details_hash (
    286       rd->num_fresh_denom_pubs,
    287       planchet_details,
    288       &k_h_bps.tuple[k]);
    289   }
    290 
    291   /* Finally, compute refresh commitment */
    292   if (TALER_REFRESH_COMMITMENT_VERSION_LEGACY_VDOLDPLUS_BROKEN == rc_version)
    293   {
    294     TALER_refresh_get_commitment_legacy_vDOLDPLUS_broken (
    295       &md->rc,
    296       &md->refresh_seed,
    297       uses_cs
    298       ? &md->blinding_seed
    299       : NULL,
    300       &k_h_bps,
    301       &coin_pub,
    302       &rd->melt_amount);
    303   }
    304   else
    305   {
    306     struct TALER_KappaTransferPublicKeys k_tr_pubs = {
    307       .num_transfer_pubs = md->num_fresh_coins,
    308     };
    309 
    310     for (uint8_t k=0; k<TALER_CNC_KAPPA; k++)
    311       k_tr_pubs.batch[k] = md->kappa_transfer_pubs[k];
    312 
    313     TALER_refresh_get_commitment (&md->rc,
    314                                   &md->refresh_seed,
    315                                   uses_cs
    316                                          ? &md->blinding_seed
    317                                          : NULL,
    318                                   &k_tr_pubs,
    319                                   &k_h_bps,
    320                                   &coin_pub,
    321                                   &rd->melt_amount);
    322   }
    323   return GNUNET_OK;
    324 }
    325 
    326 
    327 /**
    328  * First version of the exchange protocol that accepts the refresh
    329  * commitment with the transfer public keys (#11862).
    330  */
    331 #define EXCHANGE_PROTOCOL_REFRESH_COMMITMENT_CURRENT 45
    332 
    333 
    334 enum TALER_RefreshCommitmentVersion
    335 TALER_EXCHANGE_refresh_commitment_version (
    336   const struct TALER_EXCHANGE_Keys *keys)
    337 {
    338   struct TALER_JSON_ProtocolVersion pv;
    339   char dummy;
    340 
    341   if ( (NULL == keys->version) ||
    342        (3 != sscanf (keys->version,
    343                      "%u:%u:%u%c",
    344                      &pv.current,
    345                      &pv.revision,
    346                      &pv.age,
    347                      &dummy)) )
    348   {
    349     GNUNET_break_op (0);
    350     return TALER_REFRESH_COMMITMENT_VERSION_CURRENT;
    351   }
    352   if (pv.current < EXCHANGE_PROTOCOL_REFRESH_COMMITMENT_CURRENT)
    353     return TALER_REFRESH_COMMITMENT_VERSION_LEGACY_VDOLDPLUS_BROKEN;
    354   return TALER_REFRESH_COMMITMENT_VERSION_CURRENT;
    355 }