diff options
Diffstat (limited to 'src/secretsharing/secretsharing_api.c')
-rw-r--r-- | src/secretsharing/secretsharing_api.c | 337 |
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 | */ |
39 | struct GNUNET_SECRETSHARING_Session | 39 | struct 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 | */ |
62 | struct GNUNET_SECRETSHARING_DecryptionHandle | 60 | struct 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 | */ |
104 | static void | 100 | static void |
105 | ensure_elgamal_initialized (void) | 101 | ensure_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 | */ |
126 | static void | 122 | static void |
127 | handle_session_client_error (void *cls, | 123 | handle_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 | */ |
144 | static void | 140 | static void |
145 | handle_decrypt_client_error (void *cls, | 141 | handle_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 | */ |
163 | static int | 159 | static int |
164 | check_secret_ready (void *cls, | 160 | check_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 | */ |
180 | static void | 176 | static void |
181 | handle_secret_ready (void *cls, | 177 | handle_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 | */ |
216 | void | 212 | void |
217 | GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *s) | 213 | GNUNET_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 | */ |
241 | struct GNUNET_SECRETSHARING_Session * | 237 | struct GNUNET_SECRETSHARING_Session * |
242 | GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *cfg, | 238 | GNUNET_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 | ||
298 | static void | 294 | static void |
299 | handle_decrypt_done (void *cls, | 295 | handle_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 | */ |
327 | struct GNUNET_SECRETSHARING_DecryptionHandle * | 323 | struct GNUNET_SECRETSHARING_DecryptionHandle * |
328 | GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg, | 324 | GNUNET_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 | ||
387 | int | 383 | int |
388 | GNUNET_SECRETSHARING_plaintext_generate_i (struct GNUNET_SECRETSHARING_Plaintext *plaintext, | 384 | GNUNET_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 | */ |
438 | int | 434 | int |
439 | GNUNET_SECRETSHARING_encrypt (const struct GNUNET_SECRETSHARING_PublicKey *public_key, | 435 | GNUNET_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 | */ |
494 | void | 491 | void |
495 | GNUNET_SECRETSHARING_decrypt_cancel (struct GNUNET_SECRETSHARING_DecryptionHandle *dh) | 492 | GNUNET_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 */ |