LCOV - code coverage report
Current view: top level - lib - exchange_api_refresh_common.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 86.5 % 156 135
Test Date: 2026-11-18 17:34:04 Functions: 100.0 % 3 3

            Line data    Source code
       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           88 : TALER_EXCHANGE_free_melt_data (struct MeltData *md)
      28              : {
      29          352 :   for (unsigned int k = 0; k < TALER_CNC_KAPPA; k++)
      30              :   {
      31          264 :     if (NULL != md->kappa_blinded_planchets[k])
      32         1035 :       for (unsigned int i = 0; i < md->num_fresh_coins; i++)
      33          774 :         TALER_blinded_planchet_free (&md->kappa_blinded_planchets[k][i]);
      34          264 :     GNUNET_free (md->kappa_blinded_planchets[k]);
      35          264 :     GNUNET_free (md->kappa_transfer_pubs[k]);
      36              :   }
      37           88 :   GNUNET_free (md->denoms_h);
      38           88 :   GNUNET_free (md->denom_pubs);
      39           88 :   TALER_denom_pub_free (&md->melted_coin.pub_key);
      40           88 :   TALER_denom_sig_free (&md->melted_coin.sig);
      41           88 :   if (NULL != md->fcds)
      42              :   {
      43          345 :     for (unsigned int j = 0; j<md->num_fresh_coins; j++)
      44              :     {
      45          258 :       struct FreshCoinData *fcd = &md->fcds[j];
      46              : 
      47          258 :       TALER_denom_pub_free (&fcd->fresh_pk);
      48         1032 :       for (size_t i = 0; i < TALER_CNC_KAPPA; i++)
      49              :       {
      50          774 :         TALER_age_commitment_proof_free (fcd->age_commitment_proofs[i]);
      51          774 :         GNUNET_free (fcd->age_commitment_proofs[i]);
      52              :       }
      53              :     }
      54           87 :     GNUNET_free (md->fcds);
      55              :   }
      56              :   /* Finally, clean up a bit... */
      57           88 :   GNUNET_CRYPTO_zero_keys (md,
      58              :                            sizeof (struct MeltData));
      59           88 : }
      60              : 
      61              : 
      62              : enum GNUNET_GenericReturnValue
      63           87 : 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           87 : {
      71              :   struct TALER_Amount total;
      72              :   struct TALER_CoinSpendPublicKeyP coin_pub;
      73              :   struct TALER_KappaHashBlindedPlanchetsP k_h_bps;
      74           87 :   union GNUNET_CRYPTO_BlindSessionNonce nonces[rd->num_fresh_denom_pubs];
      75           87 :   bool is_cs[rd->num_fresh_denom_pubs];
      76           87 :   bool uses_cs = false;
      77              : 
      78           87 :   GNUNET_CRYPTO_eddsa_key_get_public (&rd->melt_priv.eddsa_priv,
      79              :                                       &coin_pub.eddsa_pub);
      80           87 :   switch (rc_version)
      81              :   {
      82           87 :   case TALER_REFRESH_COMMITMENT_VERSION_LEGACY_VDOLDPLUS_BROKEN:
      83              :   case TALER_REFRESH_COMMITMENT_VERSION_CURRENT:
      84           87 :     break;
      85            0 :   default:
      86              :     /* v27 is not implemented by this library */
      87            0 :     GNUNET_break (0);
      88            0 :     return GNUNET_SYSERR;
      89              :   }
      90           87 :   memset (md,
      91              :           0,
      92              :           sizeof (*md));
      93              :   /* build up melt data structure */
      94           87 :   md->rc_version = rc_version;
      95           87 :   md->refresh_seed = *rms;
      96           87 :   md->num_fresh_coins = rd->num_fresh_denom_pubs;
      97           87 :   md->melted_coin.coin_priv = rd->melt_priv;
      98           87 :   md->melted_coin.melt_amount_with_fee = rd->melt_amount;
      99           87 :   md->melted_coin.fee_melt = rd->melt_pk.fees.refresh;
     100           87 :   md->melted_coin.original_value = rd->melt_pk.value;
     101           87 :   md->melted_coin.expire_deposit = rd->melt_pk.expire_deposit;
     102           87 :   md->melted_coin.age_commitment_proof = rd->melt_age_commitment_proof;
     103           87 :   md->melted_coin.h_age_commitment = rd->melt_h_age_commitment;
     104           87 :   md->no_blinding_seed = (NULL == blinding_seed);
     105           87 :   if (NULL != blinding_seed)
     106           43 :     md->blinding_seed = *blinding_seed;
     107              : 
     108           87 :   GNUNET_assert (GNUNET_OK ==
     109              :                  TALER_amount_set_zero (rd->melt_amount.currency,
     110              :                                         &total));
     111           87 :   TALER_denom_pub_copy (&md->melted_coin.pub_key,
     112              :                         &rd->melt_pk.key);
     113           87 :   TALER_denom_sig_copy (&md->melted_coin.sig,
     114              :                         &rd->melt_sig);
     115           87 :   md->fcds = GNUNET_new_array (md->num_fresh_coins,
     116              :                                struct FreshCoinData);
     117           87 :   md->denoms_h =
     118           87 :     GNUNET_new_array (md->num_fresh_coins,
     119              :                       struct  TALER_DenominationHashP);
     120           87 :   md->denom_pubs =
     121           87 :     GNUNET_new_array (md->num_fresh_coins,
     122              :                       const struct  TALER_DenominationPublicKey*);
     123              : 
     124          345 :   for (unsigned int j = 0; j<md->num_fresh_coins; j++)
     125              :   {
     126          258 :     struct FreshCoinData *fcd = &md->fcds[j];
     127              : 
     128          258 :     md->denoms_h[j] = rd->fresh_denom_pubs[j].h_key;
     129          258 :     md->denom_pubs[j] = &rd->fresh_denom_pubs[j].key;
     130              : 
     131          258 :     TALER_denom_pub_copy (&fcd->fresh_pk,
     132          258 :                           &rd->fresh_denom_pubs[j].key);
     133          258 :     GNUNET_assert (NULL != fcd->fresh_pk.bsign_pub_key);
     134          258 :     if (blinding_values[j].blinding_inputs->cipher !=
     135          258 :         fcd->fresh_pk.bsign_pub_key->cipher)
     136              :     {
     137            0 :       GNUNET_break (0);
     138            0 :       TALER_EXCHANGE_free_melt_data (md);
     139            0 :       return GNUNET_SYSERR;
     140              :     }
     141          258 :     switch (fcd->fresh_pk.bsign_pub_key->cipher)
     142              :     {
     143            0 :     case GNUNET_CRYPTO_BSA_INVALID:
     144            0 :       GNUNET_break (0);
     145            0 :       TALER_EXCHANGE_free_melt_data (md);
     146            0 :       return GNUNET_SYSERR;
     147          131 :     case GNUNET_CRYPTO_BSA_RSA:
     148          131 :       is_cs[j] = false;
     149          131 :       break;
     150          127 :     case GNUNET_CRYPTO_BSA_CS:
     151          127 :       uses_cs = true;
     152          127 :       is_cs[j] = true;
     153          127 :       break;
     154              :     }
     155          258 :     if ( (0 >
     156          258 :           TALER_amount_add (&total,
     157              :                             &total,
     158          516 :                             &rd->fresh_denom_pubs[j].value)) ||
     159              :          (0 >
     160          258 :           TALER_amount_add (&total,
     161              :                             &total,
     162          258 :                             &rd->fresh_denom_pubs[j].fees.withdraw)) )
     163              :     {
     164            0 :       GNUNET_break (0);
     165            0 :       TALER_EXCHANGE_free_melt_data (md);
     166            0 :       return GNUNET_SYSERR;
     167              :     }
     168              :   }
     169              : 
     170              :   /* verify that melt_amount is above total cost */
     171           87 :   if (1 ==
     172           87 :       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            0 :     GNUNET_break (0);
     178            0 :     TALER_EXCHANGE_free_melt_data (md);
     179            0 :     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           87 :   memset (nonces,
     188              :           0,
     189           87 :           sizeof(nonces[0]) * rd->num_fresh_denom_pubs);
     190           87 :   if (uses_cs)
     191              :   {
     192           43 :     GNUNET_assert (! md->no_blinding_seed);
     193           43 :     TALER_cs_derive_blind_nonces_from_seed (
     194              :       blinding_seed,
     195              :       true, /* for melt */
     196           43 :       md->num_fresh_coins,
     197              :       is_cs,
     198              :       nonces);
     199              :   }
     200              :   /**
     201              :    * Generate the kappa private seeds for the batches.
     202              :    */
     203           87 :   TALER_refresh_expand_seed_to_kappa_batch_seeds (
     204           87 :     &md->refresh_seed,
     205              :     &rd->melt_priv,
     206              :     &md->kappa_batch_seeds);
     207              :   /**
     208              :    * Build up all candidates for coin planchets
     209              :    */
     210          348 :   for (unsigned int k = 0; k<TALER_CNC_KAPPA; k++)
     211          261 :   {
     212              :     struct TALER_PlanchetMasterSecretP
     213          261 :       planchet_secrets[md->num_fresh_coins];
     214          261 :     struct TALER_PlanchetDetail planchet_details[md->num_fresh_coins];
     215              : 
     216          261 :     md->kappa_blinded_planchets[k] =
     217          261 :       GNUNET_new_array (md->num_fresh_coins,
     218              :                         struct TALER_BlindedPlanchet);
     219          261 :     md->kappa_transfer_pubs[k] =
     220          261 :       GNUNET_new_array (md->num_fresh_coins,
     221              :                         struct TALER_TransferPublicKeyP);
     222              : 
     223          261 :     TALER_refresh_expand_batch_seed_to_transfer_data (
     224          261 :       &md->kappa_batch_seeds.tuple[k],
     225              :       &coin_pub,
     226          261 :       md->num_fresh_coins,
     227              :       planchet_secrets,
     228              :       md->kappa_transfer_pubs[k]);
     229              : 
     230         1035 :     for (unsigned int j = 0; j<md->num_fresh_coins; j++)
     231              :     {
     232          774 :       struct FreshCoinData *fcd = &md->fcds[j];
     233          774 :       struct TALER_CoinSpendPrivateKeyP *coin_priv = &fcd->coin_priv;
     234          774 :       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          774 :       fcd->ps[k] = planchet_secrets[j];
     240          774 :       TALER_planchet_setup_coin_priv (&planchet_secrets[j],
     241          774 :                                       &blinding_values[j],
     242              :                                       coin_priv);
     243          774 :       TALER_planchet_blinding_secret_create (&planchet_secrets[j],
     244          774 :                                              &blinding_values[j],
     245              :                                              bks);
     246          774 :       if (NULL != rd->melt_age_commitment_proof)
     247              :       {
     248          288 :         fcd->age_commitment_proofs[k] =
     249          288 :           GNUNET_new (struct TALER_AgeCommitmentProof);
     250          288 :         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          288 :         TALER_age_commitment_hash (
     256          288 :           &fcd->age_commitment_proofs[k]->commitment,
     257              :           &ach);
     258          288 :         pah = &ach;
     259              :       }
     260              :       else
     261              :       {
     262          486 :         pah = NULL;
     263              :       }
     264              : 
     265          774 :       if (GNUNET_OK !=
     266          774 :           TALER_planchet_prepare (&fcd->fresh_pk,
     267          774 :                                   &blinding_values[j],
     268              :                                   bks,
     269          774 :                                   is_cs[j] ? &nonces[j] : NULL,
     270              :                                   coin_priv,
     271              :                                   pah,
     272              :                                   &c_hash,
     273              :                                   &planchet_details[j]))
     274              :       {
     275            0 :         GNUNET_break_op (0);
     276            0 :         TALER_EXCHANGE_free_melt_data (md);
     277            0 :         return GNUNET_SYSERR;
     278              :       }
     279          774 :       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          261 :     TALER_wallet_blinded_planchet_details_hash (
     286          261 :       rd->num_fresh_denom_pubs,
     287              :       planchet_details,
     288              :       &k_h_bps.tuple[k]);
     289              :   }
     290              : 
     291              :   /* Finally, compute refresh commitment */
     292           87 :   if (TALER_REFRESH_COMMITMENT_VERSION_LEGACY_VDOLDPLUS_BROKEN == rc_version)
     293              :   {
     294            8 :     TALER_refresh_get_commitment_legacy_vDOLDPLUS_broken (
     295              :       &md->rc,
     296            8 :       &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           79 :     struct TALER_KappaTransferPublicKeys k_tr_pubs = {
     307           79 :       .num_transfer_pubs = md->num_fresh_coins,
     308              :     };
     309              : 
     310          316 :     for (uint8_t k=0; k<TALER_CNC_KAPPA; k++)
     311          237 :       k_tr_pubs.batch[k] = md->kappa_transfer_pubs[k];
     312              : 
     313           79 :     TALER_refresh_get_commitment (&md->rc,
     314           79 :                                   &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           87 :   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           52 : TALER_EXCHANGE_refresh_commitment_version (
     336              :   const struct TALER_EXCHANGE_Keys *keys)
     337              : {
     338              :   struct TALER_JSON_ProtocolVersion pv;
     339              :   char dummy;
     340              : 
     341           52 :   if ( (NULL == keys->version) ||
     342           52 :        (3 != sscanf (keys->version,
     343              :                      "%u:%u:%u%c",
     344              :                      &pv.current,
     345              :                      &pv.revision,
     346              :                      &pv.age,
     347              :                      &dummy)) )
     348              :   {
     349            0 :     GNUNET_break_op (0);
     350            0 :     return TALER_REFRESH_COMMITMENT_VERSION_CURRENT;
     351              :   }
     352           52 :   if (pv.current < EXCHANGE_PROTOCOL_REFRESH_COMMITMENT_CURRENT)
     353            1 :     return TALER_REFRESH_COMMITMENT_VERSION_LEGACY_VDOLDPLUS_BROKEN;
     354           51 :   return TALER_REFRESH_COMMITMENT_VERSION_CURRENT;
     355              : }
        

Generated by: LCOV version 2.0-1