aboutsummaryrefslogtreecommitdiff
path: root/src/cadet/cadet_protocol.h
blob: 6b8a033ea23017f68139cf9c567c27b4f8ee66fd (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
/*
     This file is part of GNUnet.
     Copyright (C) 2007 - 2017 GNUnet e.V.

     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
*/

/**
 * @file cadet/cadet_protocol.h
 * @brief P2P messages used by CADET
 * @author Bartlomiej Polot
 * @author Christian Grothoff
 */

#ifndef CADET_PROTOCOL_H_
#define CADET_PROTOCOL_H_

/**
 * At best, enable when debugging #5328!
 */
#define DEBUG_KX 0
#if DEBUG_KX
#warning NEVER run this in production! KX debugging is on!
#endif

#include "platform.h"
#include "gnunet_util_lib.h"
#include "cadet.h"

#ifdef __cplusplus

struct GNUNET_CADET_TunnelMessage;
extern "C"
{
#if 0
  /* keep Emacsens' auto-indent happy */
}
#endif
#endif

/******************************************************************************/
/********************      CADET NETWORK MESSAGES     **************************/
/******************************************************************************/

GNUNET_NETWORK_STRUCT_BEGIN


/******************************************************************************/
/*****************************   CONNECTION  **********************************/
/******************************************************************************/


/**
 * Message for cadet connection creation.
 */
struct GNUNET_CADET_ConnectionCreateMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE
   *
   * Size: sizeof (struct GNUNET_CADET_ConnectionCreateMessage) +
   *       path_length * sizeof (struct GNUNET_PeerIdentity)
   */
  struct GNUNET_MessageHeader header;

  /**
   * Connection options in network byte order.
   * #GNUNET_CADET_OPTION_DEFAULT for buffered;
   * #GNUNET_CADET_OPTION_NOBUFFER for unbuffered.
   * Other flags are ignored and should not be set at this level.
   */
  uint32_t options GNUNET_PACKED;

  /**
   * ID of the connection
   */
  struct GNUNET_CADET_ConnectionTunnelIdentifier cid;

  /**
   * path_length structs defining the *whole* path from the origin [0] to the
   * final destination [path_length-1].
   */
  /* struct GNUNET_PeerIdentity peers[path_length]; */
};


/**
 * Message for ack'ing a connection
 */
struct GNUNET_CADET_ConnectionCreateAckMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK
   */
  struct GNUNET_MessageHeader header;

  /**
   * For alignment.
   */
  uint32_t reserved GNUNET_PACKED;

  /**
   * ID of the connection.
   */
  struct GNUNET_CADET_ConnectionTunnelIdentifier cid;

};


/**
 * Message for notifying a disconnection in a path
 */
struct GNUNET_CADET_ConnectionBrokenMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN.
   */
  struct GNUNET_MessageHeader header;

  /**
   * For alignment.
   */
  uint32_t reserved GNUNET_PACKED;

  /**
   * ID of the connection.
   */
  struct GNUNET_CADET_ConnectionTunnelIdentifier cid;

  /**
   * ID of the endpoint
   */
  struct GNUNET_PeerIdentity peer1;

  /**
   * ID of the endpoint
   */
  struct GNUNET_PeerIdentity peer2;
};


/**
 * Message to destroy a connection.
 */
struct GNUNET_CADET_ConnectionDestroyMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY
   */
  struct GNUNET_MessageHeader header;

  /**
   * For alignment.
   */
  uint32_t reserved GNUNET_PACKED;

  /**
   * ID of the connection.
   */
  struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
};


/******************************************************************************/
/*******************************   TUNNEL   ***********************************/
/******************************************************************************/

/**
 * Unique identifier (counter) for an encrypted message in a channel.
 * Used to match #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_HOP_BY_HOP_ENCRYPTED_ACK
 * and  #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED_POLL messages
 * against the respective  #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED
 * messages.
 */
struct CadetEncryptedMessageIdentifier
{
  /**
   * This number is incremented by one per message. It may wrap around.
   * In network byte order.
   */
  uint32_t pid GNUNET_PACKED;
};


/**
 * Flags to be used in GNUNET_CADET_KX.
 */
enum GNUNET_CADET_KX_Flags {

  /**
   * Should the peer reply with its KX details?
   */
  GNUNET_CADET_KX_FLAG_NONE = 0,

  /**
   * The peer should reply with its KX details?
   */
  GNUNET_CADET_KX_FLAG_FORCE_REPLY = 1
};


/**
 * Message for a Key eXchange for a tunnel.
 */
struct GNUNET_CADET_TunnelKeyExchangeMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX or
   * #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH as part
   * of `struct GNUNET_CADET_TunnelKeyExchangeAuthMessage`.
   */
  struct GNUNET_MessageHeader header;

  /**
   * Flags for the key exchange in NBO, based on
   * `enum GNUNET_CADET_KX_Flags`.
   */
  uint32_t flags GNUNET_PACKED;

  /**
   * ID of the connection.
   */
  struct GNUNET_CADET_ConnectionTunnelIdentifier cid;

  /**
   * Sender's ephemeral public ECC key encoded in a
   * format suitable for network transmission, as created
   * using 'gcry_sexp_sprint'.
   */
  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;

#if DEBUG_KX
  /**
   * Sender's ephemeral public ECC key encoded in a
   * format suitable for network transmission, as created
   * using 'gcry_sexp_sprint'.
   */
  struct GNUNET_CRYPTO_EcdhePrivateKey ephemeral_key_XXX; // for debugging KX-crypto!

  /**
   * Sender's ephemeral public ECC key encoded in a
   * format suitable for network transmission, as created
   * using 'gcry_sexp_sprint'.
   */
  struct GNUNET_CRYPTO_EddsaPrivateKey private_key_XXX; // for debugging KX-crypto!
#endif

  /**
   * Sender's next ephemeral public ECC key encoded in a
   * format suitable for network transmission, as created
   * using 'gcry_sexp_sprint'.
   */
  struct GNUNET_CRYPTO_EcdhePublicKey ratchet_key;

};


/**
 * Message for a Key eXchange for a tunnel, with authentication.
 * Used as a response to the initial KX as well as for rekeying.
 */
struct GNUNET_CADET_TunnelKeyExchangeAuthMessage
{

  /**
   * Message header with key material.
   */
  struct GNUNET_CADET_TunnelKeyExchangeMessage kx;

#if DEBUG_KX
  /**
   * Received ephemeral public ECC key encoded in a
   * format suitable for network transmission, as created
   * using 'gcry_sexp_sprint'.
   */
  struct GNUNET_CRYPTO_EcdhePublicKey r_ephemeral_key_XXX; // for debugging KX-crypto!
#endif

  /**
   * KDF-proof that sender could compute the 3-DH, used in lieu of a
   * signature or payload data.
   */
  struct GNUNET_HashCode auth;

};


/**
 * Encrypted axolotl header with numbers that identify which
 * keys in which ratchet are to be used to decrypt the body.
 */
struct GNUNET_CADET_AxHeader
{

  /**
   * Number of messages sent with the current ratchet key.
   */
  uint32_t Ns GNUNET_PACKED;

  /**
   * Number of messages sent with the previous ratchet key.
   */
  uint32_t PNs GNUNET_PACKED;

  /**
   * Current ratchet key.
   */
  struct GNUNET_CRYPTO_EcdhePublicKey DHRs;

};


/**
 * Axolotl-encrypted tunnel message with application payload.
 */
struct GNUNET_CADET_TunnelEncryptedMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED
   */
  struct GNUNET_MessageHeader header;

  /**
   * Reserved, for alignment.
   */
  uint32_t reserved GNUNET_PACKED;

  /**
   * ID of the connection.
   */
  struct GNUNET_CADET_ConnectionTunnelIdentifier cid;

  /**
   * MAC of the encrypted message, used to verify message integrity.
   * Everything after this value  will be encrypted with the header key
   * and authenticated.
   */
  struct GNUNET_ShortHashCode hmac;

  /**
   * Axolotl-header that specifies which keys to use in which ratchet
   * to decrypt the body that follows.
   */
  struct GNUNET_CADET_AxHeader ax_header;

  /**
   * Encrypted content follows.
   */
};


/******************************************************************************/
/*******************************   CHANNEL  ***********************************/
/******************************************************************************/


/**
 * Message to create a Channel.
 */
struct GNUNET_CADET_ChannelOpenMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN
   */
  struct GNUNET_MessageHeader header;

  /**
   * Channel options.
   */
  uint32_t opt GNUNET_PACKED;

  /**
   * Hash of destination port and listener.
   */
  struct GNUNET_HashCode h_port;

  /**
   * ID of the channel within the tunnel.
   */
  struct GNUNET_CADET_ChannelTunnelNumber ctn;
};


/**
 * Message to acknowledge opening a channel of type
 * #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK.
 */
struct GNUNET_CADET_ChannelOpenAckMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK
   */
  struct GNUNET_MessageHeader header;

  /**
   * For alignment.
   */
  uint32_t reserved GNUNET_PACKED;

  /**
   * ID of the channel
   */
  struct GNUNET_CADET_ChannelTunnelNumber ctn;

  /**
   * Port number of the channel, used to prove to the
   * initiator that the receiver knows the port.
   */
  struct GNUNET_HashCode port;
};


/**
 * Message to destroy a channel of type
 * #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY.
 */
struct GNUNET_CADET_ChannelDestroyMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY
   */
  struct GNUNET_MessageHeader header;

  /**
   * For alignment.
   */
  uint32_t reserved GNUNET_PACKED;

  /**
   * ID of the channel
   */
  struct GNUNET_CADET_ChannelTunnelNumber ctn;
};


/**
 * Number used to uniquely identify messages in a CADET Channel.
 */
struct ChannelMessageIdentifier
{
  /**
   * Unique ID of the message, cycles around, in NBO.
   */
  uint32_t mid GNUNET_PACKED;
};


/**
 * Message for cadet data traffic.
 */
struct GNUNET_CADET_ChannelAppDataMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA.
   */
  struct GNUNET_MessageHeader header;

  /**
   * Unique ID of the payload message.
   */
  struct ChannelMessageIdentifier mid;

  /**
   * ID of the channel
   */
  struct GNUNET_CADET_ChannelTunnelNumber ctn;

  /**
   * Payload follows
   */
};


/**
 * Message to acknowledge end-to-end data.
 */
struct GNUNET_CADET_ChannelDataAckMessage
{
  /**
   * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK
   */
  struct GNUNET_MessageHeader header;

  /**
   * ID of the channel
   */
  struct GNUNET_CADET_ChannelTunnelNumber ctn;

  /**
   * Bitfield of already-received newer messages.  Note that bit 0
   * corresponds to @e mid + 1.
   *
   * pid +  0 @ LSB
   * pid + 63 @ MSB
   */
  uint64_t futures GNUNET_PACKED;

  /**
   * Next message ID expected.
   */
  struct ChannelMessageIdentifier mid;
};


GNUNET_NETWORK_STRUCT_END

#if 0                           /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif

/* ifndef CADET_PROTOCOL_H */
#endif
/* end of cadet_protocol.h */