GNUnet 0.26.2-106-g126384b46
 
Loading...
Searching...
No Matches
messenger_api_message.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2020--2026 GNUnet e.V.
4
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
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/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
26#include "messenger_api_message.h"
27
28#include "gnunet_common.h"
29#include "gnunet_messenger_service.h"
30#include "gnunet_pils_service.h"
31#include "gnunet_signatures.h"
32#include "gnunet_util_lib.h"
33
34const uint16_t encryption_overhead =
35 GNUNET_CRYPTO_HPKE_SEAL_ONESHOT_OVERHEAD_BYTES;
36
42
48
49struct GNUNET_MESSENGER_Message*
50create_message (enum GNUNET_MESSENGER_MessageKind kind)
51{
52 struct GNUNET_MESSENGER_Message *message;
53
54 message = GNUNET_new (struct GNUNET_MESSENGER_Message);
55 message->header.kind = kind;
56
57 switch (message->header.kind)
58 {
59 case GNUNET_MESSENGER_KIND_NAME:
60 message->body.name.name = NULL;
61 break;
62 case GNUNET_MESSENGER_KIND_TEXT:
63 message->body.text.text = NULL;
64 break;
65 case GNUNET_MESSENGER_KIND_FILE:
66 message->body.file.uri = NULL;
67 break;
68 case GNUNET_MESSENGER_KIND_PRIVATE:
69 message->body.privacy.length = 0;
70 message->body.privacy.data = NULL;
71 break;
72 case GNUNET_MESSENGER_KIND_TICKET:
73 message->body.ticket.identifier = NULL;
74 break;
75 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
76 message->body.transcript.length = 0;
77 message->body.transcript.data = NULL;
78 break;
79 case GNUNET_MESSENGER_KIND_TAG:
80 message->body.tag.tag = NULL;
81 break;
82 case GNUNET_MESSENGER_KIND_TALK:
83 message->body.talk.length = 0;
84 message->body.talk.data = NULL;
85 break;
86 case GNUNET_MESSENGER_KIND_SECRET:
87 message->body.secret.length = 0;
88 message->body.secret.data = NULL;
89 break;
90 default:
91 break;
92 }
93
94 return message;
95}
96
97
98struct GNUNET_MESSENGER_Message*
99copy_message (const struct GNUNET_MESSENGER_Message *message)
100{
101 struct GNUNET_MESSENGER_Message *copy;
102
103 GNUNET_assert (message);
104
105 copy = GNUNET_new (struct GNUNET_MESSENGER_Message);
106 GNUNET_memcpy (copy, message, sizeof(struct GNUNET_MESSENGER_Message));
107
108 switch (message->header.kind)
109 {
110 case GNUNET_MESSENGER_KIND_NAME:
111 copy->body.name.name = message->body.name.name? GNUNET_strdup (
112 message->body.name.name) : NULL;
113 break;
114 case GNUNET_MESSENGER_KIND_TEXT:
115 copy->body.text.text = message->body.text.text? GNUNET_strdup (
116 message->body.text.text) : NULL;
117 break;
118 case GNUNET_MESSENGER_KIND_FILE:
119 copy->body.file.uri = message->body.file.uri? GNUNET_strdup (
120 message->body.file.uri) : NULL;
121 break;
122 case GNUNET_MESSENGER_KIND_PRIVATE:
123 copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc (
124 copy->body.privacy.length) : NULL;
125
126 if (copy->body.privacy.data)
127 GNUNET_memcpy (copy->body.privacy.data, message->body.privacy.data,
128 copy->body.privacy.length);
129
130 break;
131 case GNUNET_MESSENGER_KIND_TICKET:
132 copy->body.ticket.identifier = message->body.ticket.identifier?
133 GNUNET_strdup (
134 message->body.ticket.identifier) : NULL;
135 break;
136 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
137 copy->body.transcript.data = copy->body.transcript.length ? GNUNET_malloc (
138 copy->body.transcript.length) : NULL;
139
140 if (copy->body.transcript.data)
141 GNUNET_memcpy (copy->body.transcript.data, message->body.transcript.data,
142 copy->body.transcript.length);
143
144 break;
145 case GNUNET_MESSENGER_KIND_TAG:
146 copy->body.tag.tag = message->body.tag.tag? GNUNET_strdup (
147 message->body.tag.tag) : NULL;
148 break;
149 case GNUNET_MESSENGER_KIND_TALK:
150 copy->body.talk.data = copy->body.talk.length ? GNUNET_malloc (
151 copy->body.talk.length) : NULL;
152
153 if (copy->body.talk.data)
154 GNUNET_memcpy (copy->body.talk.data, message->body.talk.data,
155 copy->body.talk.length);
156
157 break;
158 case GNUNET_MESSENGER_KIND_SECRET:
159 copy->body.secret.data = copy->body.secret.length ? GNUNET_malloc (
160 copy->body.secret.length) : NULL;
161
162 if (copy->body.secret.data)
163 GNUNET_memcpy (copy->body.secret.data, message->body.secret.data,
164 copy->body.secret.length);
165
166 break;
167 default:
168 break;
169 }
170
171 return copy;
172}
173
174
175void
176copy_message_header (struct GNUNET_MESSENGER_Message *message,
177 const struct GNUNET_MESSENGER_MessageHeader *header)
178{
179 enum GNUNET_MESSENGER_MessageKind kind;
180
181 GNUNET_assert ((message) && (header));
182
183 kind = message->header.kind;
184
185 GNUNET_memcpy (&(message->header), header,
186 sizeof(struct GNUNET_MESSENGER_MessageHeader));
187
188 message->header.kind = kind;
189}
190
191
192static void
193destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind,
194 struct GNUNET_MESSENGER_MessageBody *body)
195{
196 GNUNET_assert (body);
197
198 switch (kind)
199 {
200 case GNUNET_MESSENGER_KIND_NAME:
201 if (body->name.name)
202 GNUNET_free (body->name.name);
203 break;
204 case GNUNET_MESSENGER_KIND_TEXT:
205 if (body->text.text)
206 GNUNET_free (body->text.text);
207 break;
208 case GNUNET_MESSENGER_KIND_FILE:
209 if (body->file.uri)
210 GNUNET_free (body->file.uri);
211 break;
212 case GNUNET_MESSENGER_KIND_PRIVATE:
213 if (body->privacy.data)
214 GNUNET_free (body->privacy.data);
215 break;
216 case GNUNET_MESSENGER_KIND_TICKET:
217 if (body->ticket.identifier)
218 GNUNET_free (body->ticket.identifier);
219 break;
220 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
221 if (body->transcript.data)
222 GNUNET_free (body->transcript.data);
223 break;
224 case GNUNET_MESSENGER_KIND_TAG:
225 if (body->tag.tag)
226 GNUNET_free (body->tag.tag);
227 break;
228 case GNUNET_MESSENGER_KIND_TALK:
229 if (body->talk.data)
230 GNUNET_free (body->talk.data);
231 break;
232 case GNUNET_MESSENGER_KIND_SECRET:
233 if (body->secret.data)
234 GNUNET_free (body->secret.data);
235 break;
236 default:
237 break;
238 }
239}
240
241
242void
243cleanup_message (struct GNUNET_MESSENGER_Message *message)
244{
245 GNUNET_assert (message);
246
247 destroy_message_body (message->header.kind, &(message->body));
248}
249
250
251void
252destroy_message (struct GNUNET_MESSENGER_Message *message)
253{
254 GNUNET_assert (message);
255
256 destroy_message_body (message->header.kind, &(message->body));
257
258 GNUNET_free (message);
259}
260
261
262enum GNUNET_GenericReturnValue
263is_message_session_bound (const struct GNUNET_MESSENGER_Message *message)
264{
265 GNUNET_assert (message);
266
267 if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) ||
268 (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) ||
269 (GNUNET_MESSENGER_KIND_NAME == message->header.kind) ||
270 (GNUNET_MESSENGER_KIND_KEY == message->header.kind) ||
271 (GNUNET_MESSENGER_KIND_ID == message->header.kind))
272 return GNUNET_YES;
273 else
274 return GNUNET_NO;
275}
276
277
278static void
279fold_short_message (const struct GNUNET_MESSENGER_Message *message,
280 struct GNUNET_MESSENGER_ShortMessage *shortened)
281{
282 shortened->kind = message->header.kind;
283
284 GNUNET_memcpy (&(shortened->body), &(message->body), sizeof(struct
285 GNUNET_MESSENGER_MessageBody));
286}
287
288
289static void
290unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened,
291 struct GNUNET_MESSENGER_Message *message)
292{
293 destroy_message_body (message->header.kind, &(message->body));
294
295 message->header.kind = shortened->kind;
296
297 GNUNET_memcpy (&(message->body), &(shortened->body),
298 sizeof(struct GNUNET_MESSENGER_MessageBody));
299}
300
301
302#define member_size(type, member) sizeof(((type*) NULL)->member)
303
304static uint16_t
305get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind)
306{
307 uint16_t length;
308
309 length = 0;
310
311 switch (kind)
312 {
313 case GNUNET_MESSENGER_KIND_INFO:
314 length += member_size (struct GNUNET_MESSENGER_Message,
315 body.info.messenger_version);
316 break;
317 case GNUNET_MESSENGER_KIND_JOIN:
318 length += member_size (struct GNUNET_MESSENGER_Message,
319 body.join.epoch);
320 break;
321 case GNUNET_MESSENGER_KIND_LEAVE:
322 length += member_size (struct GNUNET_MESSENGER_Message,
323 body.leave.epoch);
324 break;
325 case GNUNET_MESSENGER_KIND_PEER:
326 length += member_size (struct GNUNET_MESSENGER_Message, body.peer.peer);
327 break;
328 case GNUNET_MESSENGER_KIND_ID:
329 length += member_size (struct GNUNET_MESSENGER_Message, body.id.id);
330 break;
331 case GNUNET_MESSENGER_KIND_MISS:
332 length += member_size (struct GNUNET_MESSENGER_Message, body.miss.peer);
333 break;
334 case GNUNET_MESSENGER_KIND_MERGE:
335 length += member_size (struct GNUNET_MESSENGER_Message,
336 body.merge.epochs[0]);
337 length += member_size (struct GNUNET_MESSENGER_Message,
338 body.merge.epochs[1]);
339 length += member_size (struct GNUNET_MESSENGER_Message,
340 body.merge.previous);
341 break;
342 case GNUNET_MESSENGER_KIND_REQUEST:
343 length += member_size (struct GNUNET_MESSENGER_Message, body.request.hash);
344 break;
345 case GNUNET_MESSENGER_KIND_INVITE:
346 length += member_size (struct GNUNET_MESSENGER_Message, body.invite.door);
347 length += member_size (struct GNUNET_MESSENGER_Message, body.invite.key);
348 break;
349 case GNUNET_MESSENGER_KIND_FILE:
350 length += member_size (struct GNUNET_MESSENGER_Message, body.file.key);
351 length += member_size (struct GNUNET_MESSENGER_Message, body.file.hash);
352 length += member_size (struct GNUNET_MESSENGER_Message, body.file.name);
353 break;
354 case GNUNET_MESSENGER_KIND_DELETION:
355 length += member_size (struct GNUNET_MESSENGER_Message, body.deletion.hash);
356 length += member_size (struct GNUNET_MESSENGER_Message,
357 body.deletion.delay);
358 break;
359 case GNUNET_MESSENGER_KIND_CONNECTION:
360 length += member_size (struct GNUNET_MESSENGER_Message,
361 body.connection.amount);
362 length += member_size (struct GNUNET_MESSENGER_Message,
363 body.connection.flags);
364 break;
365 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
366 length += member_size (struct GNUNET_MESSENGER_Message,
367 body.transcript.hash);
368 break;
369 case GNUNET_MESSENGER_KIND_TAG:
370 length += member_size (struct GNUNET_MESSENGER_Message, body.tag.hash);
371 break;
372 case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
373 length += member_size (struct GNUNET_MESSENGER_Message,
374 body.subscription.discourse);
375 length += member_size (struct GNUNET_MESSENGER_Message,
376 body.subscription.time);
377 length += member_size (struct GNUNET_MESSENGER_Message,
378 body.subscription.flags);
379 break;
380 case GNUNET_MESSENGER_KIND_TALK:
381 length += member_size (struct GNUNET_MESSENGER_Message,
382 body.talk.discourse);
383 break;
384 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
385 length += member_size (struct GNUNET_MESSENGER_Message,
386 body.announcement.identifier);
387 length += member_size (struct GNUNET_MESSENGER_Message,
388 body.announcement.key);
389 length += member_size (struct GNUNET_MESSENGER_Message,
390 body.announcement.nonce);
391 length += member_size (struct GNUNET_MESSENGER_Message,
392 body.announcement.timeout);
393 length += member_size (struct GNUNET_MESSENGER_Message,
394 body.announcement.hmac);
395 break;
396 case GNUNET_MESSENGER_KIND_SECRET:
397 length += member_size (struct GNUNET_MESSENGER_Message,
398 body.secret.identifier);
399 length += member_size (struct GNUNET_MESSENGER_Message,
400 body.secret.iv);
401 length += member_size (struct GNUNET_MESSENGER_Message,
402 body.secret.hmac);
403 break;
404 case GNUNET_MESSENGER_KIND_APPEAL:
405 length += member_size (struct GNUNET_MESSENGER_Message,
406 body.appeal.event);
407 length += member_size (struct GNUNET_MESSENGER_Message,
408 body.appeal.key);
409 length += member_size (struct GNUNET_MESSENGER_Message,
410 body.appeal.timeout);
411 break;
412 case GNUNET_MESSENGER_KIND_ACCESS:
413 length += member_size (struct GNUNET_MESSENGER_Message,
414 body.access.event);
415 length += member_size (struct GNUNET_MESSENGER_Message,
416 body.access.key);
417 length += member_size (struct GNUNET_MESSENGER_Message,
418 body.access.hmac);
419 break;
420 case GNUNET_MESSENGER_KIND_REVOLUTION:
421 length += member_size (struct GNUNET_MESSENGER_Message,
422 body.revolution.identifier);
423 length += member_size (struct GNUNET_MESSENGER_Message,
424 body.revolution.nonce);
425 length += member_size (struct GNUNET_MESSENGER_Message,
426 body.revolution.hmac);
427 break;
428 case GNUNET_MESSENGER_KIND_GROUP:
429 length += member_size (struct GNUNET_MESSENGER_Message,
430 body.group.identifier);
431 length += member_size (struct GNUNET_MESSENGER_Message,
432 body.group.initiator);
433 length += member_size (struct GNUNET_MESSENGER_Message,
434 body.group.partner);
435 length += member_size (struct GNUNET_MESSENGER_Message,
436 body.group.timeout);
437 break;
438 case GNUNET_MESSENGER_KIND_AUTHORIZATION:
439 length += member_size (struct GNUNET_MESSENGER_Message,
440 body.authorization.identifier);
441 length += member_size (struct GNUNET_MESSENGER_Message,
442 body.authorization.event);
443 length += member_size (struct GNUNET_MESSENGER_Message,
444 body.authorization.key);
445 length += member_size (struct GNUNET_MESSENGER_Message,
446 body.authorization.hmac);
447 break;
448 default:
449 break;
450 }
451
452 return length;
453}
454
455
456typedef uint32_t kind_t;
457
458uint16_t
459get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind,
460 enum GNUNET_GenericReturnValue include_header)
461{
462 uint16_t length;
463
464 length = 0;
465
466 if (GNUNET_YES == include_header)
467 {
468 length += member_size (struct GNUNET_MESSENGER_Message, header.timestamp);
469 length += member_size (struct GNUNET_MESSENGER_Message, header.sender_id);
470 length += member_size (struct GNUNET_MESSENGER_Message, header.previous);
471 }
472
473 length += sizeof(kind_t);
474
475 return length + get_message_body_kind_size (kind);
476}
477
478
479static uint16_t
480get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind,
481 const struct GNUNET_MESSENGER_MessageBody *body)
482{
483 uint16_t length;
484
485 length = 0;
486
487 switch (kind)
488 {
489 case GNUNET_MESSENGER_KIND_JOIN:
490 length += GNUNET_CRYPTO_blindable_pk_get_length (&(body->join.key));
491 length += GNUNET_CRYPTO_hpke_pk_get_length (&(body->join.hpke_key));
492 break;
493 case GNUNET_MESSENGER_KIND_NAME:
494 length += (body->name.name ? strlen (body->name.name) : 0);
495 break;
496 case GNUNET_MESSENGER_KIND_KEY:
497 length += GNUNET_CRYPTO_blindable_pk_get_length (&(body->key.key));
498 length += GNUNET_CRYPTO_hpke_pk_get_length (&(body->key.hpke_key));
499 break;
500 case GNUNET_MESSENGER_KIND_TEXT:
501 length += (body->text.text ? strlen (body->text.text) : 0);
502 break;
503 case GNUNET_MESSENGER_KIND_FILE:
504 length += (body->file.uri ? strlen (body->file.uri) : 0);
505 break;
506 case GNUNET_MESSENGER_KIND_PRIVATE:
507 length += body->privacy.length;
508 break;
509 case GNUNET_MESSENGER_KIND_TICKET:
510 length += (body->ticket.identifier ? strlen (body->ticket.identifier) : 0);
511 break;
512 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
513 length += GNUNET_CRYPTO_blindable_pk_get_length (&(body->transcript.key));
514 length += body->transcript.length;
515 break;
516 case GNUNET_MESSENGER_KIND_TAG:
517 length += (body->tag.tag ? strlen (body->tag.tag) : 0);
518 break;
519 case GNUNET_MESSENGER_KIND_TALK:
520 length += body->talk.length;
521 break;
522 case GNUNET_MESSENGER_KIND_SECRET:
523 length += body->secret.length;
524 break;
525 default:
526 break;
527 }
528
529 return length;
530}
531
532
533uint16_t
534get_message_size (const struct GNUNET_MESSENGER_Message *message,
535 enum GNUNET_GenericReturnValue include_header)
536{
537 uint16_t length;
538
539 GNUNET_assert (message);
540
541 length = 0;
542
543 if (GNUNET_YES == include_header)
544 length += GNUNET_CRYPTO_blinded_key_signature_get_length (
545 &(message->header.signature));
546
547 length += get_message_kind_size (message->header.kind, include_header);
548 length += get_message_body_size (message->header.kind, &(message->body));
549
550 return length;
551}
552
553
554static uint16_t
555get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message,
556 enum GNUNET_GenericReturnValue include_body)
557{
558 uint16_t minimum_size;
559
560 minimum_size = sizeof(struct GNUNET_HashCode) + sizeof(kind_t);
561
562 if (message)
563 return minimum_size + get_message_body_kind_size (message->kind)
564 + (include_body == GNUNET_YES?
565 get_message_body_size (message->kind, &(message->body)) : 0);
566 else
567 return minimum_size;
568}
569
570
571static uint16_t
572calc_usual_padding ()
573{
574 uint16_t padding;
575 uint16_t kind_size;
576
577 padding = 0;
578
579 for (unsigned int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++)
580 {
581 kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i,
582 GNUNET_YES);
583
584 if (kind_size > padding)
585 padding = kind_size;
586 }
587
588 return padding + GNUNET_MESSENGER_PADDING_MIN;
589}
590
591
592#define max(x, y) (x > y? x : y)
593
594static uint16_t
595calc_padded_length (uint16_t length)
596{
597 static uint16_t usual_padding = 0;
598 uint16_t padded_length;
599
600 if (! usual_padding)
601 usual_padding = calc_usual_padding ();
602
603 padded_length = max (
604 length + GNUNET_MESSENGER_PADDING_MIN,
605 usual_padding);
606
607 if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL0)
608 return GNUNET_MESSENGER_PADDING_LEVEL0;
609
610 if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL1)
611 return GNUNET_MESSENGER_PADDING_LEVEL1;
612
613 if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL2)
614 return GNUNET_MESSENGER_PADDING_LEVEL2;
615
616 return GNUNET_MESSENGER_MAX_MESSAGE_SIZE;
617
618}
619
620
621#define min(x, y) (x < y? x : y)
622
623#define encode_step_ext(dst, offset, src, size) do { \
624 GNUNET_memcpy (dst + offset, src, size); \
625 offset += size; \
626} while (0)
627
628#define encode_step(dst, offset, src) do { \
629 encode_step_ext (dst, offset, src, sizeof(*src)); \
630} while (0)
631
632#define encode_step_key(dst, offset, src, length) do { \
633 ssize_t result = GNUNET_CRYPTO_write_blindable_pk_to_buffer ( \
634 src, dst + offset, length - offset); \
635 if (result < 0) \
636 GNUNET_break (0); \
637 else \
638 offset += result; \
639} while (0)
640
641#define encode_step_hpke_key(dst, offset, src, length) do { \
642 ssize_t result = GNUNET_CRYPTO_write_hpke_pk_to_buffer ( \
643 src, dst + offset, length - offset); \
644 if (result < 0) \
645 GNUNET_break (0); \
646 else \
647 offset += result; \
648} while (0)
649
650#define encode_step_signature(dst, offset, src, length) do { \
651 ssize_t result = GNUNET_CRYPTO_write_blinded_key_signature_to_buffer ( \
652 src, dst + offset, length - offset); \
653 if (result < 0) \
654 GNUNET_break (0); \
655 else \
656 offset += result; \
657} while (0)
658
659static void
660encode_message_body (enum GNUNET_MESSENGER_MessageKind kind,
661 const struct GNUNET_MESSENGER_MessageBody *body,
662 uint16_t length,
663 char *buffer,
664 uint16_t offset)
665{
666 uint32_t value0, value1;
667
668 GNUNET_assert ((body) && (buffer));
669
670 switch (kind)
671 {
672 case GNUNET_MESSENGER_KIND_INFO:
673 value0 = GNUNET_htobe32 (body->info.messenger_version);
674
675 encode_step (buffer, offset, &value0);
676 break;
677 case GNUNET_MESSENGER_KIND_JOIN:
678 encode_step (buffer, offset, &(body->join.epoch));
679 encode_step_key (buffer, offset, &(body->join.key), length);
680 encode_step_hpke_key (buffer, offset, &(body->join.hpke_key), length);
681 break;
682 case GNUNET_MESSENGER_KIND_LEAVE:
683 encode_step (buffer, offset, &(body->leave.epoch));
684 break;
685 case GNUNET_MESSENGER_KIND_NAME:
686 if (body->name.name)
687 encode_step_ext (
688 buffer,
689 offset,
690 body->name.name,
691 min (length - offset, strlen (body->name.name)));
692 break;
693 case GNUNET_MESSENGER_KIND_KEY:
694 encode_step_key (buffer, offset, &(body->key.key), length);
695 encode_step_hpke_key (buffer, offset, &(body->key.hpke_key), length);
696 break;
697 case GNUNET_MESSENGER_KIND_PEER:
698 encode_step (buffer, offset, &(body->peer.peer));
699 break;
700 case GNUNET_MESSENGER_KIND_ID:
701 encode_step (buffer, offset, &(body->id.id));
702 break;
703 case GNUNET_MESSENGER_KIND_MISS:
704 encode_step (buffer, offset, &(body->miss.peer));
705 break;
706 case GNUNET_MESSENGER_KIND_MERGE:
707 encode_step (buffer, offset, &(body->merge.epochs[0]));
708 encode_step (buffer, offset, &(body->merge.epochs[1]));
709 encode_step (buffer, offset, &(body->merge.previous));
710 break;
711 case GNUNET_MESSENGER_KIND_REQUEST:
712 encode_step (buffer, offset, &(body->request.hash));
713 break;
714 case GNUNET_MESSENGER_KIND_INVITE:
715 encode_step (buffer, offset, &(body->invite.door));
716 encode_step (buffer, offset, &(body->invite.key));
717 break;
718 case GNUNET_MESSENGER_KIND_TEXT:
719 if (body->text.text)
720 encode_step_ext (
721 buffer,
722 offset,
723 body->text.text,
724 min (length - offset, strlen (body->text.text)));
725 break;
726 case GNUNET_MESSENGER_KIND_FILE:
727 encode_step (buffer, offset, &(body->file.key));
728 encode_step (buffer, offset, &(body->file.hash));
729 encode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name));
730 if (body->file.uri)
731 encode_step_ext (buffer, offset, body->file.uri, min (length - offset,
732 strlen (
733 body->file.uri)));
734 break;
735 case GNUNET_MESSENGER_KIND_PRIVATE:
736 if (body->privacy.data)
737 encode_step_ext (buffer, offset, body->privacy.data, min (length - offset,
738 body->privacy.
739 length));
740 break;
741 case GNUNET_MESSENGER_KIND_DELETION:
742 encode_step (buffer, offset, &(body->deletion.hash));
743 encode_step (buffer, offset, &(body->deletion.delay));
744 break;
745 case GNUNET_MESSENGER_KIND_CONNECTION:
746 value0 = GNUNET_htobe32 (body->connection.amount);
747 value1 = GNUNET_htobe32 (body->connection.flags);
748
749 encode_step (buffer, offset, &value0);
750 encode_step (buffer, offset, &value1);
751 break;
752 case GNUNET_MESSENGER_KIND_TICKET:
753 encode_step_ext (buffer, offset, body->ticket.identifier,
754 min (length - offset, strlen (body->ticket.identifier)));
755 break;
756 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
757 encode_step (buffer, offset, &(body->transcript.hash));
758 encode_step_key (buffer, offset, &(body->transcript.key), length);
759
760 if (body->transcript.data)
761 encode_step_ext (buffer, offset, body->transcript.data, min (length
762 - offset,
763 body->
764 transcript.
765 length));
766 break;
767 case GNUNET_MESSENGER_KIND_TAG:
768 encode_step (buffer, offset, &(body->tag.hash));
769
770 if (body->tag.tag)
771 encode_step_ext (buffer, offset, body->tag.tag, min (length - offset,
772 strlen (
773 body->tag.tag)));
774 break;
775 case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
776 value0 = GNUNET_htobe32 (body->subscription.flags);
777
778 encode_step (buffer, offset, &(body->subscription.discourse));
779 encode_step (buffer, offset, &(body->subscription.time));
780 encode_step (buffer, offset, &value0);
781 break;
782 case GNUNET_MESSENGER_KIND_TALK:
783 encode_step (buffer, offset, &(body->talk.discourse));
784
785 if (body->talk.data)
786 encode_step_ext (buffer, offset, body->talk.data, min (length - offset,
787 body->talk.
788 length));
789 break;
790 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
791 encode_step (buffer, offset, &(body->announcement.identifier));
792 encode_step (buffer, offset, &(body->announcement.key));
793 encode_step (buffer, offset, &(body->announcement.nonce));
794 encode_step (buffer, offset, &(body->announcement.timeout));
795 encode_step (buffer, offset, &(body->announcement.hmac));
796 break;
797 case GNUNET_MESSENGER_KIND_SECRET:
798 encode_step (buffer, offset, &(body->secret.identifier));
799 encode_step (buffer, offset, &(body->secret.iv));
800 encode_step (buffer, offset, &(body->secret.hmac));
801
802 if (body->secret.data)
803 encode_step_ext (buffer, offset, body->secret.data, min (length - offset,
804 body->secret.
805 length));
806 break;
807 case GNUNET_MESSENGER_KIND_APPEAL:
808 encode_step (buffer, offset, &(body->appeal.event));
809 encode_step (buffer, offset, &(body->appeal.key));
810 encode_step (buffer, offset, &(body->appeal.timeout));
811 break;
812 case GNUNET_MESSENGER_KIND_ACCESS:
813 encode_step (buffer, offset, &(body->access.event));
814 encode_step (buffer, offset, &(body->access.key));
815 encode_step (buffer, offset, &(body->access.hmac));
816 break;
817 case GNUNET_MESSENGER_KIND_REVOLUTION:
818 encode_step (buffer, offset, &(body->revolution.identifier));
819 encode_step (buffer, offset, &(body->revolution.nonce));
820 encode_step (buffer, offset, &(body->revolution.hmac));
821 break;
822 case GNUNET_MESSENGER_KIND_GROUP:
823 encode_step (buffer, offset, &(body->group.identifier));
824 encode_step (buffer, offset, &(body->group.initiator));
825 encode_step (buffer, offset, &(body->group.partner));
826 encode_step (buffer, offset, &(body->group.timeout));
827 break;
828 case GNUNET_MESSENGER_KIND_AUTHORIZATION:
829 encode_step (buffer, offset, &(body->authorization.identifier));
830 encode_step (buffer, offset, &(body->authorization.event));
831 encode_step (buffer, offset, &(body->authorization.key));
832 encode_step (buffer, offset, &(body->authorization.hmac));
833 break;
834 default:
835 break;
836 }
837
838 if (offset >= length)
839 return;
840
841 {
842 uint16_t padding;
843 uint16_t used_padding;
844
845 padding = length - offset;
846 used_padding = sizeof(padding) + sizeof(char);
847
848 GNUNET_assert (padding >= used_padding);
849
850 buffer[offset++] = '\0';
851
852 if (padding > used_padding)
853 GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset,
854 padding - used_padding);
855
856 GNUNET_memcpy (buffer + length - sizeof(padding), &padding,
857 sizeof(padding));
858 }
859}
860
861
862void
863encode_message_signature (const struct GNUNET_MESSENGER_Message *message,
864 uint16_t length,
865 char *buffer)
866{
867 uint16_t offset = 0;
868
869 GNUNET_assert ((message) && (buffer));
870
871 encode_step_signature (buffer, offset, &(message->header.signature),
872 length);
873}
874
875
876void
877encode_message (const struct GNUNET_MESSENGER_Message *message,
878 uint16_t length,
879 char *buffer,
880 enum GNUNET_GenericReturnValue include_header)
881{
882 uint16_t offset;
883 kind_t kind;
884
885 GNUNET_assert ((message) && (buffer));
886
887 offset = 0;
888
889 if (GNUNET_YES == include_header)
890 encode_step_signature (buffer, offset, &(message->header.signature),
891 length);
892
893 kind = GNUNET_htobe32 ((kind_t) message->header.kind);
894
895 if (GNUNET_YES == include_header)
896 {
897 encode_step (buffer, offset, &(message->header.timestamp));
898 encode_step (buffer, offset, &(message->header.sender_id));
899 encode_step (buffer, offset, &(message->header.previous));
900 }
901
902 encode_step (buffer, offset, &kind);
903
904 encode_message_body (message->header.kind, &(message->body),
905 length, buffer, offset);
906}
907
908
909static void
910encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message,
911 uint16_t length,
912 char *buffer)
913{
914 struct GNUNET_HashCode hash;
915 uint16_t offset;
916 kind_t kind;
917
918 GNUNET_assert ((message) && (buffer));
919
920 offset = sizeof(hash);
921 kind = GNUNET_htobe32 ((kind_t) message->kind);
922
923 encode_step (buffer, offset, &kind);
924
925 encode_message_body (message->kind, &(message->body), length, buffer, offset);
926
927 GNUNET_CRYPTO_hash (
928 buffer + sizeof(hash),
929 length - sizeof(hash),
930 &hash);
931
932 GNUNET_memcpy (buffer, &hash, sizeof(hash));
933}
934
935
936#define decode_step_ext(src, offset, dst, size) do { \
937 GNUNET_memcpy (dst, src + offset, size); \
938 offset += size; \
939} while (0)
940
941#define decode_step(src, offset, dst) do { \
942 decode_step_ext (src, offset, dst, sizeof(*dst)); \
943} while (0)
944
945#define decode_step_malloc(src, offset, dst, size, zero) do { \
946 dst = GNUNET_malloc (size + zero); \
947 if (zero) dst[size] = 0; \
948 decode_step_ext (src, offset, dst, size); \
949} while (0)
950
951#define decode_step_key(src, offset, dst, length) do { \
952 enum GNUNET_GenericReturnValue result; \
953 size_t read; \
954 result = GNUNET_CRYPTO_read_blindable_pk_from_buffer ( \
955 src + offset, length - offset, dst, &read); \
956 if (GNUNET_SYSERR == result) \
957 GNUNET_break (0); \
958 else \
959 offset += read; \
960} while (0)
961
962#define decode_step_hpke_key(src, offset, dst, length) do { \
963 enum GNUNET_GenericReturnValue result; \
964 size_t read; \
965 result = GNUNET_CRYPTO_read_hpke_pk_from_buffer ( \
966 src + offset, length - offset, dst, &read); \
967 if (GNUNET_SYSERR == result) \
968 GNUNET_break (0); \
969 else \
970 offset += read; \
971} while (0)
972
973static uint16_t
974decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind,
975 struct GNUNET_MESSENGER_MessageBody *body,
976 uint16_t length,
977 const char *buffer,
978 uint16_t offset)
979{
980 uint16_t padding;
981 uint32_t value0, value1;
982
983 GNUNET_assert ((kind) && (body) && (buffer));
984
985 padding = 0;
986
987 GNUNET_memcpy (&padding, buffer + length - sizeof(padding), sizeof(padding));
988
989 if (padding > length - offset)
990 padding = 0;
991
992 {
993 uint16_t end_zero;
994 end_zero = length - padding;
995
996 if ((padding) && (buffer[end_zero] != '\0'))
997 padding = 0;
998 }
999
1000 length -= padding;
1001
1002 switch (*kind)
1003 {
1004 case GNUNET_MESSENGER_KIND_INFO:
1005 decode_step (buffer, offset, &value0);
1006
1007 body->info.messenger_version = GNUNET_be32toh (value0);
1008 break;
1009 case GNUNET_MESSENGER_KIND_JOIN:
1010 decode_step (buffer, offset, &(body->join.epoch));
1011 decode_step_key (buffer, offset, &(body->join.key), length);
1012 decode_step_hpke_key (buffer, offset, &(body->join.hpke_key), length);
1013 break;
1014 case GNUNET_MESSENGER_KIND_LEAVE:
1015 decode_step (buffer, offset, &(body->leave.epoch));
1016 break;
1017 case GNUNET_MESSENGER_KIND_NAME:
1018 if (length > offset)
1019 decode_step_malloc (buffer, offset, body->name.name, length - offset, 1);
1020 else
1021 body->name.name = NULL;
1022 break;
1023 case GNUNET_MESSENGER_KIND_KEY:
1024 decode_step_key (buffer, offset, &(body->key.key), length);
1025 decode_step_hpke_key (buffer, offset, &(body->key.hpke_key), length);
1026 break;
1027 case GNUNET_MESSENGER_KIND_PEER:
1028 decode_step (buffer, offset, &(body->peer.peer));
1029 break;
1030 case GNUNET_MESSENGER_KIND_ID:
1031 decode_step (buffer, offset, &(body->id.id));
1032 break;
1033 case GNUNET_MESSENGER_KIND_MISS:
1034 decode_step (buffer, offset, &(body->miss.peer));
1035 break;
1036 case GNUNET_MESSENGER_KIND_MERGE:
1037 decode_step (buffer, offset, &(body->merge.epochs[0]));
1038 decode_step (buffer, offset, &(body->merge.epochs[1]));
1039 decode_step (buffer, offset, &(body->merge.previous));
1040 break;
1041 case GNUNET_MESSENGER_KIND_REQUEST:
1042 decode_step (buffer, offset, &(body->request.hash));
1043 break;
1044 case GNUNET_MESSENGER_KIND_INVITE:
1045 decode_step (buffer, offset, &(body->invite.door));
1046 decode_step (buffer, offset, &(body->invite.key));
1047 break;
1048 case GNUNET_MESSENGER_KIND_TEXT:
1049 if (length > offset)
1050 decode_step_malloc (buffer, offset, body->text.text, length - offset, 1);
1051 else
1052 body->text.text = NULL;
1053 break;
1054 case GNUNET_MESSENGER_KIND_FILE:
1055 decode_step (buffer, offset, &(body->file.key));
1056 decode_step (buffer, offset, &(body->file.hash));
1057 decode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name));
1058 if (length > offset)
1059 decode_step_malloc (buffer, offset, body->file.uri, length - offset, 1);
1060 else
1061 body->file.uri = NULL;
1062 break;
1063 case GNUNET_MESSENGER_KIND_PRIVATE:
1064 if (length > offset)
1065 {
1066 body->privacy.length = (length - offset);
1067 decode_step_malloc (buffer, offset, body->privacy.data, length - offset,
1068 0);
1069 }
1070 else
1071 {
1072 body->privacy.length = 0;
1073 body->privacy.data = NULL;
1074 }
1075
1076 break;
1077 case GNUNET_MESSENGER_KIND_DELETION:
1078 decode_step (buffer, offset, &(body->deletion.hash));
1079 decode_step (buffer, offset, &(body->deletion.delay));
1080 break;
1081 case GNUNET_MESSENGER_KIND_CONNECTION:
1082 decode_step (buffer, offset, &value0);
1083 decode_step (buffer, offset, &value1);
1084
1085 body->connection.amount = GNUNET_be32toh (value0);
1086 body->connection.flags = GNUNET_be32toh (value1);
1087 break;
1088 case GNUNET_MESSENGER_KIND_TICKET:
1089 if (length > offset)
1090 decode_step_malloc (buffer, offset, body->ticket.identifier, length
1091 - offset, 1);
1092 else
1093 body->ticket.identifier = NULL;
1094 break;
1095 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
1096 decode_step (buffer, offset, &(body->transcript.hash));
1097 decode_step_key (buffer, offset, &(body->transcript.key), length);
1098
1099 if (length > offset)
1100 {
1101 body->transcript.length = (length - offset);
1102 decode_step_malloc (buffer, offset, body->transcript.data,
1103 length - offset, 0);
1104 }
1105 else
1106 {
1107 body->transcript.length = 0;
1108 body->transcript.data = NULL;
1109 }
1110
1111 break;
1112 case GNUNET_MESSENGER_KIND_TAG:
1113 decode_step (buffer, offset, &(body->tag.hash));
1114 if (length > offset)
1115 decode_step_malloc (buffer, offset, body->tag.tag, length - offset, 1);
1116 else
1117 body->tag.tag = NULL;
1118 break;
1119 case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
1120 decode_step (buffer, offset, &(body->subscription.discourse));
1121 decode_step (buffer, offset, &(body->subscription.time));
1122 decode_step (buffer, offset, &value0);
1123
1124 body->subscription.flags = GNUNET_be32toh (value0);
1125 break;
1126 case GNUNET_MESSENGER_KIND_TALK:
1127 decode_step (buffer, offset, &(body->talk.discourse));
1128
1129 if (length > offset)
1130 {
1131 body->talk.length = (length - offset);
1132 decode_step_malloc (buffer, offset, body->talk.data, length - offset,
1133 0);
1134 }
1135 else
1136 {
1137 body->talk.length = 0;
1138 body->talk.data = NULL;
1139 }
1140
1141 break;
1142 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
1143 decode_step (buffer, offset, &(body->announcement.identifier));
1144 decode_step (buffer, offset, &(body->announcement.key));
1145 decode_step (buffer, offset, &(body->announcement.nonce));
1146 decode_step (buffer, offset, &(body->announcement.timeout));
1147 decode_step (buffer, offset, &(body->announcement.hmac));
1148 break;
1149 case GNUNET_MESSENGER_KIND_SECRET:
1150 decode_step (buffer, offset, &(body->secret.identifier));
1151 decode_step (buffer, offset, &(body->secret.iv));
1152 decode_step (buffer, offset, &(body->secret.hmac));
1153
1154 if (length > offset)
1155 {
1156 body->secret.length = (length - offset);
1157 decode_step_malloc (buffer, offset, body->secret.data, length - offset,
1158 0);
1159 }
1160 else
1161 {
1162 body->secret.length = 0;
1163 body->secret.data = NULL;
1164 }
1165
1166 break;
1167 case GNUNET_MESSENGER_KIND_APPEAL:
1168 decode_step (buffer, offset, &(body->appeal.event));
1169 decode_step (buffer, offset, &(body->appeal.key));
1170 decode_step (buffer, offset, &(body->appeal.timeout));
1171 break;
1172 case GNUNET_MESSENGER_KIND_ACCESS:
1173 decode_step (buffer, offset, &(body->access.event));
1174 decode_step (buffer, offset, &(body->access.key));
1175 decode_step (buffer, offset, &(body->access.hmac));
1176 break;
1177 case GNUNET_MESSENGER_KIND_REVOLUTION:
1178 decode_step (buffer, offset, &(body->revolution.identifier));
1179 decode_step (buffer, offset, &(body->revolution.nonce));
1180 decode_step (buffer, offset, &(body->revolution.hmac));
1181 break;
1182 case GNUNET_MESSENGER_KIND_GROUP:
1183 decode_step (buffer, offset, &(body->group.identifier));
1184 decode_step (buffer, offset, &(body->group.initiator));
1185 decode_step (buffer, offset, &(body->group.partner));
1186 decode_step (buffer, offset, &(body->group.timeout));
1187 break;
1188 case GNUNET_MESSENGER_KIND_AUTHORIZATION:
1189 decode_step (buffer, offset, &(body->authorization.identifier));
1190 decode_step (buffer, offset, &(body->authorization.event));
1191 decode_step (buffer, offset, &(body->authorization.key));
1192 decode_step (buffer, offset, &(body->authorization.hmac));
1193 break;
1194 default:
1195 *kind = GNUNET_MESSENGER_KIND_UNKNOWN;
1196 break;
1197 }
1198
1199 return padding;
1200}
1201
1202
1203enum GNUNET_GenericReturnValue
1204decode_message (struct GNUNET_MESSENGER_Message *message,
1205 uint16_t length,
1206 const char *buffer,
1207 enum GNUNET_GenericReturnValue include_header,
1208 uint16_t *padding)
1209{
1210 uint16_t offset;
1211 uint16_t count;
1212 kind_t kind;
1213
1214 GNUNET_assert (
1215 (message) &&
1216 (buffer) &&
1217 (length >= get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
1218 include_header)));
1219
1220 offset = 0;
1221
1222 if (GNUNET_YES == include_header)
1223 {
1224 ssize_t result;
1225
1226 result = GNUNET_CRYPTO_read_blinded_key_signature_from_buffer (
1227 &(message->header.signature), buffer, length - offset);
1228
1229 if (result < 0)
1230 return GNUNET_NO;
1231 else
1232 offset += result;
1233 }
1234
1235 count = length - offset;
1236 if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
1237 include_header))
1238 return GNUNET_NO;
1239
1240 if (GNUNET_YES == include_header)
1241 {
1242 decode_step (buffer, offset, &(message->header.timestamp));
1243 decode_step (buffer, offset, &(message->header.sender_id));
1244 decode_step (buffer, offset, &(message->header.previous));
1245 }
1246
1247 decode_step (buffer, offset, &kind);
1248 kind = GNUNET_be32toh (kind);
1249
1250 message->header.kind = (enum GNUNET_MESSENGER_MessageKind) kind;
1251
1252 if (count < get_message_kind_size (message->header.kind, include_header))
1253 return GNUNET_NO;
1254
1255 {
1256 uint16_t result;
1257 result = decode_message_body (&(message->header.kind),
1258 &(message->body), length, buffer, offset);
1259
1260 if (padding)
1261 *padding = result;
1262 }
1263
1264 return GNUNET_YES;
1265}
1266
1267
1268static enum GNUNET_GenericReturnValue
1269decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message,
1270 uint16_t length,
1271 const char *buffer)
1272{
1273 struct GNUNET_HashCode expected, hash;
1274 uint16_t offset;
1275 kind_t kind;
1276
1277 GNUNET_assert ((message) && (buffer));
1278
1279 offset = sizeof(hash);
1280
1281 if (length < get_short_message_size (NULL, GNUNET_NO))
1282 return GNUNET_NO;
1283
1284 GNUNET_memcpy (&hash, buffer, sizeof(hash));
1285
1286 GNUNET_CRYPTO_hash (
1287 buffer + sizeof(hash),
1288 length - sizeof(hash),
1289 &expected);
1290
1291 if (0 != GNUNET_CRYPTO_hash_cmp (&hash, &expected))
1292 return GNUNET_NO;
1293
1294 decode_step (buffer, offset, &kind);
1295 kind = GNUNET_be32toh (kind);
1296
1297 message->kind = (enum GNUNET_MESSENGER_MessageKind) kind;
1298
1299 if (length < get_short_message_size (message, GNUNET_NO))
1300 return GNUNET_NO;
1301
1302 decode_message_body (&(message->kind), &(message->body), length, buffer,
1303 offset);
1304
1305 if (GNUNET_MESSENGER_KIND_UNKNOWN == message->kind)
1306 return GNUNET_NO;
1307
1308 return GNUNET_YES;
1309}
1310
1311
1312void
1313hash_message (const struct GNUNET_MESSENGER_Message *message,
1314 uint16_t length,
1315 const char *buffer,
1316 struct GNUNET_HashCode *hash)
1317{
1318 ssize_t offset;
1319
1320 GNUNET_assert ((message) && (buffer) && (hash));
1321
1322 offset = GNUNET_CRYPTO_blinded_key_signature_get_length (&(message->header.
1323 signature));
1324
1325 GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash);
1326}
1327
1328
1329void
1330sign_message (struct GNUNET_MESSENGER_Message *message,
1331 const struct GNUNET_HashCode *hash,
1332 const struct GNUNET_CRYPTO_BlindablePrivateKey *key)
1333{
1334 struct GNUNET_MESSENGER_MessageSignature signature;
1335
1336 GNUNET_assert ((message) && (hash) && (key));
1337
1338 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by member: %s\n",
1339 GNUNET_h2s (hash));
1340
1341 signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
1342 signature.purpose.size = htonl (sizeof(signature));
1343
1344 GNUNET_memcpy (&(signature.hash), hash, sizeof(signature.hash));
1345
1346 GNUNET_CRYPTO_blinded_key_sign (key, &signature,
1347 &(message->header.signature));
1348 message->header.signature.type = key->type;
1349}
1350
1351
1352struct GNUNET_PILS_Operation*
1353sign_message_by_peer (struct GNUNET_MESSENGER_Message *message,
1354 const struct GNUNET_HashCode *hash,
1355 struct GNUNET_PILS_Handle *pils,
1356 const GNUNET_PILS_SignResultCallback sign_cb,
1357 void *cls)
1358{
1359 struct GNUNET_MESSENGER_MessageSignature signature;
1360 struct GNUNET_PILS_Operation *operation;
1361
1362 GNUNET_assert ((message) && (hash) && (pils));
1363
1364 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by peer: %s\n",
1365 GNUNET_h2s (hash));
1366
1367 signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
1368 signature.purpose.size = htonl (sizeof (signature));
1369
1370 GNUNET_memcpy (&(signature.hash), hash, sizeof (signature.hash));
1371
1372 operation = GNUNET_PILS_sign_by_peer_identity (pils, &(signature.purpose),
1373 sign_cb, cls);
1374
1375 if (! operation)
1376 return NULL;
1377
1378 message->header.signature.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
1379 return operation;
1380}
1381
1382
1383static enum GNUNET_GenericReturnValue
1384calc_message_hmac (const struct GNUNET_MESSENGER_Message *message,
1385 const struct GNUNET_CRYPTO_SymmetricSessionKey *key,
1386 struct GNUNET_HashCode *hmac)
1387{
1388 struct GNUNET_CRYPTO_AuthKey auth_key;
1389
1390 GNUNET_assert ((message) && (key) && (hmac));
1391
1392 switch (message->header.kind)
1393 {
1394 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
1395 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1396 &auth_key, sizeof (auth_key),
1397 GNUNET_MESSENGER_SALT_ANNOUNCEMENT_KEY,
1398 sizeof (GNUNET_MESSENGER_SALT_ANNOUNCEMENT_KEY),
1399 key, sizeof (*key),
1400 GNUNET_CRYPTO_kdf_arg_auto (&message->body.announcement.identifier),
1401 GNUNET_CRYPTO_kdf_arg (&(message->body.announcement.nonce), GNUNET_MESSENGER_EPOCH_NONCE_BYTES)))
1402 return GNUNET_NO;
1403
1404 GNUNET_CRYPTO_hmac (&auth_key, &(message->body.announcement),
1405 sizeof (message->body.announcement)
1406 - sizeof (*hmac),
1407 hmac);
1408 return GNUNET_YES;
1409 case GNUNET_MESSENGER_KIND_ACCESS:
1410 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1411 &auth_key, sizeof (auth_key),
1412 GNUNET_MESSENGER_SALT_EPOCH_KEY,
1413 sizeof (GNUNET_MESSENGER_SALT_EPOCH_KEY),
1414 key, sizeof (*key),
1415 GNUNET_CRYPTO_kdf_arg_auto (&message->body.access.event)))
1416 return GNUNET_NO;
1417
1418 GNUNET_CRYPTO_hmac (&auth_key, &(message->body.access),
1419 sizeof (message->body.access)
1420 - sizeof (*hmac),
1421 hmac);
1422 return GNUNET_YES;
1423 case GNUNET_MESSENGER_KIND_REVOLUTION:
1424 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1425 &auth_key, sizeof (auth_key),
1426 GNUNET_MESSENGER_SALT_ANNOUNCEMENT_KEY,
1427 sizeof (GNUNET_MESSENGER_SALT_ANNOUNCEMENT_KEY),
1428 key, sizeof (*key),
1429 GNUNET_CRYPTO_kdf_arg_auto (&message->body.revolution.identifier),
1430 GNUNET_CRYPTO_kdf_arg (&(message->body.revolution.nonce), GNUNET_MESSENGER_EPOCH_NONCE_BYTES)))
1431 return GNUNET_NO;
1432
1433 GNUNET_CRYPTO_hmac (&auth_key, &(message->body.revolution),
1434 sizeof (message->body.revolution)
1435 - sizeof (*hmac),
1436 hmac);
1437 return GNUNET_YES;
1438 case GNUNET_MESSENGER_KIND_AUTHORIZATION:
1439 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1440 &auth_key, sizeof (auth_key),
1441 GNUNET_MESSENGER_SALT_GROUP_KEY,
1442 sizeof (GNUNET_MESSENGER_SALT_GROUP_KEY),
1443 key, sizeof (*key),
1444 GNUNET_CRYPTO_kdf_arg_auto (&message->body.authorization.identifier),
1445 GNUNET_CRYPTO_kdf_arg_auto (&message->body.authorization.event)))
1446 return GNUNET_NO;
1447
1448 GNUNET_CRYPTO_hmac (&auth_key, &(message->body.authorization),
1449 sizeof (message->body.authorization)
1450 - sizeof (*hmac),
1451 hmac);
1452 return GNUNET_YES;
1453 default:
1454 return GNUNET_SYSERR;
1455 }
1456}
1457
1458
1459enum GNUNET_GenericReturnValue
1460sign_message_by_key (struct GNUNET_MESSENGER_Message *message,
1461 const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
1462{
1463 struct GNUNET_HashCode *hmac;
1464
1465 GNUNET_assert ((message) && (key));
1466
1467 switch (message->header.kind)
1468 {
1469 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
1470 hmac = &(message->body.announcement.hmac);
1471 break;
1472 case GNUNET_MESSENGER_KIND_ACCESS:
1473 hmac = &(message->body.access.hmac);
1474 break;
1475 case GNUNET_MESSENGER_KIND_REVOLUTION:
1476 hmac = &(message->body.revolution.hmac);
1477 break;
1478 case GNUNET_MESSENGER_KIND_AUTHORIZATION:
1479 hmac = &(message->body.authorization.hmac);
1480 break;
1481 default:
1482 hmac = NULL;
1483 break;
1484 }
1485
1486 if (! hmac)
1487 return GNUNET_SYSERR;
1488
1489 return calc_message_hmac (message, key, hmac);
1490}
1491
1492
1493enum GNUNET_GenericReturnValue
1494verify_message (const struct GNUNET_MESSENGER_Message *message,
1495 const struct GNUNET_HashCode *hash,
1496 const struct GNUNET_CRYPTO_BlindablePublicKey *key)
1497{
1498 struct GNUNET_MESSENGER_MessageSignature signature;
1499
1500 GNUNET_assert ((message) && (hash) && (key));
1501
1502 if (key->type != message->header.signature.type)
1503 return GNUNET_SYSERR;
1504
1505 signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
1506 signature.purpose.size = htonl (sizeof(signature));
1507
1508 GNUNET_memcpy (&(signature.hash), hash, sizeof(signature.hash));
1509
1510 return GNUNET_CRYPTO_blinded_key_signature_verify (
1511 GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature,
1512 &(message->header.signature), key);
1513}
1514
1515
1516enum GNUNET_GenericReturnValue
1517verify_message_by_peer (const struct GNUNET_MESSENGER_Message *message,
1518 const struct GNUNET_HashCode *hash,
1519 const struct GNUNET_PeerIdentity *identity)
1520{
1521 struct GNUNET_MESSENGER_MessageSignature signature;
1522
1523 GNUNET_assert ((message) && (hash) && (identity));
1524
1525 if (ntohl (GNUNET_PUBLIC_KEY_TYPE_EDDSA) != message->header.signature.type)
1526 return GNUNET_SYSERR;
1527
1528 signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
1529 signature.purpose.size = htonl (sizeof(signature));
1530
1531 GNUNET_memcpy (&(signature.hash), hash, sizeof(signature.hash));
1532
1533 return GNUNET_CRYPTO_verify_peer_identity (
1534 GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &(signature.purpose),
1535 &(message->header.signature.
1536 eddsa_signature), identity);
1537}
1538
1539
1540enum GNUNET_GenericReturnValue
1541verify_message_by_key (const struct GNUNET_MESSENGER_Message *message,
1542 const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
1543{
1544 const struct GNUNET_HashCode *msg_hmac;
1545 struct GNUNET_HashCode hmac;
1546
1547 GNUNET_assert ((message) && (key));
1548
1549 switch (message->header.kind)
1550 {
1551 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
1552 msg_hmac = &(message->body.announcement.hmac);
1553 break;
1554 case GNUNET_MESSENGER_KIND_ACCESS:
1555 msg_hmac = &(message->body.access.hmac);
1556 break;
1557 case GNUNET_MESSENGER_KIND_REVOLUTION:
1558 msg_hmac = &(message->body.revolution.hmac);
1559 break;
1560 case GNUNET_MESSENGER_KIND_AUTHORIZATION:
1561 msg_hmac = &(message->body.authorization.hmac);
1562 break;
1563 default:
1564 msg_hmac = NULL;
1565 break;
1566 }
1567
1568 if (! msg_hmac)
1569 return GNUNET_SYSERR;
1570
1571 if (GNUNET_YES != calc_message_hmac (message, key, &hmac))
1572 return GNUNET_SYSERR;
1573
1574 if (0 == GNUNET_CRYPTO_hash_cmp (&hmac, msg_hmac))
1575 return GNUNET_OK;
1576
1577 return GNUNET_SYSERR;
1578}
1579
1580
1581enum GNUNET_GenericReturnValue
1582encrypt_message (struct GNUNET_MESSENGER_Message *message,
1583 const struct GNUNET_CRYPTO_HpkePublicKey *hpke_key)
1584{
1585 enum GNUNET_GenericReturnValue result;
1586 struct GNUNET_MESSENGER_ShortMessage shortened;
1587 uint16_t length, padded_length, encoded_length;
1588 uint8_t *data;
1589
1590 GNUNET_assert ((message) && (hpke_key));
1591
1592 if (GNUNET_YES == is_service_message (message))
1593 return GNUNET_NO;
1594
1595 fold_short_message (message, &shortened);
1596
1597 length = get_short_message_size (&shortened, GNUNET_YES);
1598 padded_length = calc_padded_length (length + encryption_overhead);
1599
1600 GNUNET_assert (padded_length >= length + encryption_overhead);
1601
1602 message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
1603 message->body.privacy.data = GNUNET_malloc (padded_length);
1604 message->body.privacy.length = padded_length;
1605
1606 encoded_length = (padded_length - encryption_overhead);
1607
1608 GNUNET_assert (padded_length == encoded_length + encryption_overhead);
1609
1610 result = GNUNET_NO;
1611 data = GNUNET_malloc (encoded_length);
1612
1613 encode_short_message (&shortened, encoded_length, (char *) data);
1614
1615 if (GNUNET_OK != GNUNET_CRYPTO_hpke_seal_oneshot (hpke_key,
1616 (const uint8_t*)
1617 "messenger",
1618 strlen ("messenger"),
1619 NULL, 0,
1620 (const uint8_t*) data,
1621 encoded_length,
1622 (uint8_t*) message->body.
1623 privacy.data,
1624 NULL))
1625 {
1626 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n");
1627
1628 unfold_short_message (&shortened, message);
1629 goto cleanup;
1630 }
1631
1632 destroy_message_body (shortened.kind, &(shortened.body));
1633 result = GNUNET_YES;
1634
1635cleanup:
1636 GNUNET_free (data);
1637 return result;
1638}
1639
1640
1641enum GNUNET_GenericReturnValue
1642decrypt_message (struct GNUNET_MESSENGER_Message *message,
1643 const struct GNUNET_CRYPTO_HpkePrivateKey *hpke_key)
1644{
1645 enum GNUNET_GenericReturnValue result;
1646 uint16_t padded_length, encoded_length;
1647 uint8_t *data;
1648
1649 GNUNET_assert ((message) && (hpke_key) &&
1650 (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind));
1651
1652 padded_length = message->body.privacy.length;
1653
1654 if (padded_length < encryption_overhead)
1655 {
1656 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1657 "Message length too short to decrypt!\n");
1658
1659 return GNUNET_NO;
1660 }
1661
1662 encoded_length = (padded_length - encryption_overhead);
1663
1664 GNUNET_assert (padded_length == encoded_length + encryption_overhead);
1665
1666 result = GNUNET_NO;
1667 data = GNUNET_malloc (encoded_length);
1668
1669 if (GNUNET_OK !=
1670 GNUNET_CRYPTO_hpke_open_oneshot (hpke_key,
1671 (uint8_t*) "messenger",
1672 strlen ("messenger"),
1673 NULL, 0,
1674 (uint8_t*) message->body.privacy.data,
1675 padded_length,
1676 (uint8_t*) data,
1677 NULL))
1678 {
1679 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting message failed!\n");
1680
1681 goto cleanup;
1682 }
1683
1684 {
1685 struct GNUNET_MESSENGER_ShortMessage shortened;
1686 if (GNUNET_YES != decode_short_message (&shortened,
1687 encoded_length,
1688 (char*) data))
1689 {
1690 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1691 "Decoding decrypted message failed!\n");
1692
1693 goto cleanup;
1694 }
1695
1696 unfold_short_message (&shortened, message);
1697 result = GNUNET_YES;
1698 }
1699
1700cleanup:
1701 GNUNET_free (data);
1702 return result;
1703}
1704
1705
1706struct GNUNET_MESSENGER_Message*
1707transcribe_message (const struct GNUNET_MESSENGER_Message *message,
1708 const struct GNUNET_CRYPTO_BlindablePublicKey *key)
1709{
1710 struct GNUNET_MESSENGER_Message *transcript;
1711
1712 GNUNET_assert ((message) && (key));
1713
1714 if (GNUNET_YES == is_service_message (message))
1715 return NULL;
1716
1717 transcript = create_message (GNUNET_MESSENGER_KIND_TRANSCRIPT);
1718
1719 if (! transcript)
1720 {
1721 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Transcribing message failed!\n");
1722 return NULL;
1723 }
1724
1725 GNUNET_memcpy (&(transcript->body.transcript.key), key,
1726 sizeof(transcript->body.transcript.key));
1727
1728 {
1729 struct GNUNET_MESSENGER_ShortMessage shortened;
1730 uint16_t data_length;
1731
1732 fold_short_message (message, &shortened);
1733
1734 data_length = get_short_message_size (&shortened, GNUNET_YES);
1735
1736 transcript->body.transcript.data = GNUNET_malloc (data_length);
1737 transcript->body.transcript.length = data_length;
1738
1739 encode_short_message (&shortened, data_length,
1740 transcript->body.transcript.data);
1741 }
1742
1743 return transcript;
1744}
1745
1746
1747enum GNUNET_GenericReturnValue
1748encrypt_secret_message (struct GNUNET_MESSENGER_Message *message,
1749 const union GNUNET_MESSENGER_EpochIdentifier *identifier
1750 ,
1751 const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
1752{
1753 enum GNUNET_GenericReturnValue result;
1754 struct GNUNET_MESSENGER_ShortMessage shortened;
1755 uint16_t length, padded_length;
1756 uint8_t *data;
1757
1758 GNUNET_assert ((message) && (identifier) && (key));
1759
1760 fold_short_message (message, &shortened);
1761
1762 length = get_short_message_size (&shortened, GNUNET_YES);
1763 padded_length = calc_padded_length (length + 0);
1764
1765 GNUNET_assert (padded_length >= length + 0);
1766
1767 message->header.kind = GNUNET_MESSENGER_KIND_SECRET;
1768
1769 GNUNET_memcpy (&(message->body.secret.identifier), identifier,
1770 sizeof (message->body.secret.identifier));
1771
1772 GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
1773 &(message->body.secret.iv),
1774 GNUNET_MESSENGER_SECRET_IV_BYTES);
1775
1776 message->body.secret.data = GNUNET_malloc (padded_length);
1777 message->body.secret.length = padded_length;
1778
1779 result = GNUNET_NO;
1780 data = GNUNET_malloc (padded_length);
1781
1782 encode_short_message (&shortened, padded_length, (char *) data);
1783
1784 {
1785 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
1786
1787 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1788 &iv, sizeof (iv),
1789 GNUNET_MESSENGER_SALT_SECRET_IV,
1790 sizeof (GNUNET_MESSENGER_SALT_SECRET_IV),
1791 key, sizeof (*key),
1792 GNUNET_CRYPTO_kdf_arg (message->body.secret.iv, GNUNET_MESSENGER_SECRET_IV_BYTES)))
1793 {
1794 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deriving initialization vector failed!\n");
1795 unfold_short_message (&shortened, message);
1796 goto cleanup;
1797 }
1798
1799 if (-1 == GNUNET_CRYPTO_symmetric_encrypt (data, padded_length, key,
1800 &iv, message->body.secret.data))
1801 {
1802 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n");
1803 unfold_short_message (&shortened, message);
1804 goto cleanup;
1805 }
1806 }
1807
1808 {
1809 struct GNUNET_CRYPTO_AuthKey auth_key;
1810
1811 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1812 &auth_key, sizeof (auth_key),
1813 GNUNET_MESSENGER_SALT_SECRET_KEY,
1814 sizeof (GNUNET_MESSENGER_SALT_SECRET_KEY),
1815 key, sizeof (*key),
1816 GNUNET_CRYPTO_kdf_arg (message->body.secret.iv, GNUNET_MESSENGER_SECRET_IV_BYTES)))
1817 {
1818 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deriving authentication key failed!\n");
1819 unfold_short_message (&shortened, message);
1820 goto cleanup;
1821 }
1822
1823 GNUNET_CRYPTO_hmac (&auth_key, message->body.secret.data, padded_length,
1824 &(message->body.secret.hmac));
1825 }
1826
1827 destroy_message_body (shortened.kind, &(shortened.body));
1828 result = GNUNET_YES;
1829
1830cleanup:
1831 GNUNET_free (data);
1832 return result;
1833}
1834
1835
1836enum GNUNET_GenericReturnValue
1837decrypt_secret_message (struct GNUNET_MESSENGER_Message *message,
1838 const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
1839{
1840 enum GNUNET_GenericReturnValue result;
1841 uint16_t padded_length;
1842 uint8_t *data;
1843
1844 GNUNET_assert ((message) && (key) &&
1845 (GNUNET_MESSENGER_KIND_SECRET == message->header.kind));
1846
1847 padded_length = message->body.secret.length;
1848
1849 {
1850 struct GNUNET_CRYPTO_AuthKey auth_key;
1851 struct GNUNET_HashCode hmac;
1852
1853 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1854 &auth_key, sizeof (auth_key),
1855 GNUNET_MESSENGER_SALT_SECRET_KEY,
1856 sizeof (GNUNET_MESSENGER_SALT_SECRET_KEY),
1857 key, sizeof (*key),
1858 GNUNET_CRYPTO_kdf_arg (message->body.secret.iv, GNUNET_MESSENGER_SECRET_IV_BYTES)))
1859 {
1860 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deriving authentication key failed!\n");
1861 return GNUNET_NO;
1862 }
1863
1864 GNUNET_CRYPTO_hmac (&auth_key, message->body.secret.data, padded_length,
1865 &hmac);
1866
1867 if (0 != GNUNET_CRYPTO_hash_cmp (&(message->body.secret.hmac), &hmac))
1868 {
1869 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1870 "Decrypted message does not match HMAC!\n");
1871 return GNUNET_NO;
1872 }
1873 }
1874
1875 result = GNUNET_NO;
1876 data = GNUNET_malloc (padded_length);
1877
1878 {
1879 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
1880
1881 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1882 &iv, sizeof (iv),
1883 GNUNET_MESSENGER_SALT_SECRET_IV,
1884 sizeof (GNUNET_MESSENGER_SALT_SECRET_IV),
1885 key,
1886 sizeof (*key),
1887 GNUNET_CRYPTO_kdf_arg (message->body.secret.iv, GNUNET_MESSENGER_SECRET_IV_BYTES)))
1888 {
1889 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deriving initialization vector failed!\n");
1890 goto cleanup;
1891 }
1892
1893 if (-1 == GNUNET_CRYPTO_symmetric_decrypt (message->body.secret.data,
1894 padded_length,
1895 key, &iv, data))
1896 {
1897 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting message failed!\n");
1898 goto cleanup;
1899 }
1900 }
1901
1902 {
1903 struct GNUNET_MESSENGER_ShortMessage shortened;
1904 if (GNUNET_YES != decode_short_message (&shortened,
1905 padded_length,
1906 (char*) data))
1907 {
1908 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1909 "Decoding decrypted message failed!\n");
1910
1911 goto cleanup;
1912 }
1913
1914 unfold_short_message (&shortened, message);
1915 result = GNUNET_YES;
1916 }
1917
1918cleanup:
1919 GNUNET_free (data);
1920 return result;
1921}
1922
1923
1924enum GNUNET_GenericReturnValue
1925read_transcript_message (struct GNUNET_MESSENGER_Message *message)
1926{
1927 uint16_t data_length;
1928 struct GNUNET_MESSENGER_ShortMessage shortened;
1929
1930 GNUNET_assert ((message) &&
1931 (GNUNET_MESSENGER_KIND_TRANSCRIPT == message->header.kind));
1932
1933 data_length = message->body.transcript.length;
1934
1935 if (GNUNET_YES != decode_short_message (&shortened,
1936 data_length,
1937 message->body.transcript.data))
1938 {
1939 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1940 "Decoding decrypted message failed!\n");
1941
1942 return GNUNET_NO;
1943 }
1944
1945 unfold_short_message (&shortened, message);
1946 return GNUNET_YES;
1947}
1948
1949
1950enum GNUNET_GenericReturnValue
1951extract_access_message_key (const struct GNUNET_MESSENGER_Message *message,
1952 const struct GNUNET_CRYPTO_HpkePrivateKey *key,
1953 struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key
1954 )
1955{
1956 GNUNET_assert ((message) && (key) && (shared_key) &&
1957 (GNUNET_MESSENGER_KIND_ACCESS == message->header.kind));
1958
1959 if (GNUNET_OK !=
1960 GNUNET_CRYPTO_hpke_open_oneshot (key,
1961 (uint8_t*) "messenger",
1962 strlen ("messenger"),
1963 NULL, 0,
1964 (uint8_t*) message->body.access.key,
1965 GNUNET_MESSENGER_ACCESS_KEY_BYTES,
1966 (uint8_t*) shared_key,
1967 NULL))
1968 {
1969 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting shared key failed!\n");
1970 return GNUNET_NO;
1971 }
1972
1973 if (GNUNET_OK != verify_message_by_key (message, shared_key))
1974 {
1975 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Shared key mismatches HMAC!\n");
1976 return GNUNET_NO;
1977 }
1978
1979 return GNUNET_YES;
1980}
1981
1982
1983enum GNUNET_GenericReturnValue
1984extract_authorization_message_key (struct GNUNET_MESSENGER_Message *message,
1985 const struct
1986 GNUNET_CRYPTO_SymmetricSessionKey *key,
1987 struct GNUNET_CRYPTO_SymmetricSessionKey *
1988 shared_key)
1989{
1990 struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
1991
1992 GNUNET_assert ((message) && (key) && (shared_key) &&
1993 (GNUNET_MESSENGER_KIND_AUTHORIZATION == message->header.kind));
1994
1995 if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
1996 &iv, sizeof (iv),
1997 GNUNET_MESSENGER_SALT_GROUP_KEY,
1998 sizeof (GNUNET_MESSENGER_SALT_GROUP_KEY),
1999 key,
2000 sizeof (*key),
2001 GNUNET_CRYPTO_kdf_arg_auto (&message->body.authorization.identifier),
2002 GNUNET_CRYPTO_kdf_arg_auto (&message->body.authorization.event)))
2003 {
2004 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Deriving initialization vector failed!\n");
2005 return GNUNET_NO;
2006 }
2007
2008 if (-1 == GNUNET_CRYPTO_symmetric_decrypt (message->body.authorization.key,
2009 GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES,
2010 key,
2011 &iv,
2012 shared_key))
2013 {
2014 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting shared key failed!\n");
2015 return GNUNET_NO;
2016 }
2017
2018 if (GNUNET_OK != verify_message_by_key (message, shared_key))
2019 {
2020 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Shared key mismatches HMAC!\n");
2021 return GNUNET_NO;
2022 }
2023
2024 return GNUNET_YES;
2025}
2026
2027
2028struct GNUNET_TIME_Relative
2029get_message_timeout (const struct GNUNET_MESSENGER_Message *message)
2030{
2031 struct GNUNET_TIME_Absolute timestamp;
2032 struct GNUNET_TIME_Relative timeout;
2033
2034 GNUNET_assert (message);
2035
2036 timestamp = GNUNET_TIME_absolute_ntoh (message->header.timestamp);
2037
2038 switch (message->header.kind)
2039 {
2040 case GNUNET_MESSENGER_KIND_DELETION:
2041 timeout = GNUNET_TIME_relative_ntoh (message->body.deletion.delay);
2042 break;
2043 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
2044 timeout = GNUNET_TIME_relative_ntoh (message->body.announcement.timeout);
2045 break;
2046 case GNUNET_MESSENGER_KIND_APPEAL:
2047 timeout = GNUNET_TIME_relative_ntoh (message->body.appeal.timeout);
2048 break;
2049 case GNUNET_MESSENGER_KIND_GROUP:
2050 timeout = GNUNET_TIME_relative_ntoh (message->body.group.timeout);
2051 break;
2052 default:
2053 timeout = GNUNET_TIME_relative_get_zero_ ();
2054 break;
2055 }
2056
2057 timestamp = GNUNET_TIME_absolute_add (timestamp, timeout);
2058
2059 timeout = GNUNET_TIME_absolute_get_remaining (timestamp);
2060 timeout = GNUNET_TIME_relative_min (timeout,
2061 GNUNET_TIME_relative_get_minute_ ());
2062
2063 return timeout;
2064}
2065
2066
2067struct GNUNET_MQ_Envelope*
2068pack_message (struct GNUNET_MESSENGER_Message *message,
2069 struct GNUNET_HashCode *hash,
2070 enum GNUNET_MESSENGER_PackMode mode)
2071{
2072 struct GNUNET_MessageHeader *header;
2073 uint16_t length, padded_length;
2074 struct GNUNET_MQ_Envelope *env;
2075 char *buffer;
2076
2077 GNUNET_assert (message);
2078
2079 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2080 "Packing message kind=%u and sender: %s\n",
2081 message->header.kind, GNUNET_sh2s (&(message->header.sender_id)));
2082
2083 length = get_message_size (message, GNUNET_YES);
2084 padded_length = calc_padded_length (length);
2085
2086 if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode)
2087 {
2088 env = GNUNET_MQ_msg_extra (header, padded_length,
2089 GNUNET_MESSAGE_TYPE_CADET_CLI);
2090 buffer = (char*) &(header[1]);
2091 }
2092 else
2093 {
2094 env = NULL;
2095 buffer = GNUNET_malloc (padded_length);
2096 }
2097
2098 encode_message (message, padded_length, buffer, GNUNET_YES);
2099
2100 if (hash)
2101 hash_message (message, length, buffer, hash);
2102
2103 if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode)
2104 GNUNET_free (buffer);
2105
2106 return env;
2107}
2108
2109
2110enum GNUNET_GenericReturnValue
2111is_peer_message (const struct GNUNET_MESSENGER_Message *message)
2112{
2113 GNUNET_assert (message);
2114
2115 switch (message->header.kind)
2116 {
2117 case GNUNET_MESSENGER_KIND_INFO:
2118 case GNUNET_MESSENGER_KIND_PEER:
2119 case GNUNET_MESSENGER_KIND_MISS:
2120 case GNUNET_MESSENGER_KIND_MERGE:
2121 case GNUNET_MESSENGER_KIND_CONNECTION:
2122 return GNUNET_YES;
2123 default:
2124 return GNUNET_NO;
2125 }
2126}
2127
2128
2129enum GNUNET_GenericReturnValue
2130is_service_message (const struct GNUNET_MESSENGER_Message *message)
2131{
2132 GNUNET_assert (message);
2133
2134 if (GNUNET_YES == is_peer_message (message))
2135 return GNUNET_YES;
2136
2137 switch (message->header.kind)
2138 {
2139 case GNUNET_MESSENGER_KIND_INFO:
2140 return GNUNET_YES; // Reserved for connection handling only!
2141 case GNUNET_MESSENGER_KIND_JOIN:
2142 return GNUNET_YES; // Reserved for member handling only!
2143 case GNUNET_MESSENGER_KIND_LEAVE:
2144 return GNUNET_YES; // Reserved for member handling only!
2145 case GNUNET_MESSENGER_KIND_NAME:
2146 return GNUNET_YES; // Reserved for member name handling only!
2147 case GNUNET_MESSENGER_KIND_KEY:
2148 return GNUNET_YES; // Reserved for member key handling only!
2149 case GNUNET_MESSENGER_KIND_PEER:
2150 return GNUNET_YES; // Reserved for connection handling only!
2151 case GNUNET_MESSENGER_KIND_ID:
2152 return GNUNET_YES; // Reserved for member id handling only!
2153 case GNUNET_MESSENGER_KIND_MISS:
2154 return GNUNET_YES; // Reserved for connection handling only!
2155 case GNUNET_MESSENGER_KIND_MERGE:
2156 return GNUNET_YES; // Reserved for peers only!
2157 case GNUNET_MESSENGER_KIND_REQUEST:
2158 return GNUNET_YES; // Requests should not apply individually! (inefficiently)
2159 case GNUNET_MESSENGER_KIND_INVITE:
2160 return GNUNET_NO;
2161 case GNUNET_MESSENGER_KIND_TEXT:
2162 return GNUNET_NO;
2163 case GNUNET_MESSENGER_KIND_FILE:
2164 return GNUNET_NO;
2165 case GNUNET_MESSENGER_KIND_PRIVATE:
2166 return GNUNET_YES; // Prevent duplicate encryption breaking all access!
2167 case GNUNET_MESSENGER_KIND_DELETION:
2168 return GNUNET_YES; // Deletion should not apply individually! (inefficiently)
2169 case GNUNET_MESSENGER_KIND_CONNECTION:
2170 return GNUNET_YES; // Reserved for connection handling only!
2171 case GNUNET_MESSENGER_KIND_TICKET:
2172 return GNUNET_NO;
2173 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
2174 return GNUNET_NO;
2175 case GNUNET_MESSENGER_KIND_TAG:
2176 return GNUNET_NO;
2177 case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
2178 return GNUNET_YES; // Reserved for subscription handling only!
2179 case GNUNET_MESSENGER_KIND_TALK:
2180 return GNUNET_NO;
2181 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
2182 return GNUNET_YES; // Reserved for epoch and group key exchange!
2183 case GNUNET_MESSENGER_KIND_SECRET:
2184 return GNUNET_YES; // Prevent duplicate encryption breaking all access!
2185 case GNUNET_MESSENGER_KIND_APPEAL:
2186 return GNUNET_YES; // Reserved for epoch key exchange!
2187 case GNUNET_MESSENGER_KIND_ACCESS:
2188 return GNUNET_YES; // Reserved for epoch and group key exchange!
2189 case GNUNET_MESSENGER_KIND_REVOLUTION:
2190 return GNUNET_YES; // Reserved for epoch and group key revoking!
2191 case GNUNET_MESSENGER_KIND_GROUP:
2192 return GNUNET_YES; // Reserved for group key exchange!
2193 case GNUNET_MESSENGER_KIND_AUTHORIZATION:
2194 return GNUNET_YES; // Reserved for epoch and group key exchange!
2195 default:
2196 return GNUNET_SYSERR;
2197 }
2198}
2199
2200
2201enum GNUNET_GenericReturnValue
2202is_epoch_message (const struct GNUNET_MESSENGER_Message *message)
2203{
2204 GNUNET_assert (message);
2205
2206 switch (message->header.kind)
2207 {
2208 case GNUNET_MESSENGER_KIND_JOIN:
2209 return GNUNET_YES;
2210 case GNUNET_MESSENGER_KIND_LEAVE:
2211 return GNUNET_YES;
2212 case GNUNET_MESSENGER_KIND_MERGE:
2213 return GNUNET_YES;
2214 default:
2215 return GNUNET_NO;
2216 }
2217}
2218
2219
2220enum GNUNET_GenericReturnValue
2221filter_message_sending (const struct GNUNET_MESSENGER_Message *message)
2222{
2223 GNUNET_assert (message);
2224
2225 if (GNUNET_YES == is_peer_message (message))
2226 return GNUNET_SYSERR; // Requires signature of peer rather than member!
2227
2228 switch (message->header.kind)
2229 {
2230 case GNUNET_MESSENGER_KIND_INFO:
2231 return GNUNET_SYSERR; // Reserved for connection handling only!
2232 case GNUNET_MESSENGER_KIND_JOIN:
2233 return GNUNET_NO; // Use #GNUNET_MESSENGER_enter_room(...) instead!
2234 case GNUNET_MESSENGER_KIND_LEAVE:
2235 return GNUNET_NO; // Use #GNUNET_MESSENGER_close_room(...) instead!
2236 case GNUNET_MESSENGER_KIND_NAME:
2237 return GNUNET_YES;
2238 case GNUNET_MESSENGER_KIND_KEY:
2239 return GNUNET_NO; // Use #GNUNET_MESSENGER_set_key(...) instead!
2240 case GNUNET_MESSENGER_KIND_PEER:
2241 return GNUNET_SYSERR; // Use #GNUNET_MESSENGER_open_room(...) instead!
2242 case GNUNET_MESSENGER_KIND_ID:
2243 return GNUNET_NO; // Reserved for member id handling only!
2244 case GNUNET_MESSENGER_KIND_MISS:
2245 return GNUNET_SYSERR; // Reserved for connection handling only!
2246 case GNUNET_MESSENGER_KIND_MERGE:
2247 return GNUNET_SYSERR; // Reserved for peers only!
2248 case GNUNET_MESSENGER_KIND_REQUEST:
2249 return GNUNET_NO; // Use #GNUNET_MESSENGER_get_message(...) instead!
2250 case GNUNET_MESSENGER_KIND_INVITE:
2251 return GNUNET_YES;
2252 case GNUNET_MESSENGER_KIND_TEXT:
2253 return GNUNET_YES;
2254 case GNUNET_MESSENGER_KIND_FILE:
2255 return GNUNET_YES;
2256 case GNUNET_MESSENGER_KIND_PRIVATE:
2257 return GNUNET_NO; // Use #GNUNET_MESSENGER_send_message(...) with a contact instead!
2258 case GNUNET_MESSENGER_KIND_DELETION:
2259 return GNUNET_NO; // Use #GNUNET_MESSENGER_delete_message(...) instead!
2260 case GNUNET_MESSENGER_KIND_CONNECTION:
2261 return GNUNET_SYSERR; // Reserved for connection handling only!
2262 case GNUNET_MESSENGER_KIND_TICKET:
2263 return GNUNET_YES;
2264 case GNUNET_MESSENGER_KIND_TRANSCRIPT:
2265 return GNUNET_NO; // Use #GNUNET_MESSENGER_send_message(...) with a contact instead!
2266 case GNUNET_MESSENGER_KIND_TAG:
2267 return GNUNET_YES;
2268 case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
2269 return GNUNET_YES;
2270 case GNUNET_MESSENGER_KIND_TALK:
2271 return GNUNET_YES;
2272 case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
2273 return GNUNET_NO; // Should only be used for implicit key exchange!
2274 case GNUNET_MESSENGER_KIND_SECRET:
2275 return GNUNET_NO; // Should only be used for implicit forward secrecy!
2276 case GNUNET_MESSENGER_KIND_APPEAL:
2277 return GNUNET_NO; // Should only be used for implicit key exchange!
2278 case GNUNET_MESSENGER_KIND_ACCESS:
2279 return GNUNET_NO; // Should only be used for implicit key exchange!
2280 case GNUNET_MESSENGER_KIND_REVOLUTION:
2281 return GNUNET_NO; // Should only be used for implicit key exchange!
2282 case GNUNET_MESSENGER_KIND_GROUP:
2283 return GNUNET_NO; // Should only be used for implicit key exchange!
2284 case GNUNET_MESSENGER_KIND_AUTHORIZATION:
2285 return GNUNET_NO; // Should only be used for implicit key exchange!
2286 default:
2287 return GNUNET_SYSERR;
2288 }
2289}
2290
2291
2292const struct GNUNET_ShortHashCode*
2293get_message_discourse (const struct GNUNET_MESSENGER_Message *message)
2294{
2295 GNUNET_assert (message);
2296
2297 switch (message->header.kind)
2298 {
2299 case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
2300 return &(message->body.subscription.discourse);
2301 case GNUNET_MESSENGER_KIND_TALK:
2302 return &(message->body.talk.discourse);
2303 default:
2304 return NULL;
2305 }
2306}
env
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
sign_cb
static void sign_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego)
Definition gnunet-abd.c:675
timeout
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition gnunet-arm.c:118
timestamp
static uint64_t timestamp(void)
Get current timestamp.
Definition gnunet-communicator-http3.c:411
data
static char * data
The data to insert into the dht.
Definition gnunet-dht-put.c:88
key
struct GNUNET_HashCode key
The key used in the DHT.
Definition gnunet-dht-put.c:37
pils
static struct GNUNET_PILS_Handle * pils
Handle to PILS.
Definition gnunet-pils.c:44
identity
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
Definition gnunet-publish.c:142
result
static int result
Global testing status.
Definition gnunet-regex-profiler.c:240
cleanup
static void cleanup()
Cleanup task.
Definition gnunet-service-reclaim.c:614
gnunet_common.h
commonly used definitions; globals in this file are exempt from the rule that the module name ("commo...
mode
static enum @52 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
gnunet_messenger_service.h
gnunet_pils_service.h
GNUNET_PILS_sign_by_peer_identity
struct GNUNET_PILS_Operation * GNUNET_PILS_sign_by_peer_identity(struct GNUNET_PILS_Handle *handle, const struct GNUNET_CRYPTO_SignaturePurpose *purpose, GNUNET_PILS_SignResultCallback cb, void *cb_cls)
Sign data with the peer id.
Definition pils_api.c:528
GNUNET_PILS_SignResultCallback
void(* GNUNET_PILS_SignResultCallback)(void *cls, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig)
A handler/callback to be called for signatures.
Definition gnunet_pils_service.h:63
gnunet_signatures.h
GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE
#define GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE
Signature of a chat message.
Definition gnunet_signatures.h:106
gnunet_util_lib.h
GNUNET_CRYPTO_random_block
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
Definition crypto_random.c:133
GNUNET_CRYPTO_symmetric_encrypt
ssize_t GNUNET_CRYPTO_symmetric_encrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, void *result)
Encrypt a block using a symmetric sessionkey.
Definition crypto_symmetric.c:118
GNUNET_CRYPTO_verify_peer_identity
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_verify_peer_identity(uint32_t purpose, const struct GNUNET_CRYPTO_SignaturePurpose *validate, const struct GNUNET_CRYPTO_EddsaSignature *sig, const struct GNUNET_PeerIdentity *identity)
Verify a given signature with a peer's identity.
Definition crypto_ecc_setup.c:321
GNUNET_CRYPTO_symmetric_decrypt
ssize_t GNUNET_CRYPTO_symmetric_decrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, void *result)
Decrypt a given block using a symmetric sessionkey.
Definition crypto_symmetric.c:144
GNUNET_CRYPTO_QUALITY_WEAK
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Definition gnunet_crypto_lib.h:92
GNUNET_CRYPTO_QUALITY_NONCE
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
Definition gnunet_crypto_lib.h:104
GNUNET_CRYPTO_hash
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition crypto_hash.c:41
GNUNET_CRYPTO_hmac
void GNUNET_CRYPTO_hmac(const struct GNUNET_CRYPTO_AuthKey *key, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104)
Definition crypto_hash.c:295
GNUNET_CRYPTO_hkdf_gnunet
#define GNUNET_CRYPTO_hkdf_gnunet(result, out_len, xts, xts_len, skm, skm_len,...)
A peculiar HKDF instantiation that tried to mimic Truncated NMAC.
Definition gnunet_crypto_lib.h:1449
GNUNET_CRYPTO_hash_cmp
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition crypto_hash.c:219
GNUNET_CRYPTO_blinded_key_signature_verify
#define GNUNET_CRYPTO_blinded_key_signature_verify(purp, ps, sig, pub)
Verify a given signature with GNUNET_CRYPTO_BlindablePublicKey.
Definition gnunet_crypto_lib.h:4827
GNUNET_log
#define GNUNET_log(kind,...)
Definition gnunet_common.h:551
GNUNET_be32toh
#define GNUNET_be32toh(x)
Definition gnunet_common.h:197
GNUNET_CRYPTO_hpke_pk_get_length
ssize_t GNUNET_CRYPTO_hpke_pk_get_length(const struct GNUNET_CRYPTO_HpkePublicKey *key)
Get the compacted length of a GNUNET_CRYPTO_HpkePublicKey.
Definition crypto_hpke.c:894
GNUNET_CRYPTO_hpke_seal_oneshot
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hpke_seal_oneshot(const struct GNUNET_CRYPTO_HpkePublicKey *pkR, const uint8_t *info, size_t info_len, const uint8_t *aad, size_t aad_len, const uint8_t *pt, size_t pt_len, uint8_t *ct, unsigned long long *ct_len)
RFC9180 HPKE encryption.
Definition crypto_hpke.c:777
GNUNET_CRYPTO_hpke_open_oneshot
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hpke_open_oneshot(const struct GNUNET_CRYPTO_HpkePrivateKey *skR, const uint8_t *info, size_t info_len, const uint8_t *aad, size_t aad_len, const uint8_t *ct, size_t ct_len, uint8_t *pt, unsigned long long *pt_len)
RFC9180 HPKE encryption.
Definition crypto_hpke.c:807
GNUNET_CRYPTO_blinded_key_signature_get_length
ssize_t GNUNET_CRYPTO_blinded_key_signature_get_length(const struct GNUNET_CRYPTO_BlindableKeySignature *sig)
Get the compacted length of a #GNUNET_CRYPTO_Signature.
Definition crypto_pkey.c:194
GNUNET_CRYPTO_kdf_arg_auto
#define GNUNET_CRYPTO_kdf_arg_auto(d)
Definition gnunet_crypto_lib.h:1368
GNUNET_CRYPTO_blinded_key_sign
#define GNUNET_CRYPTO_blinded_key_sign(priv, ps, sig)
Sign a given block with GNUNET_CRYPTO_BlindablePrivateKey.
Definition gnunet_crypto_lib.h:4754
GNUNET_CRYPTO_kdf_arg
#define GNUNET_CRYPTO_kdf_arg(d, s)
Definition gnunet_crypto_lib.h:1376
GNUNET_memcpy
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Definition gnunet_common.h:1320
GNUNET_GenericReturnValue
GNUNET_GenericReturnValue
Named constants for return values.
Definition gnunet_common.h:111
GNUNET_CRYPTO_blindable_pk_get_length
ssize_t GNUNET_CRYPTO_blindable_pk_get_length(const struct GNUNET_CRYPTO_BlindablePublicKey *key)
Get the compacted length of a GNUNET_CRYPTO_BlindablePublicKey.
Definition crypto_pkey.c:85
GNUNET_htobe32
#define GNUNET_htobe32(x)
Definition gnunet_common.h:195
GNUNET_PACKED
#define GNUNET_PACKED
gcc-ism to get packed structs.
Definition gnunet_common.h:241
GNUNET_CRYPTO_read_blinded_key_signature_from_buffer
ssize_t GNUNET_CRYPTO_read_blinded_key_signature_from_buffer(struct GNUNET_CRYPTO_BlindableKeySignature *sig, const void *buffer, size_t len)
Reads a GNUNET_CRYPTO_BlindableKeySignature from a compact buffer.
Definition crypto_pkey.c:232
GNUNET_CRYPTO_HPKE_SEAL_ONESHOT_OVERHEAD_BYTES
#define GNUNET_CRYPTO_HPKE_SEAL_ONESHOT_OVERHEAD_BYTES
Definition gnunet_crypto_lib.h:2173
GNUNET_PUBLIC_KEY_TYPE_EDDSA
@ GNUNET_PUBLIC_KEY_TYPE_EDDSA
EDDSA identity.
Definition gnunet_crypto_lib.h:391
GNUNET_OK
@ GNUNET_OK
Definition gnunet_common.h:114
GNUNET_YES
@ GNUNET_YES
Definition gnunet_common.h:116
GNUNET_NO
@ GNUNET_NO
Definition gnunet_common.h:113
GNUNET_SYSERR
@ GNUNET_SYSERR
Definition gnunet_common.h:112
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition gnunet_common.h:960
GNUNET_sh2s
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
Definition common_logging.c:1313
GNUNET_h2s
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
Definition common_logging.c:1206
GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_WARNING
Definition gnunet_common.h:418
GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_DEBUG
Definition gnunet_common.h:424
GNUNET_strdup
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Definition gnunet_common.h:1429
GNUNET_new
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition gnunet_common.h:1240
GNUNET_malloc
#define GNUNET_malloc(size)
Wrapper around malloc.
Definition gnunet_common.h:1355
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition gnunet_common.h:1415
GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES
#define GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES
Definition gnunet_messenger_service.h:1052
GNUNET_MESSENGER_ACCESS_KEY_BYTES
#define GNUNET_MESSENGER_ACCESS_KEY_BYTES
Definition gnunet_messenger_service.h:971
GNUNET_MESSENGER_MessageKind
GNUNET_MESSENGER_MessageKind
Enum for the different supported kinds of messages.
Definition gnunet_messenger_service.h:274
GNUNET_MESSENGER_EPOCH_NONCE_BYTES
#define GNUNET_MESSENGER_EPOCH_NONCE_BYTES
Definition gnunet_messenger_service.h:203
GNUNET_MESSENGER_SECRET_IV_BYTES
#define GNUNET_MESSENGER_SECRET_IV_BYTES
Definition gnunet_messenger_service.h:910
GNUNET_MESSENGER_KIND_MAX
#define GNUNET_MESSENGER_KIND_MAX
Definition gnunet_messenger_service.h:421
GNUNET_MESSENGER_KIND_INFO
@ GNUNET_MESSENGER_KIND_INFO
The info kind.
Definition gnunet_messenger_service.h:278
GNUNET_MESSENGER_KIND_MISS
@ GNUNET_MESSENGER_KIND_MISS
The miss kind.
Definition gnunet_messenger_service.h:313
GNUNET_MESSENGER_KIND_INVITE
@ GNUNET_MESSENGER_KIND_INVITE
The invite kind.
Definition gnunet_messenger_service.h:328
GNUNET_MESSENGER_KIND_AUTHORIZATION
@ GNUNET_MESSENGER_KIND_AUTHORIZATION
The authorization kind.
Definition gnunet_messenger_service.h:413
GNUNET_MESSENGER_KIND_ANNOUNCEMENT
@ GNUNET_MESSENGER_KIND_ANNOUNCEMENT
The announcement kind.
Definition gnunet_messenger_service.h:383
GNUNET_MESSENGER_KIND_PRIVATE
@ GNUNET_MESSENGER_KIND_PRIVATE
The private kind.
Definition gnunet_messenger_service.h:343
GNUNET_MESSENGER_KIND_TAG
@ GNUNET_MESSENGER_KIND_TAG
The tag kind.
Definition gnunet_messenger_service.h:368
GNUNET_MESSENGER_KIND_FILE
@ GNUNET_MESSENGER_KIND_FILE
The file kind.
Definition gnunet_messenger_service.h:338
GNUNET_MESSENGER_KIND_APPEAL
@ GNUNET_MESSENGER_KIND_APPEAL
The appeal kind.
Definition gnunet_messenger_service.h:393
GNUNET_MESSENGER_KIND_REQUEST
@ GNUNET_MESSENGER_KIND_REQUEST
The request kind.
Definition gnunet_messenger_service.h:323
GNUNET_MESSENGER_KIND_NAME
@ GNUNET_MESSENGER_KIND_NAME
The name kind.
Definition gnunet_messenger_service.h:293
GNUNET_MESSENGER_KIND_ACCESS
@ GNUNET_MESSENGER_KIND_ACCESS
The access kind.
Definition gnunet_messenger_service.h:398
GNUNET_MESSENGER_KIND_LEAVE
@ GNUNET_MESSENGER_KIND_LEAVE
The leave kind.
Definition gnunet_messenger_service.h:288
GNUNET_MESSENGER_KIND_TALK
@ GNUNET_MESSENGER_KIND_TALK
The talk kind.
Definition gnunet_messenger_service.h:378
GNUNET_MESSENGER_KIND_REVOLUTION
@ GNUNET_MESSENGER_KIND_REVOLUTION
The revolution kind.
Definition gnunet_messenger_service.h:403
GNUNET_MESSENGER_KIND_PEER
@ GNUNET_MESSENGER_KIND_PEER
The peer kind.
Definition gnunet_messenger_service.h:303
GNUNET_MESSENGER_KIND_UNKNOWN
@ GNUNET_MESSENGER_KIND_UNKNOWN
The unknown kind.
Definition gnunet_messenger_service.h:418
GNUNET_MESSENGER_KIND_TRANSCRIPT
@ GNUNET_MESSENGER_KIND_TRANSCRIPT
The transcript kind.
Definition gnunet_messenger_service.h:363
GNUNET_MESSENGER_KIND_KEY
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
Definition gnunet_messenger_service.h:298
GNUNET_MESSENGER_KIND_TEXT
@ GNUNET_MESSENGER_KIND_TEXT
The text kind.
Definition gnunet_messenger_service.h:333
GNUNET_MESSENGER_KIND_SECRET
@ GNUNET_MESSENGER_KIND_SECRET
The secret kind.
Definition gnunet_messenger_service.h:388
GNUNET_MESSENGER_KIND_JOIN
@ GNUNET_MESSENGER_KIND_JOIN
The join kind.
Definition gnunet_messenger_service.h:283
GNUNET_MESSENGER_KIND_SUBSCRIBTION
@ GNUNET_MESSENGER_KIND_SUBSCRIBTION
The subscription kind.
Definition gnunet_messenger_service.h:373
GNUNET_MESSENGER_KIND_DELETION
@ GNUNET_MESSENGER_KIND_DELETION
The deletion kind.
Definition gnunet_messenger_service.h:348
GNUNET_MESSENGER_KIND_CONNECTION
@ GNUNET_MESSENGER_KIND_CONNECTION
The connection kind.
Definition gnunet_messenger_service.h:353
GNUNET_MESSENGER_KIND_TICKET
@ GNUNET_MESSENGER_KIND_TICKET
The ticket kind.
Definition gnunet_messenger_service.h:358
GNUNET_MESSENGER_KIND_MERGE
@ GNUNET_MESSENGER_KIND_MERGE
The merge kind.
Definition gnunet_messenger_service.h:318
GNUNET_MESSENGER_KIND_GROUP
@ GNUNET_MESSENGER_KIND_GROUP
The group kind.
Definition gnunet_messenger_service.h:408
GNUNET_MESSENGER_KIND_ID
@ GNUNET_MESSENGER_KIND_ID
The id kind.
Definition gnunet_messenger_service.h:308
GNUNET_MQ_msg_extra
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition gnunet_mq_lib.h:61
GNUNET_MESSAGE_TYPE_CADET_CLI
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
Definition gnunet_protocols.h:3163
GNUNET_TIME_relative_min
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition time.c:344
GNUNET_TIME_relative_get_zero_
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_zero_(void)
Return relative time of 0ms.
Definition time.c:133
GNUNET_TIME_relative_ntoh
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition time.c:626
GNUNET_TIME_relative_get_minute_
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_minute_(void)
Return relative time of 1 minute.
Definition time.c:178
GNUNET_TIME_absolute_get_remaining
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition time.c:406
GNUNET_TIME_absolute_ntoh
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition time.c:737
GNUNET_TIME_absolute_add
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition time.c:452
destroy_message_body
static void destroy_message_body(enum GNUNET_MESSENGER_MessageKind kind, struct GNUNET_MESSENGER_MessageBody *body)
Definition messenger_api_message.c:193
encrypt_message
enum GNUNET_GenericReturnValue encrypt_message(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_HpkePublicKey *hpke_key)
Encrypts a message using a given public key and replaces its body and kind with the now private encry...
Definition messenger_api_message.c:1582
decode_step
#define decode_step(src, offset, dst)
Definition messenger_api_message.c:941
encode_message_signature
void encode_message_signature(const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer)
Encodes the signature of a given message into a buffer of a maximum length in bytes.
Definition messenger_api_message.c:863
encode_step_ext
#define encode_step_ext(dst, offset, src, size)
Definition messenger_api_message.c:623
get_short_message_size
static uint16_t get_short_message_size(const struct GNUNET_MESSENGER_ShortMessage *message, enum GNUNET_GenericReturnValue include_body)
Definition messenger_api_message.c:555
get_message_body_kind_size
static uint16_t get_message_body_kind_size(enum GNUNET_MESSENGER_MessageKind kind)
Definition messenger_api_message.c:305
extract_access_message_key
enum GNUNET_GenericReturnValue extract_access_message_key(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_HpkePrivateKey *key, struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key)
Extracts the shared epoch or group key from an access message using the private ephemeral key from an...
Definition messenger_api_message.c:1951
encode_message
void encode_message(const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, enum GNUNET_GenericReturnValue include_header)
Encodes a given message into a buffer of a maximum length in bytes.
Definition messenger_api_message.c:877
get_message_timeout
struct GNUNET_TIME_Relative get_message_timeout(const struct GNUNET_MESSENGER_Message *message)
Return the relative timeout of the content from a given message that controls when a delayed handling...
Definition messenger_api_message.c:2029
is_service_message
enum GNUNET_GenericReturnValue is_service_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message contains service critical information.
Definition messenger_api_message.c:2130
verify_message_by_key
enum GNUNET_GenericReturnValue verify_message_by_key(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
Verifies the hmac of a given message body with a specific shared key.
Definition messenger_api_message.c:1541
pack_message
struct GNUNET_MQ_Envelope * pack_message(struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_PackMode mode)
Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_P...
Definition messenger_api_message.c:2068
get_message_body_size
static uint16_t get_message_body_size(enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET_MESSENGER_MessageBody *body)
Definition messenger_api_message.c:480
copy_message
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.
Definition messenger_api_message.c:99
sign_message_by_peer
struct GNUNET_PILS_Operation * sign_message_by_peer(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, struct GNUNET_PILS_Handle *pils, const GNUNET_PILS_SignResultCallback sign_cb, void *cls)
Signs the hash of a message with the peer identity of a given pils service going into a callback with...
Definition messenger_api_message.c:1353
fold_short_message
static void fold_short_message(const struct GNUNET_MESSENGER_Message *message, struct GNUNET_MESSENGER_ShortMessage *shortened)
Definition messenger_api_message.c:279
decode_step_key
#define decode_step_key(src, offset, dst, length)
Definition messenger_api_message.c:951
decode_step_hpke_key
#define decode_step_hpke_key(src, offset, dst, length)
Definition messenger_api_message.c:962
calc_padded_length
static uint16_t calc_padded_length(uint16_t length)
Definition messenger_api_message.c:595
filter_message_sending
enum GNUNET_GenericReturnValue filter_message_sending(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message should be sent by a client.
Definition messenger_api_message.c:2221
decode_step_malloc
#define decode_step_malloc(src, offset, dst, size, zero)
Definition messenger_api_message.c:945
encode_step
#define encode_step(dst, offset, src)
Definition messenger_api_message.c:628
verify_message
enum GNUNET_GenericReturnValue verify_message(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_CRYPTO_BlindablePublicKey *key)
Verifies the signature of a given message and its hash with a specific public key.
Definition messenger_api_message.c:1494
sign_message
void sign_message(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_CRYPTO_BlindablePrivateKey *key)
Signs the hash of a message with a given private key.
Definition messenger_api_message.c:1330
extract_authorization_message_key
enum GNUNET_GenericReturnValue extract_authorization_message_key(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_SymmetricSessionKey *key, struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key)
Extracts the shared epoch or group key from an authorization message using a previously exchanged sha...
Definition messenger_api_message.c:1984
decrypt_message
enum GNUNET_GenericReturnValue decrypt_message(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_HpkePrivateKey *hpke_key)
Decrypts a private message using a given private key and replaces its body and kind with the inner en...
Definition messenger_api_message.c:1642
encryption_overhead
const uint16_t encryption_overhead
Definition messenger_api_message.c:34
encode_message_body
static void encode_message_body(enum GNUNET_MESSENGER_MessageKind kind, const struct GNUNET_MESSENGER_MessageBody *body, uint16_t length, char *buffer, uint16_t offset)
Definition messenger_api_message.c:660
is_peer_message
enum GNUNET_GenericReturnValue is_peer_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message can be sent by the service without usage of a clients priv...
Definition messenger_api_message.c:2111
encode_short_message
static void encode_short_message(const struct GNUNET_MESSENGER_ShortMessage *message, uint16_t length, char *buffer)
Definition messenger_api_message.c:910
decode_short_message
static enum GNUNET_GenericReturnValue decode_short_message(struct GNUNET_MESSENGER_ShortMessage *message, uint16_t length, const char *buffer)
Definition messenger_api_message.c:1269
get_message_discourse
const struct GNUNET_ShortHashCode * get_message_discourse(const struct GNUNET_MESSENGER_Message *message)
Returns the discourse hash of a message depending on its kind.
Definition messenger_api_message.c:2293
sign_message_by_key
enum GNUNET_GenericReturnValue sign_message_by_key(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
Signs the message body via it's own hmac with a specific shared key.
Definition messenger_api_message.c:1460
is_epoch_message
enum GNUNET_GenericReturnValue is_epoch_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a certain kind of message from storage contains some specific details that might be r...
Definition messenger_api_message.c:2202
verify_message_by_peer
enum GNUNET_GenericReturnValue verify_message_by_peer(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_PeerIdentity *identity)
Verifies the signature of a given message and its hash with a specific peer's identity.
Definition messenger_api_message.c:1517
hash_message
void hash_message(const struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer, struct GNUNET_HashCode *hash)
Calculates a hash of a given buffer with a length in bytes from a message.
Definition messenger_api_message.c:1313
create_message
struct GNUNET_MESSENGER_Message * create_message(enum GNUNET_MESSENGER_MessageKind kind)
Creates and allocates a new message with a specific kind.
Definition messenger_api_message.c:50
decode_step_ext
#define decode_step_ext(src, offset, dst, size)
Definition messenger_api_message.c:936
unfold_short_message
static void unfold_short_message(struct GNUNET_MESSENGER_ShortMessage *shortened, struct GNUNET_MESSENGER_Message *message)
Definition messenger_api_message.c:290
encode_step_hpke_key
#define encode_step_hpke_key(dst, offset, src, length)
Definition messenger_api_message.c:641
encode_step_signature
#define encode_step_signature(dst, offset, src, length)
Definition messenger_api_message.c:650
calc_usual_padding
static uint16_t calc_usual_padding()
Definition messenger_api_message.c:572
decode_message_body
static uint16_t decode_message_body(enum GNUNET_MESSENGER_MessageKind *kind, struct GNUNET_MESSENGER_MessageBody *body, uint16_t length, const char *buffer, uint16_t offset)
Definition messenger_api_message.c:974
decrypt_secret_message
enum GNUNET_GenericReturnValue decrypt_secret_message(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
Decrypts a secret message using a given shared key and replaces its body and kind with the inner encr...
Definition messenger_api_message.c:1837
kind_t
uint32_t kind_t
Definition messenger_api_message.c:456
min
#define min(x, y)
Definition messenger_api_message.c:621
max
#define max(x, y)
Definition messenger_api_message.c:592
copy_message_header
void copy_message_header(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_MESSENGER_MessageHeader *header)
Copy message header details from another message to a given message.
Definition messenger_api_message.c:176
destroy_message
void destroy_message(struct GNUNET_MESSENGER_Message *message)
Destroys a message and frees its memory fully.
Definition messenger_api_message.c:252
get_message_kind_size
uint16_t get_message_kind_size(enum GNUNET_MESSENGER_MessageKind kind, enum GNUNET_GenericReturnValue include_header)
Returns the minimal size in bytes to encode a message of a specific kind.
Definition messenger_api_message.c:459
calc_message_hmac
static enum GNUNET_GenericReturnValue calc_message_hmac(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_SymmetricSessionKey *key, struct GNUNET_HashCode *hmac)
Definition messenger_api_message.c:1384
read_transcript_message
enum GNUNET_GenericReturnValue read_transcript_message(struct GNUNET_MESSENGER_Message *message)
Read the original message from a transcript message and replaces its body and kind with the inner enc...
Definition messenger_api_message.c:1925
encode_step_key
#define encode_step_key(dst, offset, src, length)
Definition messenger_api_message.c:632
is_message_session_bound
enum GNUNET_GenericReturnValue is_message_session_bound(const struct GNUNET_MESSENGER_Message *message)
Returns if the message should be bound to a member session.
Definition messenger_api_message.c:263
get_message_size
uint16_t get_message_size(const struct GNUNET_MESSENGER_Message *message, enum GNUNET_GenericReturnValue include_header)
Returns the exact size in bytes to encode a given message.
Definition messenger_api_message.c:534
decode_message
enum GNUNET_GenericReturnValue decode_message(struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer, enum GNUNET_GenericReturnValue include_header, uint16_t *padding)
Decodes a message from a given buffer of a maximum length in bytes.
Definition messenger_api_message.c:1204
transcribe_message
struct GNUNET_MESSENGER_Message * transcribe_message(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_BlindablePublicKey *key)
Transcribes a message as a new transcript message using a given public key from the recipient of the ...
Definition messenger_api_message.c:1707
encrypt_secret_message
enum GNUNET_GenericReturnValue encrypt_secret_message(struct GNUNET_MESSENGER_Message *message, const union GNUNET_MESSENGER_EpochIdentifier *identifier, const struct GNUNET_CRYPTO_SymmetricSessionKey *key)
Encrypts a message using a given shared key from an announcement of an epoch and replaces its body an...
Definition messenger_api_message.c:1748
member_size
#define member_size(type, member)
Definition messenger_api_message.c:302
cleanup_message
void cleanup_message(struct GNUNET_MESSENGER_Message *message)
Frees the messages body memory.
Definition messenger_api_message.c:243
messenger_api_message.h
GNUNET_MESSENGER_MAX_MESSAGE_SIZE
#define GNUNET_MESSENGER_MAX_MESSAGE_SIZE
Definition messenger_api_message.h:50
GNUNET_MESSENGER_PackMode
GNUNET_MESSENGER_PackMode
Definition messenger_api_message.h:59
GNUNET_MESSENGER_PACK_MODE_ENVELOPE
@ GNUNET_MESSENGER_PACK_MODE_ENVELOPE
Definition messenger_api_message.h:60
GNUNET_MESSENGER_PADDING_LEVEL0
#define GNUNET_MESSENGER_PADDING_LEVEL0
Definition messenger_api_message.h:54
GNUNET_MESSENGER_SALT_SECRET_KEY
#define GNUNET_MESSENGER_SALT_SECRET_KEY
Definition messenger_api_message.h:41
GNUNET_MESSENGER_PADDING_MIN
#define GNUNET_MESSENGER_PADDING_MIN
Definition messenger_api_message.h:53
GNUNET_MESSENGER_SALT_EPOCH_KEY
#define GNUNET_MESSENGER_SALT_EPOCH_KEY
Definition messenger_api_message.h:37
GNUNET_MESSENGER_SALT_ANNOUNCEMENT_KEY
#define GNUNET_MESSENGER_SALT_ANNOUNCEMENT_KEY
Definition messenger_api_message.h:35
GNUNET_MESSENGER_PADDING_LEVEL2
#define GNUNET_MESSENGER_PADDING_LEVEL2
Definition messenger_api_message.h:56
GNUNET_MESSENGER_PADDING_LEVEL1
#define GNUNET_MESSENGER_PADDING_LEVEL1
Definition messenger_api_message.h:55
GNUNET_MESSENGER_SALT_SECRET_IV
#define GNUNET_MESSENGER_SALT_SECRET_IV
Definition messenger_api_message.h:48
GNUNET_MESSENGER_SALT_GROUP_KEY
#define GNUNET_MESSENGER_SALT_GROUP_KEY
Definition messenger_api_message.h:39
GNUNET_CRYPTO_AuthKey
type for (message) authentication keys
Definition gnunet_crypto_lib.h:578
GNUNET_CRYPTO_BlindableKeySignature::type
uint32_t type
Type of signature.
Definition gnunet_crypto_lib.h:515
GNUNET_CRYPTO_BlindablePrivateKey
A private key for an identity as per LSD0001.
Definition gnunet_crypto_lib.h:411
GNUNET_CRYPTO_BlindablePublicKey
An identity key as per LSD0001.
Definition gnunet_crypto_lib.h:438
GNUNET_CRYPTO_HpkePrivateKey
A public key used for decryption.
Definition gnunet_crypto_lib.h:465
GNUNET_CRYPTO_HpkePublicKey
A public key used for encryption.
Definition gnunet_crypto_lib.h:488
GNUNET_CRYPTO_SignaturePurpose
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
Definition gnunet_crypto_lib.h:142
GNUNET_CRYPTO_SignaturePurpose::purpose
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
Definition gnunet_crypto_lib.h:156
GNUNET_CRYPTO_SignaturePurpose::size
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
Definition gnunet_crypto_lib.h:148
GNUNET_CRYPTO_SymmetricInitializationVector
IV for sym cipher.
Definition gnunet_crypto_lib.h:567
GNUNET_CRYPTO_SymmetricSessionKey
type for session keys
Definition gnunet_crypto_lib.h:535
GNUNET_HashCode
A 512-bit hashcode.
Definition gnunet_common.h:287
GNUNET_MESSENGER_MessageAccess::hmac
struct GNUNET_HashCode hmac
The hmac of the access.
Definition gnunet_messenger_service.h:996
GNUNET_MESSENGER_MessageAccess::event
struct GNUNET_HashCode event
The hash of the linked announcement or group message event.
Definition gnunet_messenger_service.h:986
GNUNET_MESSENGER_MessageAccess::key
uint8_t key[sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey)+16+sizeof(struct GNUNET_CRYPTO_HpkeEncapsulation)]
The encrypted group or epoch key.
Definition gnunet_messenger_service.h:991
GNUNET_MESSENGER_MessageAnnouncement::nonce
union GNUNET_MESSENGER_EpochNonce nonce
The nonce of the announcement.
Definition gnunet_messenger_service.h:897
GNUNET_MESSENGER_MessageAnnouncement::hmac
struct GNUNET_HashCode hmac
The hmac of the announcement.
Definition gnunet_messenger_service.h:907
GNUNET_MESSENGER_MessageAnnouncement::timeout
struct GNUNET_TIME_RelativeNBO timeout
The timeout of the announcement.
Definition gnunet_messenger_service.h:902
GNUNET_MESSENGER_MessageAnnouncement::identifier
union GNUNET_MESSENGER_EpochIdentifier identifier
The identifier of the announcement in an epoch.
Definition gnunet_messenger_service.h:887
GNUNET_MESSENGER_MessageAnnouncement::key
struct GNUNET_CRYPTO_EcdhePublicKey key
The public key to appeal access.
Definition gnunet_messenger_service.h:892
GNUNET_MESSENGER_MessageAppeal::key
struct GNUNET_CRYPTO_EcdhePublicKey key
The public key to receive access.
Definition gnunet_messenger_service.h:963
GNUNET_MESSENGER_MessageAppeal::timeout
struct GNUNET_TIME_RelativeNBO timeout
The timeout of the appeal.
Definition gnunet_messenger_service.h:968
GNUNET_MESSENGER_MessageAppeal::event
struct GNUNET_HashCode event
The hash of the linked announcement message event.
Definition gnunet_messenger_service.h:958
GNUNET_MESSENGER_MessageAuthorization::event
struct GNUNET_HashCode event
The hash of the linked group message event.
Definition gnunet_messenger_service.h:1071
GNUNET_MESSENGER_MessageAuthorization::identifier
union GNUNET_MESSENGER_EpochIdentifier identifier
The identifier of the group in an epoch.
Definition gnunet_messenger_service.h:1066
GNUNET_MESSENGER_MessageAuthorization::hmac
struct GNUNET_HashCode hmac
The hmac of the authorization.
Definition gnunet_messenger_service.h:1081
GNUNET_MESSENGER_MessageAuthorization::key
uint8_t key[sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey)]
The encrypted group or epoch key.
Definition gnunet_messenger_service.h:1076
GNUNET_MESSENGER_MessageBody
The unified body of a GNUNET_MESSENGER_Message.
Definition gnunet_messenger_service.h:1088
GNUNET_MESSENGER_MessageBody::announcement
struct GNUNET_MESSENGER_MessageAnnouncement announcement
Definition gnunet_messenger_service.h:1112
GNUNET_MESSENGER_MessageBody::group
struct GNUNET_MESSENGER_MessageGroup group
Definition gnunet_messenger_service.h:1117
GNUNET_MESSENGER_MessageBody::secret
struct GNUNET_MESSENGER_MessageSecret secret
Definition gnunet_messenger_service.h:1113
GNUNET_MESSENGER_MessageBody::deletion
struct GNUNET_MESSENGER_MessageDeletion deletion
Definition gnunet_messenger_service.h:1105
GNUNET_MESSENGER_MessageBody::privacy
struct GNUNET_MESSENGER_MessagePrivate privacy
Definition gnunet_messenger_service.h:1104
GNUNET_MESSENGER_MessageBody::connection
struct GNUNET_MESSENGER_MessageConnection connection
Definition gnunet_messenger_service.h:1106
GNUNET_MESSENGER_MessageBody::text
struct GNUNET_MESSENGER_MessageText text
Definition gnunet_messenger_service.h:1102
GNUNET_MESSENGER_MessageBody::request
struct GNUNET_MESSENGER_MessageRequest request
Definition gnunet_messenger_service.h:1100
GNUNET_MESSENGER_MessageBody::merge
struct GNUNET_MESSENGER_MessageMerge merge
Definition gnunet_messenger_service.h:1099
GNUNET_MESSENGER_MessageBody::id
struct GNUNET_MESSENGER_MessageId id
Definition gnunet_messenger_service.h:1097
GNUNET_MESSENGER_MessageBody::name
struct GNUNET_MESSENGER_MessageName name
Definition gnunet_messenger_service.h:1094
GNUNET_MESSENGER_MessageBody::leave
struct GNUNET_MESSENGER_MessageLeave leave
Definition gnunet_messenger_service.h:1093
GNUNET_MESSENGER_MessageBody::transcript
struct GNUNET_MESSENGER_MessageTranscript transcript
Definition gnunet_messenger_service.h:1108
GNUNET_MESSENGER_MessageBody::revolution
struct GNUNET_MESSENGER_MessageRevolution revolution
Definition gnunet_messenger_service.h:1116
GNUNET_MESSENGER_MessageBody::talk
struct GNUNET_MESSENGER_MessageTalk talk
Definition gnunet_messenger_service.h:1111
GNUNET_MESSENGER_MessageBody::file
struct GNUNET_MESSENGER_MessageFile file
Definition gnunet_messenger_service.h:1103
GNUNET_MESSENGER_MessageBody::tag
struct GNUNET_MESSENGER_MessageTag tag
Definition gnunet_messenger_service.h:1109
GNUNET_MESSENGER_MessageBody::key
struct GNUNET_MESSENGER_MessageKey key
Definition gnunet_messenger_service.h:1095
GNUNET_MESSENGER_MessageBody::invite
struct GNUNET_MESSENGER_MessageInvite invite
Definition gnunet_messenger_service.h:1101
GNUNET_MESSENGER_MessageBody::access
struct GNUNET_MESSENGER_MessageAccess access
Definition gnunet_messenger_service.h:1115
GNUNET_MESSENGER_MessageBody::subscription
struct GNUNET_MESSENGER_MessageSubscribtion subscription
Definition gnunet_messenger_service.h:1110
GNUNET_MESSENGER_MessageBody::authorization
struct GNUNET_MESSENGER_MessageAuthorization authorization
Definition gnunet_messenger_service.h:1118
GNUNET_MESSENGER_MessageBody::appeal
struct GNUNET_MESSENGER_MessageAppeal appeal
Definition gnunet_messenger_service.h:1114
GNUNET_MESSENGER_MessageBody::miss
struct GNUNET_MESSENGER_MessageMiss miss
Definition gnunet_messenger_service.h:1098
GNUNET_MESSENGER_MessageBody::peer
struct GNUNET_MESSENGER_MessagePeer peer
Definition gnunet_messenger_service.h:1096
GNUNET_MESSENGER_MessageBody::join
struct GNUNET_MESSENGER_MessageJoin join
Definition gnunet_messenger_service.h:1092
GNUNET_MESSENGER_MessageBody::ticket
struct GNUNET_MESSENGER_MessageTicket ticket
Definition gnunet_messenger_service.h:1107
GNUNET_MESSENGER_MessageBody::info
struct GNUNET_MESSENGER_MessageInfo info
Definition gnunet_messenger_service.h:1091
GNUNET_MESSENGER_MessageConnection::amount
uint32_t amount
The amount of connections of a peer.
Definition gnunet_messenger_service.h:758
GNUNET_MESSENGER_MessageConnection::flags
uint32_t flags
The flags about the connections of a peer.
Definition gnunet_messenger_service.h:763
GNUNET_MESSENGER_MessageDeletion::hash
struct GNUNET_HashCode hash
The hash of the message to delete.
Definition gnunet_messenger_service.h:739
GNUNET_MESSENGER_MessageDeletion::delay
struct GNUNET_TIME_RelativeNBO delay
The delay of the delete operation to get processed.
Definition gnunet_messenger_service.h:744
GNUNET_MESSENGER_MessageFile::uri
char * uri
The uri of the encrypted file.
Definition gnunet_messenger_service.h:706
GNUNET_MESSENGER_MessageFile::hash
struct GNUNET_HashCode hash
The hash of the original file.
Definition gnunet_messenger_service.h:696
GNUNET_MESSENGER_MessageFile::key
struct GNUNET_CRYPTO_SymmetricSessionKey key
The symmetric key to decrypt the file.
Definition gnunet_messenger_service.h:691
GNUNET_MESSENGER_MessageFile::name
char name[NAME_MAX]
The name of the original file.
Definition gnunet_messenger_service.h:701
GNUNET_MESSENGER_MessageGroup::timeout
struct GNUNET_TIME_RelativeNBO timeout
The timeout of the group formation.
Definition gnunet_messenger_service.h:1049
GNUNET_MESSENGER_MessageGroup::initiator
struct GNUNET_HashCode initiator
The hash of the initiator group announcement.
Definition gnunet_messenger_service.h:1039
GNUNET_MESSENGER_MessageGroup::identifier
union GNUNET_MESSENGER_EpochIdentifier identifier
The identifier of the group in an epoch.
Definition gnunet_messenger_service.h:1034
GNUNET_MESSENGER_MessageGroup::partner
struct GNUNET_HashCode partner
The hash of the partner group announcement.
Definition gnunet_messenger_service.h:1044
GNUNET_MESSENGER_MessageHeader
The header of a GNUNET_MESSENGER_Message.
Definition gnunet_messenger_service.h:456
GNUNET_MESSENGER_MessageHeader::previous
struct GNUNET_HashCode previous
The hash of the previous message from the senders perspective.
Definition gnunet_messenger_service.h:475
GNUNET_MESSENGER_MessageHeader::signature
struct GNUNET_CRYPTO_BlindableKeySignature signature
The signature of the senders private key.
Definition gnunet_messenger_service.h:460
GNUNET_MESSENGER_MessageHeader::kind
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
Definition gnunet_messenger_service.h:480
GNUNET_MESSENGER_MessageHeader::timestamp
struct GNUNET_TIME_AbsoluteNBO timestamp
The timestamp of the message.
Definition gnunet_messenger_service.h:465
GNUNET_MESSENGER_MessageHeader::sender_id
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
Definition gnunet_messenger_service.h:470
GNUNET_MESSENGER_MessageId::id
struct GNUNET_ShortHashCode id
The new id which will replace the senders id in a room.
Definition gnunet_messenger_service.h:597
GNUNET_MESSENGER_MessageInfo::messenger_version
uint32_t messenger_version
The version of GNUnet Messenger API.
Definition gnunet_messenger_service.h:498
GNUNET_MESSENGER_MessageInvite::key
union GNUNET_MESSENGER_RoomKey key
The hash identifying the port of the room.
Definition gnunet_messenger_service.h:663
GNUNET_MESSENGER_MessageInvite::door
struct GNUNET_PeerIdentity door
The peer identity of an open door to a room.
Definition gnunet_messenger_service.h:658
GNUNET_MESSENGER_MessageJoin::key
struct GNUNET_CRYPTO_BlindablePublicKey key
The senders blindable public key to verify its signatures.
Definition gnunet_messenger_service.h:517
GNUNET_MESSENGER_MessageJoin::epoch
struct GNUNET_HashCode epoch
The previous epoch the message was sent from.
Definition gnunet_messenger_service.h:512
GNUNET_MESSENGER_MessageJoin::hpke_key
struct GNUNET_CRYPTO_HpkePublicKey hpke_key
The senders HPKE public key to encrypt private messages with.
Definition gnunet_messenger_service.h:522
GNUNET_MESSENGER_MessageKey::key
struct GNUNET_CRYPTO_BlindablePublicKey key
The new blindable public key which replaces the current senders public key.
Definition gnunet_messenger_service.h:564
GNUNET_MESSENGER_MessageKey::hpke_key
struct GNUNET_CRYPTO_HpkePublicKey hpke_key
The new HPKE public key which replaces the current senders HPKE public key.
Definition gnunet_messenger_service.h:569
GNUNET_MESSENGER_MessageLeave::epoch
struct GNUNET_HashCode epoch
The previous epoch the message was sent from.
Definition gnunet_messenger_service.h:536
GNUNET_MESSENGER_MessageMerge::previous
struct GNUNET_HashCode previous
The hash of a second previous message.
Definition gnunet_messenger_service.h:630
GNUNET_MESSENGER_MessageMerge::epochs
struct GNUNET_HashCode epochs[2]
The previous epochs the message was sent from.
Definition gnunet_messenger_service.h:625
GNUNET_MESSENGER_MessageMiss::peer
struct GNUNET_PeerIdentity peer
The peer identity of a disconnected door to a room.
Definition gnunet_messenger_service.h:611
GNUNET_MESSENGER_MessageName::name
char * name
The new name which replaces the current senders name.
Definition gnunet_messenger_service.h:550
GNUNET_MESSENGER_MessagePeer::peer
struct GNUNET_PeerIdentity peer
The peer identity of the sender opening a room.
Definition gnunet_messenger_service.h:583
GNUNET_MESSENGER_MessagePrivate::length
uint16_t length
The length of the encrypted message.
Definition gnunet_messenger_service.h:720
GNUNET_MESSENGER_MessagePrivate::data
char * data
The data of the encrypted message.
Definition gnunet_messenger_service.h:725
GNUNET_MESSENGER_MessageRequest::hash
struct GNUNET_HashCode hash
The hash of the requested message.
Definition gnunet_messenger_service.h:644
GNUNET_MESSENGER_MessageRevolution::identifier
union GNUNET_MESSENGER_EpochIdentifier identifier
The identifier of the announcement in an epoch.
Definition gnunet_messenger_service.h:1010
GNUNET_MESSENGER_MessageRevolution::nonce
union GNUNET_MESSENGER_EpochNonce nonce
The nonce of the revolution.
Definition gnunet_messenger_service.h:1015
GNUNET_MESSENGER_MessageRevolution::hmac
struct GNUNET_HashCode hmac
The hmac of the revolution.
Definition gnunet_messenger_service.h:1020
GNUNET_MESSENGER_MessageSecret::iv
uint8_t iv[sizeof(struct GNUNET_CRYPTO_SymmetricInitializationVector)]
The IV of the secret message.
Definition gnunet_messenger_service.h:929
GNUNET_MESSENGER_MessageSecret::identifier
union GNUNET_MESSENGER_EpochIdentifier identifier
The identifier of the announcement in an epoch.
Definition gnunet_messenger_service.h:924
GNUNET_MESSENGER_MessageSecret::data
char * data
The data of the encrypted message.
Definition gnunet_messenger_service.h:944
GNUNET_MESSENGER_MessageSecret::hmac
struct GNUNET_HashCode hmac
The hmac of the encrypted message.
Definition gnunet_messenger_service.h:934
GNUNET_MESSENGER_MessageSecret::length
uint16_t length
The length of the encrypted message.
Definition gnunet_messenger_service.h:939
GNUNET_MESSENGER_MessageSignature
Definition messenger_api_message.c:38
GNUNET_MESSENGER_MessageSignature::hash
struct GNUNET_HashCode hash
Definition messenger_api_message.c:40
GNUNET_MESSENGER_MessageSignature::purpose
struct GNUNET_CRYPTO_SignaturePurpose purpose
Definition messenger_api_message.c:39
GNUNET_MESSENGER_MessageSubscribtion::flags
uint32_t flags
The flags about the subscription to a discourse.
Definition gnunet_messenger_service.h:849
GNUNET_MESSENGER_MessageSubscribtion::time
struct GNUNET_TIME_RelativeNBO time
The time window of the subscription.
Definition gnunet_messenger_service.h:844
GNUNET_MESSENGER_MessageSubscribtion::discourse
struct GNUNET_ShortHashCode discourse
The hash of the discourse to subscription.
Definition gnunet_messenger_service.h:839
GNUNET_MESSENGER_MessageTag::tag
char * tag
The custom tag.
Definition gnunet_messenger_service.h:825
GNUNET_MESSENGER_MessageTag::hash
struct GNUNET_HashCode hash
The hash of the message to tag.
Definition gnunet_messenger_service.h:820
GNUNET_MESSENGER_MessageTalk::length
uint16_t length
The length of the talk message data.
Definition gnunet_messenger_service.h:868
GNUNET_MESSENGER_MessageTalk::data
char * data
The data of the talk message.
Definition gnunet_messenger_service.h:873
GNUNET_MESSENGER_MessageTalk::discourse
struct GNUNET_ShortHashCode discourse
The hash of the discourse to talk.
Definition gnunet_messenger_service.h:863
GNUNET_MESSENGER_MessageText::text
char * text
The containing text.
Definition gnunet_messenger_service.h:677
GNUNET_MESSENGER_MessageTicket::identifier
char * identifier
The identifier of a ticket.
Definition gnunet_messenger_service.h:777
GNUNET_MESSENGER_MessageTranscript::length
uint16_t length
The length of the transcribed message.
Definition gnunet_messenger_service.h:801
GNUNET_MESSENGER_MessageTranscript::hash
struct GNUNET_HashCode hash
The hash of the original message.
Definition gnunet_messenger_service.h:791
GNUNET_MESSENGER_MessageTranscript::key
struct GNUNET_CRYPTO_BlindablePublicKey key
The key from the recipient of the original message.
Definition gnunet_messenger_service.h:796
GNUNET_MESSENGER_MessageTranscript::data
char * data
The data of the transcribed message.
Definition gnunet_messenger_service.h:806
GNUNET_MESSENGER_Message
Struct to a message.
Definition gnunet_messenger_service.h:1126
GNUNET_MESSENGER_Message::header
struct GNUNET_MESSENGER_MessageHeader header
Header.
Definition gnunet_messenger_service.h:1130
GNUNET_MESSENGER_Message::body
struct GNUNET_MESSENGER_MessageBody body
Body.
Definition gnunet_messenger_service.h:1135
GNUNET_MESSENGER_ShortMessage
Definition messenger_api_message.c:44
GNUNET_MESSENGER_ShortMessage::body
struct GNUNET_MESSENGER_MessageBody body
Definition messenger_api_message.c:46
GNUNET_MESSENGER_ShortMessage::kind
enum GNUNET_MESSENGER_MessageKind kind
Definition messenger_api_message.c:45
GNUNET_MQ_Envelope
Definition mq.c:34
GNUNET_MessageHeader
Header for all communications.
Definition gnunet_common.h:323
GNUNET_PILS_Handle
A handle for the PILS service.
Definition pils_api.c:82
GNUNET_PILS_Operation
Definition pils_api.c:48
GNUNET_PeerIdentity
The identity of the host (wraps the signing key of the peer).
Definition gnunet_crypto_lib.h:230
GNUNET_ShortHashCode
A 256-bit hashcode.
Definition gnunet_common.h:297
GNUNET_TIME_Absolute
Time for absolute times used by GNUnet, in microseconds.
Definition gnunet_time_lib.h:54
GNUNET_TIME_Relative
Time for relative time used by GNUnet, in microseconds.
Definition gnunet_time_lib.h:79
GNUNET_MESSENGER_EpochIdentifier
An epoch identifier unifies an epoch identifier code and its 256bit hash representation.
Definition gnunet_messenger_service.h:158