summaryrefslogtreecommitdiff
path: root/src/secretsharing/secretsharing_api.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/secretsharing/secretsharing_api.c')
-rw-r--r--src/secretsharing/secretsharing_api.c337
1 files changed, 167 insertions, 170 deletions
diff --git a/src/secretsharing/secretsharing_api.c b/src/secretsharing/secretsharing_api.c
index 065aac8d7..da9e14d1e 100644
--- a/src/secretsharing/secretsharing_api.c
+++ b/src/secretsharing/secretsharing_api.c
@@ -11,12 +11,12 @@
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20 20
21/** 21/**
22 * @file secretsharing/secretsharing_api.c 22 * @file secretsharing/secretsharing_api.c
@@ -30,15 +30,13 @@
30#include <gcrypt.h> 30#include <gcrypt.h>
31 31
32 32
33#define LOG(kind,...) GNUNET_log_from (kind, "secretsharing-api",__VA_ARGS__) 33#define LOG(kind, ...) GNUNET_log_from(kind, "secretsharing-api", __VA_ARGS__)
34 34
35/** 35/**
36 * Session that will eventually establish a shared secred between 36 * Session that will eventually establish a shared secred between
37 * the involved peers and allow encryption and cooperative decryption. 37 * the involved peers and allow encryption and cooperative decryption.
38 */ 38 */
39struct GNUNET_SECRETSHARING_Session 39struct GNUNET_SECRETSHARING_Session {
40{
41
42 /** 40 /**
43 * Message queue for @e client. 41 * Message queue for @e client.
44 */ 42 */
@@ -59,9 +57,7 @@ struct GNUNET_SECRETSHARING_Session
59/** 57/**
60 * Handle to cancel a cooperative decryption operation. 58 * Handle to cancel a cooperative decryption operation.
61 */ 59 */
62struct GNUNET_SECRETSHARING_DecryptionHandle 60struct GNUNET_SECRETSHARING_DecryptionHandle {
63{
64
65 /** 61 /**
66 * Message queue for @e client. 62 * Message queue for @e client.
67 */ 63 */
@@ -102,17 +98,17 @@ static gcry_mpi_t elgamal_g;
102 * Function to initialize #elgamal_q, #elgamal_p and #elgamal_g. 98 * Function to initialize #elgamal_q, #elgamal_p and #elgamal_g.
103 */ 99 */
104static void 100static void
105ensure_elgamal_initialized (void) 101ensure_elgamal_initialized(void)
106{ 102{
107 if (NULL != elgamal_q) 103 if (NULL != elgamal_q)
108 return; /* looks like crypto is already initialized */ 104 return; /* looks like crypto is already initialized */
109 105
110 GNUNET_assert (0 == gcry_mpi_scan (&elgamal_q, GCRYMPI_FMT_HEX, 106 GNUNET_assert(0 == gcry_mpi_scan(&elgamal_q, GCRYMPI_FMT_HEX,
111 GNUNET_SECRETSHARING_ELGAMAL_Q_HEX, 0, NULL)); 107 GNUNET_SECRETSHARING_ELGAMAL_Q_HEX, 0, NULL));
112 GNUNET_assert (0 == gcry_mpi_scan (&elgamal_p, GCRYMPI_FMT_HEX, 108 GNUNET_assert(0 == gcry_mpi_scan(&elgamal_p, GCRYMPI_FMT_HEX,
113 GNUNET_SECRETSHARING_ELGAMAL_P_HEX, 0, NULL)); 109 GNUNET_SECRETSHARING_ELGAMAL_P_HEX, 0, NULL));
114 GNUNET_assert (0 == gcry_mpi_scan (&elgamal_g, GCRYMPI_FMT_HEX, 110 GNUNET_assert(0 == gcry_mpi_scan(&elgamal_g, GCRYMPI_FMT_HEX,
115 GNUNET_SECRETSHARING_ELGAMAL_G_HEX, 0, NULL)); 111 GNUNET_SECRETSHARING_ELGAMAL_G_HEX, 0, NULL));
116} 112}
117 113
118 114
@@ -124,13 +120,13 @@ ensure_elgamal_initialized (void)
124 * @param error error code 120 * @param error error code
125 */ 121 */
126static void 122static void
127handle_session_client_error (void *cls, 123handle_session_client_error(void *cls,
128 enum GNUNET_MQ_Error error) 124 enum GNUNET_MQ_Error error)
129{ 125{
130 struct GNUNET_SECRETSHARING_Session *s = cls; 126 struct GNUNET_SECRETSHARING_Session *s = cls;
131 127
132 s->secret_ready_cb (s->secret_ready_cls, NULL, NULL, 0, NULL); 128 s->secret_ready_cb(s->secret_ready_cls, NULL, NULL, 0, NULL);
133 GNUNET_SECRETSHARING_session_destroy (s); 129 GNUNET_SECRETSHARING_session_destroy(s);
134} 130}
135 131
136 132
@@ -142,13 +138,13 @@ handle_session_client_error (void *cls,
142 * @param error error code 138 * @param error error code
143 */ 139 */
144static void 140static void
145handle_decrypt_client_error (void *cls, 141handle_decrypt_client_error(void *cls,
146 enum GNUNET_MQ_Error error) 142 enum GNUNET_MQ_Error error)
147{ 143{
148 struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls; 144 struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls;
149 145
150 dh->decrypt_cb (dh->decrypt_cls, NULL); 146 dh->decrypt_cb(dh->decrypt_cls, NULL);
151 GNUNET_SECRETSHARING_decrypt_cancel (dh); 147 GNUNET_SECRETSHARING_decrypt_cancel(dh);
152} 148}
153 149
154 150
@@ -161,8 +157,8 @@ handle_decrypt_client_error (void *cls,
161 * @param m message with the result 157 * @param m message with the result
162 */ 158 */
163static int 159static int
164check_secret_ready (void *cls, 160check_secret_ready(void *cls,
165 const struct GNUNET_SECRETSHARING_SecretReadyMessage *m) 161 const struct GNUNET_SECRETSHARING_SecretReadyMessage *m)
166{ 162{
167 /* FIXME: actually check m is well-formed here! */ 163 /* FIXME: actually check m is well-formed here! */
168 return GNUNET_OK; 164 return GNUNET_OK;
@@ -178,32 +174,32 @@ check_secret_ready (void *cls,
178 * @param m message with the result 174 * @param m message with the result
179 */ 175 */
180static void 176static void
181handle_secret_ready (void *cls, 177handle_secret_ready(void *cls,
182 const struct GNUNET_SECRETSHARING_SecretReadyMessage *m) 178 const struct GNUNET_SECRETSHARING_SecretReadyMessage *m)
183{ 179{
184 struct GNUNET_SECRETSHARING_Session *s = cls; 180 struct GNUNET_SECRETSHARING_Session *s = cls;
185 struct GNUNET_SECRETSHARING_Share *share; 181 struct GNUNET_SECRETSHARING_Share *share;
186 size_t share_size; 182 size_t share_size;
187 183
188 LOG (GNUNET_ERROR_TYPE_DEBUG, 184 LOG(GNUNET_ERROR_TYPE_DEBUG,
189 "Got secret ready message of size %u\n", 185 "Got secret ready message of size %u\n",
190 ntohs (m->header.size)); 186 ntohs(m->header.size));
191 share_size = ntohs (m->header.size) - sizeof (struct GNUNET_SECRETSHARING_SecretReadyMessage); 187 share_size = ntohs(m->header.size) - sizeof(struct GNUNET_SECRETSHARING_SecretReadyMessage);
192 188
193 share = GNUNET_SECRETSHARING_share_read (&m[1], 189 share = GNUNET_SECRETSHARING_share_read(&m[1],
194 share_size, 190 share_size,
195 NULL); 191 NULL);
196 GNUNET_assert (NULL != share); // FIXME: this can fail! 192 GNUNET_assert(NULL != share); // FIXME: this can fail!
197 // should have been checked in #check_secret_ready! 193 // should have been checked in #check_secret_ready!
198 // FIXME: below we never check &m[1] is valid! 194 // FIXME: below we never check &m[1] is valid!
199 // FIXME: do we leak 'share' here? 195 // FIXME: do we leak 'share' here?
200 s->secret_ready_cb (s->secret_ready_cls, 196 s->secret_ready_cb(s->secret_ready_cls,
201 share, /* FIXME */ 197 share, /* FIXME */
202 &share->public_key, 198 &share->public_key,
203 share->num_peers, 199 share->num_peers,
204 (const struct GNUNET_PeerIdentity *) &m[1]); 200 (const struct GNUNET_PeerIdentity *)&m[1]);
205 201
206 GNUNET_SECRETSHARING_session_destroy (s); 202 GNUNET_SECRETSHARING_session_destroy(s);
207} 203}
208 204
209 205
@@ -214,11 +210,11 @@ handle_secret_ready (void *cls,
214 * @param s session to destroy 210 * @param s session to destroy
215 */ 211 */
216void 212void
217GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *s) 213GNUNET_SECRETSHARING_session_destroy(struct GNUNET_SECRETSHARING_Session *s)
218{ 214{
219 GNUNET_MQ_destroy (s->mq); 215 GNUNET_MQ_destroy(s->mq);
220 s->mq = NULL; 216 s->mq = NULL;
221 GNUNET_free (s); 217 GNUNET_free(s);
222} 218}
223 219
224 220
@@ -239,65 +235,65 @@ GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *s)
239 * @param cls closure for @a cb 235 * @param cls closure for @a cb
240 */ 236 */
241struct GNUNET_SECRETSHARING_Session * 237struct GNUNET_SECRETSHARING_Session *
242GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *cfg, 238GNUNET_SECRETSHARING_create_session(const struct GNUNET_CONFIGURATION_Handle *cfg,
243 unsigned int num_peers, 239 unsigned int num_peers,
244 const struct GNUNET_PeerIdentity *peers, 240 const struct GNUNET_PeerIdentity *peers,
245 const struct GNUNET_HashCode *session_id, 241 const struct GNUNET_HashCode *session_id,
246 struct GNUNET_TIME_Absolute start, 242 struct GNUNET_TIME_Absolute start,
247 struct GNUNET_TIME_Absolute deadline, 243 struct GNUNET_TIME_Absolute deadline,
248 unsigned int threshold, 244 unsigned int threshold,
249 GNUNET_SECRETSHARING_SecretReadyCallback cb, 245 GNUNET_SECRETSHARING_SecretReadyCallback cb,
250 void *cls) 246 void *cls)
251{ 247{
252 struct GNUNET_SECRETSHARING_Session *s 248 struct GNUNET_SECRETSHARING_Session *s
253 = GNUNET_new (struct GNUNET_SECRETSHARING_Session); 249 = GNUNET_new(struct GNUNET_SECRETSHARING_Session);
254 struct GNUNET_MQ_MessageHandler mq_handlers[] = { 250 struct GNUNET_MQ_MessageHandler mq_handlers[] = {
255 GNUNET_MQ_hd_var_size (secret_ready, 251 GNUNET_MQ_hd_var_size(secret_ready,
256 GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY, 252 GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY,
257 struct GNUNET_SECRETSHARING_SecretReadyMessage, 253 struct GNUNET_SECRETSHARING_SecretReadyMessage,
258 s), 254 s),
259 GNUNET_MQ_handler_end () 255 GNUNET_MQ_handler_end()
260 }; 256 };
261 struct GNUNET_MQ_Envelope *ev; 257 struct GNUNET_MQ_Envelope *ev;
262 struct GNUNET_SECRETSHARING_CreateMessage *msg; 258 struct GNUNET_SECRETSHARING_CreateMessage *msg;
263 259
264 s->mq = GNUNET_CLIENT_connect (cfg, 260 s->mq = GNUNET_CLIENT_connect(cfg,
265 "secretsharing", 261 "secretsharing",
266 mq_handlers, 262 mq_handlers,
267 &handle_session_client_error, 263 &handle_session_client_error,
268 s); 264 s);
269 if (NULL == s->mq) 265 if (NULL == s->mq)
270 { 266 {
271 /* secretsharing not configured correctly */ 267 /* secretsharing not configured correctly */
272 GNUNET_break (0); 268 GNUNET_break(0);
273 GNUNET_free (s); 269 GNUNET_free(s);
274 return NULL; 270 return NULL;
275 } 271 }
276 s->secret_ready_cb = cb; 272 s->secret_ready_cb = cb;
277 s->secret_ready_cls = cls; 273 s->secret_ready_cls = cls;
278 ev = GNUNET_MQ_msg_extra (msg, 274 ev = GNUNET_MQ_msg_extra(msg,
279 num_peers * sizeof (struct GNUNET_PeerIdentity), 275 num_peers * sizeof(struct GNUNET_PeerIdentity),
280 GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_GENERATE); 276 GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_GENERATE);
281 277
282 msg->threshold = htons (threshold); 278 msg->threshold = htons(threshold);
283 msg->num_peers = htons (num_peers); 279 msg->num_peers = htons(num_peers);
284 msg->session_id = *session_id; 280 msg->session_id = *session_id;
285 msg->start = GNUNET_TIME_absolute_hton (start); 281 msg->start = GNUNET_TIME_absolute_hton(start);
286 msg->deadline = GNUNET_TIME_absolute_hton (deadline); 282 msg->deadline = GNUNET_TIME_absolute_hton(deadline);
287 GNUNET_memcpy (&msg[1], peers, num_peers * sizeof (struct GNUNET_PeerIdentity)); 283 GNUNET_memcpy(&msg[1], peers, num_peers * sizeof(struct GNUNET_PeerIdentity));
288 284
289 GNUNET_MQ_send (s->mq, ev); 285 GNUNET_MQ_send(s->mq, ev);
290 286
291 LOG (GNUNET_ERROR_TYPE_DEBUG, 287 LOG(GNUNET_ERROR_TYPE_DEBUG,
292 "Secretsharing session created with %u peers\n", 288 "Secretsharing session created with %u peers\n",
293 num_peers); 289 num_peers);
294 return s; 290 return s;
295} 291}
296 292
297 293
298static void 294static void
299handle_decrypt_done (void *cls, 295handle_decrypt_done(void *cls,
300 const struct GNUNET_SECRETSHARING_DecryptResponseMessage *m) 296 const struct GNUNET_SECRETSHARING_DecryptResponseMessage *m)
301{ 297{
302 struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls; 298 struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls;
303 const struct GNUNET_SECRETSHARING_Plaintext *plaintext; 299 const struct GNUNET_SECRETSHARING_Plaintext *plaintext;
@@ -305,9 +301,9 @@ handle_decrypt_done (void *cls,
305 if (m->success == 0) 301 if (m->success == 0)
306 plaintext = NULL; 302 plaintext = NULL;
307 else 303 else
308 plaintext = (void *) &m->plaintext; 304 plaintext = (void *)&m->plaintext;
309 dh->decrypt_cb (dh->decrypt_cls, plaintext); 305 dh->decrypt_cb(dh->decrypt_cls, plaintext);
310 GNUNET_SECRETSHARING_decrypt_cancel (dh); 306 GNUNET_SECRETSHARING_decrypt_cancel(dh);
311} 307}
312 308
313 309
@@ -325,22 +321,22 @@ handle_decrypt_done (void *cls,
325 * @return handle to cancel the operation 321 * @return handle to cancel the operation
326 */ 322 */
327struct GNUNET_SECRETSHARING_DecryptionHandle * 323struct GNUNET_SECRETSHARING_DecryptionHandle *
328GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg, 324GNUNET_SECRETSHARING_decrypt(const struct GNUNET_CONFIGURATION_Handle *cfg,
329 struct GNUNET_SECRETSHARING_Share *share, 325 struct GNUNET_SECRETSHARING_Share *share,
330 const struct GNUNET_SECRETSHARING_Ciphertext *ciphertext, 326 const struct GNUNET_SECRETSHARING_Ciphertext *ciphertext,
331 struct GNUNET_TIME_Absolute start, 327 struct GNUNET_TIME_Absolute start,
332 struct GNUNET_TIME_Absolute deadline, 328 struct GNUNET_TIME_Absolute deadline,
333 GNUNET_SECRETSHARING_DecryptCallback decrypt_cb, 329 GNUNET_SECRETSHARING_DecryptCallback decrypt_cb,
334 void *decrypt_cb_cls) 330 void *decrypt_cb_cls)
335{ 331{
336 struct GNUNET_SECRETSHARING_DecryptionHandle *s 332 struct GNUNET_SECRETSHARING_DecryptionHandle *s
337 = GNUNET_new (struct GNUNET_SECRETSHARING_DecryptionHandle); 333 = GNUNET_new(struct GNUNET_SECRETSHARING_DecryptionHandle);
338 struct GNUNET_MQ_MessageHandler mq_handlers[] = { 334 struct GNUNET_MQ_MessageHandler mq_handlers[] = {
339 GNUNET_MQ_hd_fixed_size (decrypt_done, 335 GNUNET_MQ_hd_fixed_size(decrypt_done,
340 GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE, 336 GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE,
341 struct GNUNET_SECRETSHARING_DecryptResponseMessage, 337 struct GNUNET_SECRETSHARING_DecryptResponseMessage,
342 s), 338 s),
343 GNUNET_MQ_handler_end () 339 GNUNET_MQ_handler_end()
344 }; 340 };
345 struct GNUNET_MQ_Envelope *ev; 341 struct GNUNET_MQ_Envelope *ev;
346 struct GNUNET_SECRETSHARING_DecryptRequestMessage *msg; 342 struct GNUNET_SECRETSHARING_DecryptRequestMessage *msg;
@@ -348,75 +344,75 @@ GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg,
348 344
349 s->decrypt_cb = decrypt_cb; 345 s->decrypt_cb = decrypt_cb;
350 s->decrypt_cls = decrypt_cb_cls; 346 s->decrypt_cls = decrypt_cb_cls;
351 s->mq = GNUNET_CLIENT_connect (cfg, 347 s->mq = GNUNET_CLIENT_connect(cfg,
352 "secretsharing", 348 "secretsharing",
353 mq_handlers, 349 mq_handlers,
354 &handle_decrypt_client_error, 350 &handle_decrypt_client_error,
355 s); 351 s);
356 if (NULL == s->mq) 352 if (NULL == s->mq)
357 { 353 {
358 GNUNET_free (s); 354 GNUNET_free(s);
359 return NULL; 355 return NULL;
360 } 356 }
361 GNUNET_assert (GNUNET_OK == 357 GNUNET_assert(GNUNET_OK ==
362 GNUNET_SECRETSHARING_share_write (share, NULL, 0, 358 GNUNET_SECRETSHARING_share_write(share, NULL, 0,
363 &share_size)); 359 &share_size));
364 360
365 ev = GNUNET_MQ_msg_extra (msg, 361 ev = GNUNET_MQ_msg_extra(msg,
366 share_size, 362 share_size,
367 GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT); 363 GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT);
368 364
369 GNUNET_assert (GNUNET_OK == 365 GNUNET_assert(GNUNET_OK ==
370 GNUNET_SECRETSHARING_share_write (share, 366 GNUNET_SECRETSHARING_share_write(share,
371 &msg[1], 367 &msg[1],
372 share_size, 368 share_size,
373 NULL)); 369 NULL));
374 370
375 msg->start = GNUNET_TIME_absolute_hton (start); 371 msg->start = GNUNET_TIME_absolute_hton(start);
376 msg->deadline = GNUNET_TIME_absolute_hton (deadline); 372 msg->deadline = GNUNET_TIME_absolute_hton(deadline);
377 msg->ciphertext = *ciphertext; 373 msg->ciphertext = *ciphertext;
378 374
379 GNUNET_MQ_send (s->mq, ev); 375 GNUNET_MQ_send(s->mq, ev);
380 376
381 LOG (GNUNET_ERROR_TYPE_DEBUG, 377 LOG(GNUNET_ERROR_TYPE_DEBUG,
382 "decrypt session created\n"); 378 "decrypt session created\n");
383 return s; 379 return s;
384} 380}
385 381
386 382
387int 383int
388GNUNET_SECRETSHARING_plaintext_generate_i (struct GNUNET_SECRETSHARING_Plaintext *plaintext, 384GNUNET_SECRETSHARING_plaintext_generate_i(struct GNUNET_SECRETSHARING_Plaintext *plaintext,
389 int64_t exponent) 385 int64_t exponent)
390{ 386{
391 int negative; 387 int negative;
392 gcry_mpi_t x; 388 gcry_mpi_t x;
393 389
394 ensure_elgamal_initialized (); 390 ensure_elgamal_initialized();
395 391
396 GNUNET_assert (NULL != (x = gcry_mpi_new (0))); 392 GNUNET_assert(NULL != (x = gcry_mpi_new(0)));
397 393
398 negative = GNUNET_NO; 394 negative = GNUNET_NO;
399 if (exponent < 0) 395 if (exponent < 0)
400 { 396 {
401 negative = GNUNET_YES; 397 negative = GNUNET_YES;
402 exponent = -exponent; 398 exponent = -exponent;
403 } 399 }
404 400
405 gcry_mpi_set_ui (x, exponent); 401 gcry_mpi_set_ui(x, exponent);
406 402
407 gcry_mpi_powm (x, elgamal_g, x, elgamal_p); 403 gcry_mpi_powm(x, elgamal_g, x, elgamal_p);
408 404
409 if (GNUNET_YES == negative) 405 if (GNUNET_YES == negative)
410 { 406 {
411 int res; 407 int res;
412 res = gcry_mpi_invm (x, x, elgamal_p); 408 res = gcry_mpi_invm(x, x, elgamal_p);
413 if (0 == res) 409 if (0 == res)
414 return GNUNET_SYSERR; 410 return GNUNET_SYSERR;
415 } 411 }
416 412
417 GNUNET_CRYPTO_mpi_print_unsigned (plaintext, 413 GNUNET_CRYPTO_mpi_print_unsigned(plaintext,
418 sizeof (struct GNUNET_SECRETSHARING_Plaintext), 414 sizeof(struct GNUNET_SECRETSHARING_Plaintext),
419 x); 415 x);
420 416
421 return GNUNET_OK; 417 return GNUNET_OK;
422} 418}
@@ -436,9 +432,9 @@ GNUNET_SECRETSHARING_plaintext_generate_i (struct GNUNET_SECRETSHARING_Plaintext
436 * @return #GNUNET_YES on succes, #GNUNET_SYSERR if the message is invalid (invalid range) 432 * @return #GNUNET_YES on succes, #GNUNET_SYSERR if the message is invalid (invalid range)
437 */ 433 */
438int 434int
439GNUNET_SECRETSHARING_encrypt (const struct GNUNET_SECRETSHARING_PublicKey *public_key, 435GNUNET_SECRETSHARING_encrypt(const struct GNUNET_SECRETSHARING_PublicKey *public_key,
440 const struct GNUNET_SECRETSHARING_Plaintext *plaintext, 436 const struct GNUNET_SECRETSHARING_Plaintext *plaintext,
441 struct GNUNET_SECRETSHARING_Ciphertext *result_ciphertext) 437 struct GNUNET_SECRETSHARING_Ciphertext *result_ciphertext)
442{ 438{
443 /* pubkey */ 439 /* pubkey */
444 gcry_mpi_t h; 440 gcry_mpi_t h;
@@ -449,35 +445,36 @@ GNUNET_SECRETSHARING_encrypt (const struct GNUNET_SECRETSHARING_PublicKey *publi
449 /* temp value */ 445 /* temp value */
450 gcry_mpi_t tmp; 446 gcry_mpi_t tmp;
451 447
452 ensure_elgamal_initialized (); 448 ensure_elgamal_initialized();
453 449
454 GNUNET_assert (NULL != (h = gcry_mpi_new (0))); 450 GNUNET_assert(NULL != (h = gcry_mpi_new(0)));
455 GNUNET_assert (NULL != (y = gcry_mpi_new (0))); 451 GNUNET_assert(NULL != (y = gcry_mpi_new(0)));
456 GNUNET_assert (NULL != (tmp = gcry_mpi_new (0))); 452 GNUNET_assert(NULL != (tmp = gcry_mpi_new(0)));
457 453
458 GNUNET_CRYPTO_mpi_scan_unsigned (&h, public_key, sizeof *public_key); 454 GNUNET_CRYPTO_mpi_scan_unsigned(&h, public_key, sizeof *public_key);
459 GNUNET_CRYPTO_mpi_scan_unsigned (&m, plaintext, sizeof *plaintext); 455 GNUNET_CRYPTO_mpi_scan_unsigned(&m, plaintext, sizeof *plaintext);
460 456
461 // Randomize y such that 0 < y < elgamal_q. 457 // Randomize y such that 0 < y < elgamal_q.
462 // The '- 1' is necessary as bitlength(q) = bitlength(p) - 1. 458 // The '- 1' is necessary as bitlength(q) = bitlength(p) - 1.
463 do 459 do
464 { 460 {
465 gcry_mpi_randomize (y, GNUNET_SECRETSHARING_ELGAMAL_BITS - 1, GCRY_WEAK_RANDOM); 461 gcry_mpi_randomize(y, GNUNET_SECRETSHARING_ELGAMAL_BITS - 1, GCRY_WEAK_RANDOM);
466 } while ((gcry_mpi_cmp_ui (y, 0) == 0) || (gcry_mpi_cmp (y, elgamal_q) >= 0)); 462 }
463 while ((gcry_mpi_cmp_ui(y, 0) == 0) || (gcry_mpi_cmp(y, elgamal_q) >= 0));
467 464
468 // tmp <- g^y 465 // tmp <- g^y
469 gcry_mpi_powm (tmp, elgamal_g, y, elgamal_p); 466 gcry_mpi_powm(tmp, elgamal_g, y, elgamal_p);
470 // write tmp to c1 467 // write tmp to c1
471 GNUNET_CRYPTO_mpi_print_unsigned (&result_ciphertext->c1_bits, 468 GNUNET_CRYPTO_mpi_print_unsigned(&result_ciphertext->c1_bits,
472 GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp); 469 GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
473 470
474 // tmp <- h^y 471 // tmp <- h^y
475 gcry_mpi_powm (tmp, h, y, elgamal_p); 472 gcry_mpi_powm(tmp, h, y, elgamal_p);
476 // tmp <- tmp * m 473 // tmp <- tmp * m
477 gcry_mpi_mulm (tmp, tmp, m, elgamal_p); 474 gcry_mpi_mulm(tmp, tmp, m, elgamal_p);
478 // write tmp to c2 475 // write tmp to c2
479 GNUNET_CRYPTO_mpi_print_unsigned (&result_ciphertext->c2_bits, 476 GNUNET_CRYPTO_mpi_print_unsigned(&result_ciphertext->c2_bits,
480 GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp); 477 GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
481 478
482 return GNUNET_OK; 479 return GNUNET_OK;
483} 480}
@@ -492,11 +489,11 @@ GNUNET_SECRETSHARING_encrypt (const struct GNUNET_SECRETSHARING_PublicKey *publi
492 * @param dh to cancel 489 * @param dh to cancel
493 */ 490 */
494void 491void
495GNUNET_SECRETSHARING_decrypt_cancel (struct GNUNET_SECRETSHARING_DecryptionHandle *dh) 492GNUNET_SECRETSHARING_decrypt_cancel(struct GNUNET_SECRETSHARING_DecryptionHandle *dh)
496{ 493{
497 GNUNET_MQ_destroy (dh->mq); 494 GNUNET_MQ_destroy(dh->mq);
498 dh->mq = NULL; 495 dh->mq = NULL;
499 GNUNET_free (dh); 496 GNUNET_free(dh);
500} 497}
501 498
502/* end of secretsharing_api.c */ 499/* end of secretsharing_api.c */