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 }