Line data Source code
1 : /*
2 : This file is part of TALER
3 : Copyright (C) 2021, 2022 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 <http://www.gnu.org/licenses/>
15 : */
16 : /**
17 : * @file denom.c
18 : * @brief denomination utility functions
19 : * @author Christian Grothoff
20 : */
21 : #include "platform.h"
22 : #include "taler_util.h"
23 :
24 :
25 : enum GNUNET_GenericReturnValue
26 8 : TALER_denom_priv_create (struct TALER_DenominationPrivateKey *denom_priv,
27 : struct TALER_DenominationPublicKey *denom_pub,
28 : enum TALER_DenominationCipher cipher,
29 : ...)
30 : {
31 8 : memset (denom_priv,
32 : 0,
33 : sizeof (*denom_priv));
34 8 : memset (denom_pub,
35 : 0,
36 : sizeof (*denom_pub));
37 :
38 8 : switch (cipher)
39 : {
40 2 : case TALER_DENOMINATION_INVALID:
41 2 : GNUNET_break (0);
42 2 : return GNUNET_SYSERR;
43 2 : case TALER_DENOMINATION_RSA:
44 : {
45 : va_list ap;
46 : unsigned int bits;
47 :
48 2 : va_start (ap, cipher);
49 2 : bits = va_arg (ap, unsigned int);
50 2 : va_end (ap);
51 2 : if (bits < 512)
52 : {
53 0 : GNUNET_break (0);
54 0 : return GNUNET_SYSERR;
55 : }
56 : denom_priv->details.rsa_private_key
57 2 : = GNUNET_CRYPTO_rsa_private_key_create (bits);
58 : }
59 2 : if (NULL == denom_priv->details.rsa_private_key)
60 : {
61 0 : GNUNET_break (0);
62 0 : return GNUNET_SYSERR;
63 : }
64 : denom_pub->details.rsa_public_key
65 4 : = GNUNET_CRYPTO_rsa_private_key_get_public (
66 2 : denom_priv->details.rsa_private_key);
67 2 : denom_priv->cipher = TALER_DENOMINATION_RSA;
68 2 : denom_pub->cipher = TALER_DENOMINATION_RSA;
69 2 : return GNUNET_OK;
70 2 : case TALER_DENOMINATION_CS:
71 2 : GNUNET_CRYPTO_cs_private_key_generate (&denom_priv->details.cs_private_key);
72 2 : GNUNET_CRYPTO_cs_private_key_get_public (
73 2 : &denom_priv->details.cs_private_key,
74 : &denom_pub->details.cs_public_key);
75 2 : denom_priv->cipher = TALER_DENOMINATION_CS;
76 2 : denom_pub->cipher = TALER_DENOMINATION_CS;
77 2 : return GNUNET_OK;
78 2 : default:
79 2 : GNUNET_break (0);
80 : }
81 2 : return GNUNET_SYSERR;
82 : }
83 :
84 :
85 : enum GNUNET_GenericReturnValue
86 4 : TALER_denom_sign_blinded (struct TALER_BlindedDenominationSignature *denom_sig,
87 : const struct TALER_DenominationPrivateKey *denom_priv,
88 : bool for_melt,
89 : const struct TALER_BlindedPlanchet *blinded_planchet)
90 : {
91 4 : memset (denom_sig,
92 : 0,
93 : sizeof (*denom_sig));
94 4 : if (blinded_planchet->cipher != denom_priv->cipher)
95 : {
96 0 : GNUNET_break (0);
97 0 : return GNUNET_SYSERR;
98 : }
99 4 : switch (denom_priv->cipher)
100 : {
101 0 : case TALER_DENOMINATION_INVALID:
102 0 : GNUNET_break (0);
103 0 : return GNUNET_SYSERR;
104 2 : case TALER_DENOMINATION_RSA:
105 : denom_sig->details.blinded_rsa_signature
106 4 : = GNUNET_CRYPTO_rsa_sign_blinded (
107 2 : denom_priv->details.rsa_private_key,
108 2 : blinded_planchet->details.rsa_blinded_planchet.blinded_msg,
109 : blinded_planchet->details.rsa_blinded_planchet.blinded_msg_size);
110 2 : if (NULL == denom_sig->details.blinded_rsa_signature)
111 : {
112 0 : GNUNET_break (0);
113 0 : return GNUNET_SYSERR;
114 : }
115 2 : denom_sig->cipher = TALER_DENOMINATION_RSA;
116 2 : return GNUNET_OK;
117 2 : case TALER_DENOMINATION_CS:
118 : {
119 : struct GNUNET_CRYPTO_CsRSecret r[2];
120 :
121 2 : GNUNET_CRYPTO_cs_r_derive (
122 : &blinded_planchet->details.cs_blinded_planchet.nonce.nonce,
123 : for_melt ? "rm" : "rw",
124 : &denom_priv->details.cs_private_key,
125 : r);
126 2 : denom_sig->details.blinded_cs_answer.b =
127 2 : GNUNET_CRYPTO_cs_sign_derive (&denom_priv->details.cs_private_key,
128 : r,
129 : blinded_planchet->details.
130 2 : cs_blinded_planchet.c,
131 : &blinded_planchet->details.
132 : cs_blinded_planchet.nonce.nonce,
133 : &denom_sig->details.blinded_cs_answer.
134 : s_scalar);
135 2 : denom_sig->cipher = TALER_DENOMINATION_CS;
136 : }
137 2 : return GNUNET_OK;
138 0 : default:
139 0 : GNUNET_break (0);
140 : }
141 0 : return GNUNET_SYSERR;
142 : }
143 :
144 :
145 : enum GNUNET_GenericReturnValue
146 6 : TALER_denom_sig_unblind (
147 : struct TALER_DenominationSignature *denom_sig,
148 : const struct TALER_BlindedDenominationSignature *bdenom_sig,
149 : const union TALER_DenominationBlindingKeyP *bks,
150 : const struct TALER_CoinPubHashP *c_hash,
151 : const struct TALER_ExchangeWithdrawValues *alg_values,
152 : const struct TALER_DenominationPublicKey *denom_pub)
153 : {
154 6 : if (bdenom_sig->cipher != denom_pub->cipher)
155 : {
156 0 : GNUNET_break (0);
157 0 : return GNUNET_SYSERR;
158 : }
159 6 : switch (denom_pub->cipher)
160 : {
161 0 : case TALER_DENOMINATION_INVALID:
162 0 : GNUNET_break (0);
163 0 : return GNUNET_SYSERR;
164 3 : case TALER_DENOMINATION_RSA:
165 : denom_sig->details.rsa_signature
166 6 : = GNUNET_CRYPTO_rsa_unblind (
167 3 : bdenom_sig->details.blinded_rsa_signature,
168 : &bks->rsa_bks,
169 : denom_pub->details.rsa_public_key);
170 3 : if (NULL == denom_sig->details.rsa_signature)
171 : {
172 0 : GNUNET_break (0);
173 0 : return GNUNET_SYSERR;
174 : }
175 3 : denom_sig->cipher = TALER_DENOMINATION_RSA;
176 3 : return GNUNET_OK;
177 3 : case TALER_DENOMINATION_CS:
178 : {
179 : struct GNUNET_CRYPTO_CsBlindingSecret bs[2];
180 : struct GNUNET_CRYPTO_CsC c[2];
181 : struct TALER_DenominationCSPublicRPairP r_pub_blind;
182 :
183 3 : GNUNET_CRYPTO_cs_blinding_secrets_derive (&bks->nonce,
184 : bs);
185 3 : GNUNET_CRYPTO_cs_calc_blinded_c (
186 : bs,
187 3 : alg_values->details.cs_values.r_pub,
188 : &denom_pub->details.cs_public_key,
189 3 : &c_hash->hash,
190 : sizeof(struct GNUNET_HashCode),
191 : c,
192 : r_pub_blind.r_pub);
193 : denom_sig->details.cs_signature.r_point
194 3 : = r_pub_blind.r_pub[bdenom_sig->details.blinded_cs_answer.b];
195 3 : GNUNET_CRYPTO_cs_unblind (&bdenom_sig->details.blinded_cs_answer.s_scalar,
196 3 : &bs[bdenom_sig->details.blinded_cs_answer.b],
197 : &denom_sig->details.cs_signature.s_scalar);
198 3 : denom_sig->cipher = TALER_DENOMINATION_CS;
199 3 : return GNUNET_OK;
200 : }
201 0 : default:
202 0 : GNUNET_break (0);
203 : }
204 0 : return GNUNET_SYSERR;
205 : }
206 :
207 :
208 : void
209 9 : TALER_rsa_pub_hash (const struct GNUNET_CRYPTO_RsaPublicKey *rsa,
210 : struct TALER_RsaPubHashP *h_rsa)
211 : {
212 9 : GNUNET_CRYPTO_rsa_public_key_hash (rsa,
213 : &h_rsa->hash);
214 :
215 9 : }
216 :
217 :
218 : void
219 90 : TALER_cs_pub_hash (const struct GNUNET_CRYPTO_CsPublicKey *cs,
220 : struct TALER_CsPubHashP *h_cs)
221 : {
222 90 : GNUNET_CRYPTO_hash (cs,
223 : sizeof(*cs),
224 : &h_cs->hash);
225 90 : }
226 :
227 :
228 : void
229 31 : TALER_denom_pub_hash (const struct TALER_DenominationPublicKey *denom_pub,
230 : struct TALER_DenominationHashP *denom_hash)
231 : {
232 31 : uint32_t opt[2] = {
233 31 : htonl (denom_pub->age_mask.bits),
234 31 : htonl ((uint32_t) denom_pub->cipher)
235 : };
236 : struct GNUNET_HashContext *hc;
237 :
238 31 : hc = GNUNET_CRYPTO_hash_context_start ();
239 31 : GNUNET_CRYPTO_hash_context_read (hc,
240 : opt,
241 : sizeof (opt));
242 31 : switch (denom_pub->cipher)
243 : {
244 17 : case TALER_DENOMINATION_RSA:
245 : {
246 : void *buf;
247 : size_t blen;
248 :
249 17 : blen = GNUNET_CRYPTO_rsa_public_key_encode (
250 17 : denom_pub->details.rsa_public_key,
251 : &buf);
252 17 : GNUNET_CRYPTO_hash_context_read (hc,
253 : buf,
254 : blen);
255 17 : GNUNET_free (buf);
256 : }
257 17 : break;
258 14 : case TALER_DENOMINATION_CS:
259 14 : GNUNET_CRYPTO_hash_context_read (hc,
260 14 : &denom_pub->details.cs_public_key,
261 : sizeof(denom_pub->details.cs_public_key));
262 14 : break;
263 0 : default:
264 0 : GNUNET_assert (0);
265 : }
266 31 : GNUNET_CRYPTO_hash_context_finish (hc,
267 : &denom_hash->hash);
268 31 : }
269 :
270 :
271 : void
272 0 : TALER_denom_priv_to_pub (const struct TALER_DenominationPrivateKey *denom_priv,
273 : const struct TALER_AgeMask age_mask,
274 : struct TALER_DenominationPublicKey *denom_pub)
275 : {
276 0 : switch (denom_priv->cipher)
277 : {
278 0 : case TALER_DENOMINATION_RSA:
279 0 : denom_pub->cipher = TALER_DENOMINATION_RSA;
280 0 : denom_pub->age_mask = age_mask;
281 : denom_pub->details.rsa_public_key
282 0 : = GNUNET_CRYPTO_rsa_private_key_get_public (
283 0 : denom_priv->details.rsa_private_key);
284 0 : return;
285 0 : case TALER_DENOMINATION_CS:
286 0 : denom_pub->cipher = TALER_DENOMINATION_CS;
287 0 : denom_pub->age_mask = age_mask;
288 0 : GNUNET_CRYPTO_cs_private_key_get_public (
289 : &denom_priv->details.cs_private_key,
290 : &denom_pub->details.cs_public_key);
291 0 : return;
292 0 : default:
293 0 : GNUNET_assert (0);
294 : }
295 : }
296 :
297 :
298 : enum GNUNET_GenericReturnValue
299 31 : TALER_denom_blind (
300 : const struct TALER_DenominationPublicKey *dk,
301 : const union TALER_DenominationBlindingKeyP *coin_bks,
302 : const struct TALER_AgeCommitmentHash *ach,
303 : const struct TALER_CoinSpendPublicKeyP *coin_pub,
304 : const struct TALER_ExchangeWithdrawValues *alg_values,
305 : struct TALER_CoinPubHashP *c_hash,
306 : struct TALER_BlindedPlanchet *blinded_planchet)
307 : {
308 31 : TALER_coin_pub_hash (coin_pub,
309 : ach,
310 : c_hash);
311 31 : switch (dk->cipher)
312 : {
313 17 : case TALER_DENOMINATION_RSA:
314 17 : blinded_planchet->cipher = dk->cipher;
315 17 : if (GNUNET_YES !=
316 17 : GNUNET_CRYPTO_rsa_blind (
317 17 : &c_hash->hash,
318 : &coin_bks->rsa_bks,
319 : dk->details.rsa_public_key,
320 : &blinded_planchet->details.rsa_blinded_planchet.blinded_msg,
321 : &blinded_planchet->details.rsa_blinded_planchet.blinded_msg_size))
322 : {
323 0 : GNUNET_break (0);
324 0 : return GNUNET_SYSERR;
325 : }
326 17 : return GNUNET_OK;
327 14 : case TALER_DENOMINATION_CS:
328 : {
329 : struct TALER_DenominationCSPublicRPairP blinded_r_pub;
330 : struct GNUNET_CRYPTO_CsBlindingSecret bs[2];
331 :
332 14 : blinded_planchet->cipher = TALER_DENOMINATION_CS;
333 14 : GNUNET_CRYPTO_cs_blinding_secrets_derive (&coin_bks->nonce,
334 : bs);
335 14 : GNUNET_CRYPTO_cs_calc_blinded_c (
336 : bs,
337 14 : alg_values->details.cs_values.r_pub,
338 : &dk->details.cs_public_key,
339 : c_hash,
340 : sizeof(*c_hash),
341 14 : blinded_planchet->details.cs_blinded_planchet.c,
342 : blinded_r_pub.r_pub);
343 14 : return GNUNET_OK;
344 : }
345 0 : default:
346 0 : GNUNET_break (0);
347 0 : return GNUNET_SYSERR;
348 : }
349 : }
350 :
351 :
352 : enum GNUNET_GenericReturnValue
353 6 : TALER_denom_pub_verify (const struct TALER_DenominationPublicKey *denom_pub,
354 : const struct TALER_DenominationSignature *denom_sig,
355 : const struct TALER_CoinPubHashP *c_hash)
356 : {
357 6 : if (denom_pub->cipher != denom_sig->cipher)
358 : {
359 0 : GNUNET_break (0);
360 0 : return GNUNET_SYSERR;
361 : }
362 6 : switch (denom_pub->cipher)
363 : {
364 0 : case TALER_DENOMINATION_INVALID:
365 0 : GNUNET_break (0);
366 0 : return GNUNET_NO;
367 3 : case TALER_DENOMINATION_RSA:
368 3 : if (GNUNET_OK !=
369 3 : GNUNET_CRYPTO_rsa_verify (&c_hash->hash,
370 3 : denom_sig->details.rsa_signature,
371 3 : denom_pub->details.rsa_public_key))
372 : {
373 0 : GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
374 : "Coin signature is invalid\n");
375 0 : return GNUNET_NO;
376 : }
377 3 : return GNUNET_YES;
378 3 : case TALER_DENOMINATION_CS:
379 3 : if (GNUNET_OK !=
380 3 : GNUNET_CRYPTO_cs_verify (&denom_sig->details.cs_signature,
381 : &denom_pub->details.cs_public_key,
382 3 : &c_hash->hash,
383 : sizeof(struct GNUNET_HashCode)))
384 : {
385 0 : GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
386 : "Coin signature is invalid\n");
387 0 : return GNUNET_NO;
388 : }
389 3 : return GNUNET_YES;
390 0 : default:
391 0 : GNUNET_assert (0);
392 : }
393 : }
394 :
395 :
396 : void
397 328 : TALER_denom_pub_free (struct TALER_DenominationPublicKey *denom_pub)
398 : {
399 328 : switch (denom_pub->cipher)
400 : {
401 0 : case TALER_DENOMINATION_INVALID:
402 0 : return;
403 164 : case TALER_DENOMINATION_RSA:
404 164 : if (NULL != denom_pub->details.rsa_public_key)
405 : {
406 164 : GNUNET_CRYPTO_rsa_public_key_free (denom_pub->details.rsa_public_key);
407 164 : denom_pub->details.rsa_public_key = NULL;
408 : }
409 164 : denom_pub->cipher = TALER_DENOMINATION_INVALID;
410 164 : return;
411 164 : case TALER_DENOMINATION_CS:
412 164 : return;
413 0 : default:
414 0 : GNUNET_assert (0);
415 : }
416 : }
417 :
418 :
419 : void
420 4 : TALER_denom_priv_free (struct TALER_DenominationPrivateKey *denom_priv)
421 : {
422 4 : switch (denom_priv->cipher)
423 : {
424 0 : case TALER_DENOMINATION_INVALID:
425 0 : return;
426 2 : case TALER_DENOMINATION_RSA:
427 2 : if (NULL != denom_priv->details.rsa_private_key)
428 : {
429 2 : GNUNET_CRYPTO_rsa_private_key_free (denom_priv->details.rsa_private_key);
430 2 : denom_priv->details.rsa_private_key = NULL;
431 : }
432 2 : denom_priv->cipher = TALER_DENOMINATION_INVALID;
433 2 : return;
434 2 : case TALER_DENOMINATION_CS:
435 2 : return;
436 0 : default:
437 0 : GNUNET_assert (0);
438 : }
439 : }
440 :
441 :
442 : void
443 5 : TALER_denom_sig_free (struct TALER_DenominationSignature *denom_sig)
444 : {
445 5 : switch (denom_sig->cipher)
446 : {
447 0 : case TALER_DENOMINATION_INVALID:
448 0 : return;
449 3 : case TALER_DENOMINATION_RSA:
450 3 : if (NULL != denom_sig->details.rsa_signature)
451 : {
452 3 : GNUNET_CRYPTO_rsa_signature_free (denom_sig->details.rsa_signature);
453 3 : denom_sig->details.rsa_signature = NULL;
454 : }
455 3 : denom_sig->cipher = TALER_DENOMINATION_INVALID;
456 3 : return;
457 2 : case TALER_DENOMINATION_CS:
458 2 : return;
459 0 : default:
460 0 : GNUNET_assert (0);
461 : }
462 : }
463 :
464 :
465 : void
466 1805 : TALER_blinded_denom_sig_free (
467 : struct TALER_BlindedDenominationSignature *denom_sig)
468 : {
469 1805 : switch (denom_sig->cipher)
470 : {
471 0 : case TALER_DENOMINATION_INVALID:
472 0 : return;
473 903 : case TALER_DENOMINATION_RSA:
474 903 : if (NULL != denom_sig->details.blinded_rsa_signature)
475 : {
476 903 : GNUNET_CRYPTO_rsa_signature_free (
477 : denom_sig->details.blinded_rsa_signature);
478 903 : denom_sig->details.blinded_rsa_signature = NULL;
479 : }
480 903 : denom_sig->cipher = TALER_DENOMINATION_INVALID;
481 903 : return;
482 902 : case TALER_DENOMINATION_CS:
483 902 : return;
484 0 : default:
485 0 : GNUNET_assert (0);
486 : }
487 : }
488 :
489 :
490 : void
491 162 : TALER_denom_pub_deep_copy (struct TALER_DenominationPublicKey *denom_dst,
492 : const struct TALER_DenominationPublicKey *denom_src)
493 : {
494 162 : *denom_dst = *denom_src; /* shallow copy */
495 162 : switch (denom_src->cipher)
496 : {
497 81 : case TALER_DENOMINATION_RSA:
498 : denom_dst->details.rsa_public_key
499 162 : = GNUNET_CRYPTO_rsa_public_key_dup (
500 81 : denom_src->details.rsa_public_key);
501 81 : return;
502 81 : case TALER_DENOMINATION_CS:
503 81 : return;
504 0 : default:
505 0 : GNUNET_assert (0);
506 : }
507 : }
508 :
509 :
510 : void
511 0 : TALER_denom_sig_deep_copy (struct TALER_DenominationSignature *denom_dst,
512 : const struct TALER_DenominationSignature *denom_src)
513 : {
514 0 : *denom_dst = *denom_src; /* shallow copy */
515 0 : switch (denom_src->cipher)
516 : {
517 0 : case TALER_DENOMINATION_INVALID:
518 0 : return;
519 0 : case TALER_DENOMINATION_RSA:
520 : denom_dst->details.rsa_signature
521 0 : = GNUNET_CRYPTO_rsa_signature_dup (
522 0 : denom_src->details.rsa_signature);
523 0 : return;
524 0 : case TALER_DENOMINATION_CS:
525 0 : return;
526 0 : default:
527 0 : GNUNET_assert (0);
528 : }
529 : }
530 :
531 :
532 : void
533 0 : TALER_blinded_denom_sig_deep_copy (
534 : struct TALER_BlindedDenominationSignature *denom_dst,
535 : const struct TALER_BlindedDenominationSignature *denom_src)
536 : {
537 0 : *denom_dst = *denom_src; /* shallow copy */
538 0 : switch (denom_src->cipher)
539 : {
540 0 : case TALER_DENOMINATION_INVALID:
541 0 : return;
542 0 : case TALER_DENOMINATION_RSA:
543 : denom_dst->details.blinded_rsa_signature
544 0 : = GNUNET_CRYPTO_rsa_signature_dup (
545 0 : denom_src->details.blinded_rsa_signature);
546 0 : return;
547 0 : case TALER_DENOMINATION_CS:
548 0 : return;
549 0 : default:
550 0 : GNUNET_assert (0);
551 : }
552 : }
553 :
554 :
555 : int
556 0 : TALER_denom_pub_cmp (const struct TALER_DenominationPublicKey *denom1,
557 : const struct TALER_DenominationPublicKey *denom2)
558 : {
559 0 : if (denom1->cipher != denom2->cipher)
560 0 : return (denom1->cipher > denom2->cipher) ? 1 : -1;
561 0 : if (denom1->age_mask.bits != denom2->age_mask.bits)
562 0 : return (denom1->age_mask.bits > denom2->age_mask.bits) ? 1 : -1;
563 0 : switch (denom1->cipher)
564 : {
565 0 : case TALER_DENOMINATION_INVALID:
566 0 : return 0;
567 0 : case TALER_DENOMINATION_RSA:
568 0 : return GNUNET_CRYPTO_rsa_public_key_cmp (denom1->details.rsa_public_key,
569 0 : denom2->details.rsa_public_key);
570 0 : case TALER_DENOMINATION_CS:
571 0 : return GNUNET_memcmp (&denom1->details.cs_public_key,
572 : &denom2->details.cs_public_key);
573 0 : default:
574 0 : GNUNET_assert (0);
575 : }
576 : return -2;
577 : }
578 :
579 :
580 : int
581 0 : TALER_denom_sig_cmp (const struct TALER_DenominationSignature *sig1,
582 : const struct TALER_DenominationSignature *sig2)
583 : {
584 0 : if (sig1->cipher != sig2->cipher)
585 0 : return (sig1->cipher > sig2->cipher) ? 1 : -1;
586 0 : switch (sig1->cipher)
587 : {
588 0 : case TALER_DENOMINATION_INVALID:
589 0 : return 0;
590 0 : case TALER_DENOMINATION_RSA:
591 0 : return GNUNET_CRYPTO_rsa_signature_cmp (sig1->details.rsa_signature,
592 0 : sig2->details.rsa_signature);
593 0 : case TALER_DENOMINATION_CS:
594 0 : return GNUNET_memcmp (&sig1->details.cs_signature,
595 : &sig2->details.cs_signature);
596 0 : default:
597 0 : GNUNET_assert (0);
598 : }
599 : return -2;
600 : }
601 :
602 :
603 : int
604 0 : TALER_blinded_planchet_cmp (
605 : const struct TALER_BlindedPlanchet *bp1,
606 : const struct TALER_BlindedPlanchet *bp2)
607 : {
608 0 : if (bp1->cipher != bp2->cipher)
609 0 : return (bp1->cipher > bp2->cipher) ? 1 : -1;
610 0 : switch (bp1->cipher)
611 : {
612 0 : case TALER_DENOMINATION_INVALID:
613 0 : return 0;
614 0 : case TALER_DENOMINATION_RSA:
615 0 : if (bp1->details.rsa_blinded_planchet.blinded_msg_size !=
616 0 : bp2->details.rsa_blinded_planchet.blinded_msg_size)
617 0 : return (bp1->details.rsa_blinded_planchet.blinded_msg_size >
618 0 : bp2->details.rsa_blinded_planchet.blinded_msg_size) ? 1 : -1;
619 0 : return memcmp (bp1->details.rsa_blinded_planchet.blinded_msg,
620 0 : bp2->details.rsa_blinded_planchet.blinded_msg,
621 : bp1->details.rsa_blinded_planchet.blinded_msg_size);
622 0 : case TALER_DENOMINATION_CS:
623 0 : return GNUNET_memcmp (&bp1->details.cs_blinded_planchet,
624 : &bp2->details.cs_blinded_planchet);
625 0 : default:
626 0 : GNUNET_assert (0);
627 : }
628 : return -2;
629 : }
630 :
631 :
632 : int
633 0 : TALER_blinded_denom_sig_cmp (
634 : const struct TALER_BlindedDenominationSignature *sig1,
635 : const struct TALER_BlindedDenominationSignature *sig2)
636 : {
637 0 : if (sig1->cipher != sig2->cipher)
638 0 : return (sig1->cipher > sig2->cipher) ? 1 : -1;
639 0 : switch (sig1->cipher)
640 : {
641 0 : case TALER_DENOMINATION_INVALID:
642 0 : return 0;
643 0 : case TALER_DENOMINATION_RSA:
644 0 : return GNUNET_CRYPTO_rsa_signature_cmp (sig1->details.blinded_rsa_signature,
645 0 : sig2->details.blinded_rsa_signature);
646 0 : case TALER_DENOMINATION_CS:
647 0 : return GNUNET_memcmp (&sig1->details.blinded_cs_answer,
648 : &sig2->details.blinded_cs_answer);
649 0 : default:
650 0 : GNUNET_assert (0);
651 : }
652 : return -2;
653 : }
654 :
655 :
656 : void
657 0 : TALER_blinded_planchet_hash_ (const struct TALER_BlindedPlanchet *bp,
658 : struct GNUNET_HashContext *hash_context)
659 : {
660 0 : uint32_t cipher = htonl (bp->cipher);
661 :
662 0 : GNUNET_CRYPTO_hash_context_read (hash_context,
663 : &cipher,
664 : sizeof (cipher));
665 0 : switch (bp->cipher)
666 : {
667 0 : case TALER_DENOMINATION_INVALID:
668 0 : break;
669 0 : case TALER_DENOMINATION_RSA:
670 0 : GNUNET_CRYPTO_hash_context_read (
671 : hash_context,
672 0 : bp->details.rsa_blinded_planchet.blinded_msg,
673 : bp->details.rsa_blinded_planchet.blinded_msg_size);
674 0 : break;
675 0 : case TALER_DENOMINATION_CS:
676 0 : GNUNET_CRYPTO_hash_context_read (
677 : hash_context,
678 0 : &bp->details.cs_blinded_planchet,
679 : sizeof (bp->details.cs_blinded_planchet));
680 0 : break;
681 0 : default:
682 0 : GNUNET_assert (0);
683 : break;
684 : }
685 0 : }
686 :
687 :
688 : void
689 27 : TALER_planchet_blinding_secret_create (
690 : const struct TALER_PlanchetMasterSecretP *ps,
691 : const struct TALER_ExchangeWithdrawValues *alg_values,
692 : union TALER_DenominationBlindingKeyP *bks)
693 : {
694 27 : switch (alg_values->cipher)
695 : {
696 0 : case TALER_DENOMINATION_INVALID:
697 0 : GNUNET_break (0);
698 0 : return;
699 14 : case TALER_DENOMINATION_RSA:
700 14 : GNUNET_assert (GNUNET_YES ==
701 : GNUNET_CRYPTO_kdf (&bks->rsa_bks,
702 : sizeof (bks->rsa_bks),
703 : "bks",
704 : strlen ("bks"),
705 : ps,
706 : sizeof(*ps),
707 : NULL,
708 : 0));
709 14 : return;
710 13 : case TALER_DENOMINATION_CS:
711 13 : GNUNET_assert (GNUNET_YES ==
712 : GNUNET_CRYPTO_kdf (&bks->nonce,
713 : sizeof (bks->nonce),
714 : "bseed",
715 : strlen ("bseed"),
716 : ps,
717 : sizeof(*ps),
718 : &alg_values->details.cs_values,
719 : sizeof(alg_values->details.cs_values),
720 : NULL,
721 : 0));
722 13 : return;
723 0 : default:
724 0 : GNUNET_break (0);
725 : }
726 : }
727 :
728 :
729 : void
730 27 : TALER_planchet_setup_coin_priv (
731 : const struct TALER_PlanchetMasterSecretP *ps,
732 : const struct TALER_ExchangeWithdrawValues *alg_values,
733 : struct TALER_CoinSpendPrivateKeyP *coin_priv)
734 : {
735 27 : switch (alg_values->cipher)
736 : {
737 14 : case TALER_DENOMINATION_RSA:
738 14 : GNUNET_assert (GNUNET_YES ==
739 : GNUNET_CRYPTO_kdf (coin_priv,
740 : sizeof (*coin_priv),
741 : "coin",
742 : strlen ("coin"),
743 : ps,
744 : sizeof(*ps),
745 : NULL,
746 : 0));
747 14 : break;
748 13 : case TALER_DENOMINATION_CS:
749 13 : GNUNET_assert (GNUNET_YES ==
750 : GNUNET_CRYPTO_kdf (coin_priv,
751 : sizeof (*coin_priv),
752 : "coin",
753 : strlen ("coin"),
754 : ps,
755 : sizeof(*ps),
756 : &alg_values->details.cs_values,
757 : sizeof(alg_values->details.cs_values),
758 : NULL,
759 : 0));
760 13 : break;
761 0 : default:
762 0 : GNUNET_break (0);
763 0 : return;
764 : }
765 : }
766 :
767 :
768 : void
769 19 : TALER_blinded_planchet_free (struct TALER_BlindedPlanchet *blinded_planchet)
770 : {
771 19 : switch (blinded_planchet->cipher)
772 : {
773 0 : case TALER_DENOMINATION_INVALID:
774 0 : GNUNET_break (0);
775 0 : return;
776 17 : case TALER_DENOMINATION_RSA:
777 17 : GNUNET_free (blinded_planchet->details.rsa_blinded_planchet.blinded_msg);
778 17 : return;
779 2 : case TALER_DENOMINATION_CS:
780 2 : memset (blinded_planchet,
781 : 0,
782 : sizeof (*blinded_planchet));
783 : /* nothing to do for CS */
784 2 : return;
785 : }
786 0 : GNUNET_assert (0);
787 : }
788 :
789 :
790 : /* end of denom.c */
|
