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 : }
|