Line data Source code
1 : /*
2 : This file is part of TALER
3 : Copyright (C) 2020, 2021 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 util/crypto_helper_rsa.c
18 : * @brief utility functions for running out-of-process private key operations
19 : * @author Christian Grothoff
20 : */
21 : #include "platform.h"
22 : #include "taler/taler_util.h"
23 : #include "taler/taler_signatures.h"
24 : #include "crypto_helper_common.h"
25 : #include "secmod_rsa.h"
26 : #include <poll.h>
27 :
28 :
29 : struct TALER_CRYPTO_RsaDenominationHelper
30 : {
31 : /**
32 : * Function to call with updates to available key material.
33 : */
34 : TALER_CRYPTO_RsaDenominationKeyStatusCallback dkc;
35 :
36 : /**
37 : * Closure for @e dkc
38 : */
39 : void *dkc_cls;
40 :
41 : /**
42 : * Socket address of the denomination helper process.
43 : * Used to reconnect if the connection breaks.
44 : */
45 : struct sockaddr_un sa;
46 :
47 : /**
48 : * The UNIX domain socket, -1 if we are currently not connected.
49 : */
50 : int sock;
51 :
52 : /**
53 : * Have we ever been sync'ed?
54 : */
55 : bool synced;
56 : };
57 :
58 :
59 : /**
60 : * Disconnect from the helper process. Updates
61 : * @e sock field in @a dh.
62 : *
63 : * @param[in,out] dh handle to tear down connection of
64 : */
65 : static void
66 27 : do_disconnect (struct TALER_CRYPTO_RsaDenominationHelper *dh)
67 : {
68 27 : GNUNET_break (0 == close (dh->sock));
69 27 : dh->sock = -1;
70 27 : dh->synced = false;
71 27 : }
72 :
73 :
74 : /**
75 : * Try to connect to the helper process. Updates
76 : * @e sock field in @a dh.
77 : *
78 : * @param[in,out] dh handle to establish connection for
79 : * @return #GNUNET_OK on success
80 : */
81 : static enum GNUNET_GenericReturnValue
82 1750 : try_connect (struct TALER_CRYPTO_RsaDenominationHelper *dh)
83 : {
84 1750 : if (-1 != dh->sock)
85 1723 : return GNUNET_OK;
86 27 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
87 : "Establishing connection!\n");
88 27 : dh->sock = socket (AF_UNIX,
89 : SOCK_STREAM,
90 : 0);
91 27 : if (-1 == dh->sock)
92 : {
93 0 : GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
94 : "socket");
95 0 : return GNUNET_SYSERR;
96 : }
97 27 : if (0 !=
98 27 : connect (dh->sock,
99 27 : (const struct sockaddr *) &dh->sa,
100 : sizeof (dh->sa)))
101 : {
102 1 : GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
103 : "connect",
104 : dh->sa.sun_path);
105 1 : do_disconnect (dh);
106 1 : return GNUNET_SYSERR;
107 : }
108 26 : TALER_CRYPTO_helper_rsa_poll (dh);
109 26 : return GNUNET_OK;
110 : }
111 :
112 :
113 : struct TALER_CRYPTO_RsaDenominationHelper *
114 27 : TALER_CRYPTO_helper_rsa_connect (
115 : const struct GNUNET_CONFIGURATION_Handle *cfg,
116 : const char *section,
117 : TALER_CRYPTO_RsaDenominationKeyStatusCallback dkc,
118 : void *dkc_cls)
119 : {
120 : struct TALER_CRYPTO_RsaDenominationHelper *dh;
121 : char *unixpath;
122 : char *secname;
123 :
124 27 : GNUNET_asprintf (&secname,
125 : "%s-secmod-rsa",
126 : section);
127 :
128 27 : if (GNUNET_OK !=
129 27 : GNUNET_CONFIGURATION_get_value_filename (cfg,
130 : secname,
131 : "UNIXPATH",
132 : &unixpath))
133 : {
134 0 : GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
135 : secname,
136 : "UNIXPATH");
137 0 : GNUNET_free (secname);
138 0 : return NULL;
139 : }
140 : /* we use >= here because we want the sun_path to always
141 : be 0-terminated */
142 27 : if (strlen (unixpath) >= sizeof (dh->sa.sun_path))
143 : {
144 0 : GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
145 : secname,
146 : "UNIXPATH",
147 : "path too long");
148 0 : GNUNET_free (unixpath);
149 0 : GNUNET_free (secname);
150 0 : return NULL;
151 : }
152 27 : GNUNET_free (secname);
153 27 : dh = GNUNET_new (struct TALER_CRYPTO_RsaDenominationHelper);
154 27 : dh->dkc = dkc;
155 27 : dh->dkc_cls = dkc_cls;
156 27 : dh->sa.sun_family = AF_UNIX;
157 27 : strncpy (dh->sa.sun_path,
158 : unixpath,
159 : sizeof (dh->sa.sun_path) - 1);
160 27 : GNUNET_free (unixpath);
161 27 : dh->sock = -1;
162 27 : if (GNUNET_OK !=
163 27 : try_connect (dh))
164 : {
165 1 : GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
166 : "Could not connect to %s. Will keep trying\n",
167 : "taler-exchange-helper-secmod-rsa");
168 : }
169 27 : return dh;
170 : }
171 :
172 :
173 : /**
174 : * Handle a #TALER_HELPER_RSA_MT_AVAIL message from the helper.
175 : *
176 : * @param dh helper context
177 : * @param hdr message that we received
178 : * @return #GNUNET_OK on success
179 : */
180 : static enum GNUNET_GenericReturnValue
181 331 : handle_mt_avail (struct TALER_CRYPTO_RsaDenominationHelper *dh,
182 : const struct GNUNET_MessageHeader *hdr)
183 : {
184 331 : const struct TALER_CRYPTO_RsaKeyAvailableNotification *kan
185 : = (const struct TALER_CRYPTO_RsaKeyAvailableNotification *) hdr;
186 331 : const char *buf = (const char *) &kan[1];
187 : const char *section_name;
188 : uint16_t ps;
189 : uint16_t snl;
190 :
191 331 : if (sizeof (*kan) > ntohs (hdr->size))
192 : {
193 0 : GNUNET_break_op (0);
194 0 : return GNUNET_SYSERR;
195 : }
196 331 : ps = ntohs (kan->pub_size);
197 331 : snl = ntohs (kan->section_name_len);
198 331 : if (ntohs (hdr->size) != sizeof (*kan) + ps + snl)
199 : {
200 0 : GNUNET_break_op (0);
201 0 : return GNUNET_SYSERR;
202 : }
203 331 : if (0 == snl)
204 : {
205 0 : GNUNET_break_op (0);
206 0 : return GNUNET_SYSERR;
207 : }
208 331 : section_name = &buf[ps];
209 331 : if ('\0' != section_name[snl - 1])
210 : {
211 0 : GNUNET_break_op (0);
212 0 : return GNUNET_SYSERR;
213 : }
214 :
215 : {
216 : struct GNUNET_CRYPTO_BlindSignPublicKey *bs_pub;
217 : struct TALER_RsaPubHashP h_rsa;
218 :
219 331 : bs_pub = GNUNET_new (struct GNUNET_CRYPTO_BlindSignPublicKey);
220 331 : bs_pub->cipher = GNUNET_CRYPTO_BSA_RSA;
221 : bs_pub->details.rsa_public_key
222 662 : = GNUNET_CRYPTO_rsa_public_key_decode (buf,
223 331 : ntohs (kan->pub_size));
224 331 : if (NULL == bs_pub->details.rsa_public_key)
225 : {
226 0 : GNUNET_break_op (0);
227 0 : GNUNET_free (bs_pub);
228 0 : return GNUNET_SYSERR;
229 : }
230 331 : bs_pub->rc = 1;
231 331 : GNUNET_CRYPTO_rsa_public_key_hash (bs_pub->details.rsa_public_key,
232 : &bs_pub->pub_key_hash);
233 331 : h_rsa.hash = bs_pub->pub_key_hash;
234 331 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
235 : "Received RSA key %s (%s)\n",
236 : GNUNET_h2s (&bs_pub->pub_key_hash),
237 : section_name);
238 331 : if (GNUNET_OK !=
239 331 : TALER_exchange_secmod_rsa_verify (
240 : &h_rsa,
241 : section_name,
242 : GNUNET_TIME_timestamp_ntoh (kan->anchor_time),
243 : GNUNET_TIME_relative_ntoh (kan->duration_withdraw),
244 : &kan->secm_pub,
245 : &kan->secm_sig))
246 : {
247 0 : GNUNET_break_op (0);
248 0 : GNUNET_CRYPTO_blind_sign_pub_decref (bs_pub);
249 0 : return GNUNET_SYSERR;
250 : }
251 331 : dh->dkc (dh->dkc_cls,
252 : section_name,
253 : GNUNET_TIME_timestamp_ntoh (kan->anchor_time),
254 : GNUNET_TIME_relative_ntoh (kan->duration_withdraw),
255 : &h_rsa,
256 : bs_pub,
257 : &kan->secm_pub,
258 : &kan->secm_sig);
259 331 : GNUNET_CRYPTO_blind_sign_pub_decref (bs_pub);
260 : }
261 331 : return GNUNET_OK;
262 : }
263 :
264 :
265 : /**
266 : * Handle a #TALER_HELPER_RSA_MT_PURGE message from the helper.
267 : *
268 : * @param dh helper context
269 : * @param hdr message that we received
270 : * @return #GNUNET_OK on success
271 : */
272 : static enum GNUNET_GenericReturnValue
273 3 : handle_mt_purge (struct TALER_CRYPTO_RsaDenominationHelper *dh,
274 : const struct GNUNET_MessageHeader *hdr)
275 : {
276 3 : const struct TALER_CRYPTO_RsaKeyPurgeNotification *pn
277 : = (const struct TALER_CRYPTO_RsaKeyPurgeNotification *) hdr;
278 :
279 3 : if (sizeof (*pn) != ntohs (hdr->size))
280 : {
281 0 : GNUNET_break_op (0);
282 0 : return GNUNET_SYSERR;
283 : }
284 3 : GNUNET_log (GNUNET_ERROR_TYPE_INFO,
285 : "Received revocation of denomination key %s\n",
286 : GNUNET_h2s (&pn->h_rsa.hash));
287 3 : dh->dkc (dh->dkc_cls,
288 : NULL,
289 3 : GNUNET_TIME_UNIT_ZERO_TS,
290 3 : GNUNET_TIME_UNIT_ZERO,
291 : &pn->h_rsa,
292 : NULL,
293 : NULL,
294 : NULL);
295 3 : return GNUNET_OK;
296 : }
297 :
298 :
299 : void
300 738 : TALER_CRYPTO_helper_rsa_poll (struct TALER_CRYPTO_RsaDenominationHelper *dh)
301 : {
302 : char buf[UINT16_MAX];
303 738 : size_t off = 0;
304 738 : unsigned int retry_limit = 3;
305 738 : const struct GNUNET_MessageHeader *hdr
306 : = (const struct GNUNET_MessageHeader *) buf;
307 :
308 738 : if (GNUNET_OK !=
309 738 : try_connect (dh))
310 0 : return; /* give up */
311 : while (1)
312 32 : {
313 : uint16_t msize;
314 : ssize_t ret;
315 :
316 770 : ret = recv (dh->sock,
317 : buf + off,
318 : sizeof (buf) - off,
319 770 : (dh->synced && (0 == off))
320 : ? MSG_DONTWAIT
321 : : 0);
322 770 : if (ret < 0)
323 : {
324 738 : if (EINTR == errno)
325 0 : continue;
326 738 : if (EAGAIN == errno)
327 : {
328 738 : GNUNET_assert (dh->synced);
329 738 : GNUNET_assert (0 == off);
330 738 : break;
331 : }
332 0 : GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
333 : "recv");
334 0 : do_disconnect (dh);
335 0 : if (0 == retry_limit)
336 0 : return; /* give up */
337 0 : if (GNUNET_OK !=
338 0 : try_connect (dh))
339 0 : return; /* give up */
340 0 : retry_limit--;
341 0 : continue;
342 : }
343 32 : if (0 == ret)
344 : {
345 0 : GNUNET_break (0 == off);
346 0 : return;
347 : }
348 32 : off += ret;
349 392 : more:
350 392 : if (off < sizeof (struct GNUNET_MessageHeader))
351 32 : continue;
352 360 : msize = ntohs (hdr->size);
353 360 : if (off < msize)
354 0 : continue;
355 360 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
356 : "Received message of type %u and length %u\n",
357 : (unsigned int) ntohs (hdr->type),
358 : (unsigned int) msize);
359 360 : switch (ntohs (hdr->type))
360 : {
361 331 : case TALER_HELPER_RSA_MT_AVAIL:
362 331 : if (GNUNET_OK !=
363 331 : handle_mt_avail (dh,
364 : hdr))
365 : {
366 0 : GNUNET_break_op (0);
367 0 : do_disconnect (dh);
368 0 : return;
369 : }
370 331 : break;
371 3 : case TALER_HELPER_RSA_MT_PURGE:
372 3 : if (GNUNET_OK !=
373 3 : handle_mt_purge (dh,
374 : hdr))
375 : {
376 0 : GNUNET_break_op (0);
377 0 : do_disconnect (dh);
378 0 : return;
379 : }
380 3 : break;
381 26 : case TALER_HELPER_RSA_SYNCED:
382 26 : GNUNET_log (GNUNET_ERROR_TYPE_INFO,
383 : "Now synchronized with RSA helper\n");
384 26 : dh->synced = true;
385 26 : break;
386 0 : default:
387 0 : GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
388 : "Received unexpected message of type %d (len: %u)\n",
389 : (unsigned int) ntohs (hdr->type),
390 : (unsigned int) msize);
391 0 : GNUNET_break_op (0);
392 0 : do_disconnect (dh);
393 0 : return;
394 : }
395 360 : memmove (buf,
396 360 : &buf[msize],
397 : off - msize);
398 360 : off -= msize;
399 360 : goto more;
400 : }
401 : }
402 :
403 :
404 : enum TALER_ErrorCode
405 982 : TALER_CRYPTO_helper_rsa_batch_sign (
406 : struct TALER_CRYPTO_RsaDenominationHelper *dh,
407 : unsigned int rsrs_length,
408 : const struct TALER_CRYPTO_RsaSignRequest rsrs[static rsrs_length],
409 : struct TALER_BlindedDenominationSignature bss[static rsrs_length])
410 982 : {
411 982 : enum TALER_ErrorCode ec = TALER_EC_INVALID;
412 : unsigned int rpos;
413 : unsigned int rend;
414 : unsigned int wpos;
415 :
416 982 : memset (bss,
417 : 0,
418 : sizeof (*bss) * rsrs_length);
419 982 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
420 : "Starting signature process\n");
421 982 : if (GNUNET_OK !=
422 982 : try_connect (dh))
423 : {
424 0 : GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
425 : "Failed to connect to helper\n");
426 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_UNAVAILABLE;
427 : }
428 982 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
429 : "Requesting %u signatures\n",
430 : rsrs_length);
431 982 : rpos = 0;
432 982 : rend = 0;
433 982 : wpos = 0;
434 1964 : while (rpos < rsrs_length)
435 : {
436 982 : unsigned int mlen = sizeof (struct TALER_CRYPTO_BatchSignRequest);
437 :
438 2413 : while ( (rend < rsrs_length) &&
439 : (mlen
440 : + sizeof (struct TALER_CRYPTO_SignRequest)
441 1431 : + rsrs[rend].msg_size < UINT16_MAX) )
442 : {
443 1431 : mlen += sizeof (struct TALER_CRYPTO_SignRequest) + rsrs[rend].msg_size;
444 1431 : rend++;
445 : }
446 982 : {
447 982 : char obuf[mlen] GNUNET_ALIGN;
448 982 : struct TALER_CRYPTO_BatchSignRequest *bsr
449 : = (struct TALER_CRYPTO_BatchSignRequest *) obuf;
450 : void *wbuf;
451 :
452 982 : bsr->header.type = htons (TALER_HELPER_RSA_MT_REQ_BATCH_SIGN);
453 982 : bsr->header.size = htons (mlen);
454 982 : bsr->batch_size = htonl (rend - rpos);
455 982 : wbuf = &bsr[1];
456 2413 : for (unsigned int i = rpos; i<rend; i++)
457 : {
458 1431 : struct TALER_CRYPTO_SignRequest *sr = wbuf;
459 1431 : const struct TALER_CRYPTO_RsaSignRequest *rsr = &rsrs[i];
460 :
461 1431 : sr->header.type = htons (TALER_HELPER_RSA_MT_REQ_SIGN);
462 1431 : sr->header.size = htons (sizeof (*sr) + rsr->msg_size);
463 1431 : sr->reserved = htonl (0);
464 1431 : sr->h_rsa = *rsr->h_rsa;
465 1431 : GNUNET_memcpy (&sr[1],
466 : rsr->msg,
467 : rsr->msg_size);
468 1431 : wbuf += sizeof (*sr) + rsr->msg_size;
469 : }
470 982 : GNUNET_assert (wbuf == &obuf[mlen]);
471 982 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
472 : "Sending batch request [%u-%u)\n",
473 : rpos,
474 : rend);
475 982 : if (GNUNET_OK !=
476 982 : TALER_crypto_helper_send_all (dh->sock,
477 : obuf,
478 982 : sizeof (obuf)))
479 : {
480 0 : GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
481 : "send");
482 0 : do_disconnect (dh);
483 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_UNAVAILABLE;
484 : }
485 : }
486 982 : rpos = rend;
487 : {
488 : char buf[UINT16_MAX];
489 982 : size_t off = 0;
490 982 : const struct GNUNET_MessageHeader *hdr
491 : = (const struct GNUNET_MessageHeader *) buf;
492 982 : bool finished = false;
493 :
494 : while (1)
495 1229 : {
496 : uint16_t msize;
497 : ssize_t ret;
498 :
499 2211 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
500 : "Awaiting reply at %u (up to %u)\n",
501 : wpos,
502 : rend);
503 3193 : ret = recv (dh->sock,
504 2211 : &buf[off],
505 : sizeof (buf) - off,
506 982 : (finished && (0 == off))
507 : ? MSG_DONTWAIT
508 : : 0);
509 2211 : if (ret < 0)
510 : {
511 982 : if (EINTR == errno)
512 0 : continue;
513 982 : if (EAGAIN == errno)
514 : {
515 982 : GNUNET_assert (finished);
516 982 : GNUNET_assert (0 == off);
517 982 : break;
518 : }
519 0 : GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
520 : "recv");
521 0 : do_disconnect (dh);
522 0 : ec = TALER_EC_EXCHANGE_DENOMINATION_HELPER_UNAVAILABLE;
523 0 : break;
524 : }
525 1229 : if (0 == ret)
526 : {
527 0 : GNUNET_break (0 == off);
528 0 : if (! finished)
529 0 : ec = TALER_EC_EXCHANGE_SIGNKEY_HELPER_BUG;
530 0 : if (TALER_EC_NONE == ec)
531 0 : break;
532 0 : return ec;
533 : }
534 1229 : off += ret;
535 2660 : more:
536 2660 : if (off < sizeof (struct GNUNET_MessageHeader))
537 1229 : continue;
538 1431 : msize = ntohs (hdr->size);
539 1431 : if (off < msize)
540 0 : continue;
541 1431 : switch (ntohs (hdr->type))
542 : {
543 1160 : case TALER_HELPER_RSA_MT_RES_SIGNATURE:
544 1160 : if (msize < sizeof (struct TALER_CRYPTO_SignResponse))
545 : {
546 0 : GNUNET_break_op (0);
547 0 : do_disconnect (dh);
548 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_BUG;
549 : }
550 1160 : if (finished)
551 : {
552 0 : GNUNET_break_op (0);
553 0 : do_disconnect (dh);
554 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_BUG;
555 : }
556 : {
557 1160 : const struct TALER_CRYPTO_SignResponse *sr =
558 : (const struct TALER_CRYPTO_SignResponse *) buf;
559 : struct GNUNET_CRYPTO_RsaSignature *rsa_signature;
560 : struct GNUNET_CRYPTO_BlindedSignature *blind_sig;
561 :
562 1160 : rsa_signature = GNUNET_CRYPTO_rsa_signature_decode (
563 1160 : &sr[1],
564 : msize - sizeof (*sr));
565 1160 : if (NULL == rsa_signature)
566 : {
567 0 : GNUNET_break_op (0);
568 0 : do_disconnect (dh);
569 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_BUG;
570 : }
571 1160 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
572 : "Received %u signature\n",
573 : wpos);
574 1160 : blind_sig = GNUNET_new (struct GNUNET_CRYPTO_BlindedSignature);
575 1160 : blind_sig->cipher = GNUNET_CRYPTO_BSA_RSA;
576 1160 : blind_sig->rc = 1;
577 1160 : blind_sig->details.blinded_rsa_signature = rsa_signature;
578 1160 : bss[wpos].blinded_sig = blind_sig;
579 1160 : wpos++;
580 1160 : if (wpos == rend)
581 : {
582 967 : if (TALER_EC_INVALID == ec)
583 967 : ec = TALER_EC_NONE;
584 967 : finished = true;
585 : }
586 1160 : break;
587 : }
588 271 : case TALER_HELPER_RSA_MT_RES_SIGN_FAILURE:
589 271 : if (msize != sizeof (struct TALER_CRYPTO_SignFailure))
590 : {
591 0 : GNUNET_break_op (0);
592 0 : do_disconnect (dh);
593 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_BUG;
594 : }
595 : {
596 271 : const struct TALER_CRYPTO_SignFailure *sf =
597 : (const struct TALER_CRYPTO_SignFailure *) buf;
598 :
599 271 : ec = (enum TALER_ErrorCode) (int) ntohl (sf->ec);
600 271 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
601 : "Signing %u failed with status %d!\n",
602 : wpos,
603 : ec);
604 271 : wpos++;
605 271 : if (wpos == rend)
606 : {
607 15 : finished = true;
608 : }
609 271 : break;
610 : }
611 0 : case TALER_HELPER_RSA_MT_AVAIL:
612 0 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
613 : "Received new key!\n");
614 0 : if (GNUNET_OK !=
615 0 : handle_mt_avail (dh,
616 : hdr))
617 : {
618 0 : GNUNET_break_op (0);
619 0 : do_disconnect (dh);
620 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_BUG;
621 : }
622 0 : break; /* while(1) loop ensures we recvfrom() again */
623 0 : case TALER_HELPER_RSA_MT_PURGE:
624 0 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
625 : "Received revocation!\n");
626 0 : if (GNUNET_OK !=
627 0 : handle_mt_purge (dh,
628 : hdr))
629 : {
630 0 : GNUNET_break_op (0);
631 0 : do_disconnect (dh);
632 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_BUG;
633 : }
634 0 : break; /* while(1) loop ensures we recvfrom() again */
635 0 : case TALER_HELPER_RSA_SYNCED:
636 0 : GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
637 : "Synchronized add odd time with RSA helper!\n");
638 0 : dh->synced = true;
639 0 : break;
640 0 : default:
641 0 : GNUNET_break_op (0);
642 0 : GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
643 : "Received unexpected message of type %u\n",
644 : ntohs (hdr->type));
645 0 : do_disconnect (dh);
646 0 : return TALER_EC_EXCHANGE_DENOMINATION_HELPER_BUG;
647 : }
648 1431 : memmove (buf,
649 1431 : &buf[msize],
650 : off - msize);
651 1431 : off -= msize;
652 1431 : goto more;
653 : } /* while(1) */
654 : } /* scope */
655 : } /* while (rpos < rsrs_length) */
656 982 : GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
657 : "Existing with %u signatures and status %d\n",
658 : wpos,
659 : ec);
660 982 : return ec;
661 : }
662 :
663 :
664 : void
665 3 : TALER_CRYPTO_helper_rsa_revoke (
666 : struct TALER_CRYPTO_RsaDenominationHelper *dh,
667 : const struct TALER_RsaPubHashP *h_rsa)
668 : {
669 3 : struct TALER_CRYPTO_RevokeRequest rr = {
670 3 : .header.size = htons (sizeof (rr)),
671 3 : .header.type = htons (TALER_HELPER_RSA_MT_REQ_REVOKE),
672 : .h_rsa = *h_rsa
673 : };
674 :
675 3 : if (GNUNET_OK !=
676 3 : try_connect (dh))
677 0 : return; /* give up */
678 3 : if (GNUNET_OK !=
679 3 : TALER_crypto_helper_send_all (dh->sock,
680 : &rr,
681 : sizeof (rr)))
682 : {
683 0 : GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
684 : "send");
685 0 : do_disconnect (dh);
686 0 : return;
687 : }
688 3 : GNUNET_log (GNUNET_ERROR_TYPE_INFO,
689 : "Requested revocation of denomination key %s\n",
690 : GNUNET_h2s (&h_rsa->hash));
691 : }
692 :
693 :
694 : void
695 27 : TALER_CRYPTO_helper_rsa_disconnect (
696 : struct TALER_CRYPTO_RsaDenominationHelper *dh)
697 : {
698 27 : if (-1 != dh->sock)
699 26 : do_disconnect (dh);
700 27 : GNUNET_free (dh);
701 27 : }
702 :
703 :
704 : /* end of crypto_helper_denom.c */
|
