src/cadet/cadet_protocol.h

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2001 - 2011 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @author Bartlomiej Polot
  23  * @file cadet/cadet_protocol.h
  24  */
  25
  26 #ifndef CADET_PROTOCOL_H_
  27 #define CADET_PROTOCOL_H_
  28
  29 #include "platform.h"
  30 #include "gnunet_util_lib.h"
  31 #include "cadet.h"
  32
  33 #ifdef __cplusplus
  34
  35 struct GNUNET_CADET_TunnelMessage;
  36 extern "C"
  37 {
  38 #if 0
  39   /* keep Emacsens' auto-indent happy */
  40 }
  41 #endif
  42 #endif
  43
  44 /******************************************************************************/
  45 /********************      CADET NETWORK MESSAGES     **************************/
  46 /******************************************************************************/
  47
  48 GNUNET_NETWORK_STRUCT_BEGIN
  49
  50 /**
  51  * Message for cadet connection creation.
  52  */
  53 struct GNUNET_CADET_ConnectionCreate
  54 {
  55     /**
  56      * Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE
  57      *
  58      * Size: sizeof (struct GNUNET_CADET_ConnectionCreate) +
  59      *       path_length * sizeof (struct GNUNET_PeerIdentity)
  60      */
  61   struct GNUNET_MessageHeader header;
  62
  63     /**
  64      * ID of the connection
  65      */
  66   struct GNUNET_CADET_Hash cid;
  67
  68     /**
  69      * path_length structs defining the *whole* path from the origin [0] to the
  70      * final destination [path_length-1].
  71      */
  72   /* struct GNUNET_PeerIdentity peers[path_length]; */
  73 };
  74
  75
  76 /**
  77  * Message for ack'ing a connection
  78  */
  79 struct GNUNET_CADET_ConnectionACK
  80 {
  81     /**
  82      * Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK
  83      */
  84   struct GNUNET_MessageHeader header;
  85
  86     /**
  87      * ID of the connection.
  88      */
  89   struct GNUNET_CADET_Hash cid;
  90
  91 };
  92
  93
  94 /**
  95  * Message for encapsulation of a Key eXchange message in a connection.
  96  */
  97 struct GNUNET_CADET_KX
  98 {
  99     /**
 100      * Type: GNUNET_MESSAGE_TYPE_CADET_KX.
 101      */
 102   struct GNUNET_MessageHeader header;
 103
 104     /**
 105      * ID of the connection.
 106      */
 107   struct GNUNET_CADET_Hash cid;
 108
 109   /* Specific KX message follows. */
 110 };
 111
 112
 113
 114 /**
 115  * Message for encapsulation of a Key eXchange message in a connection.
 116  */
 117 struct GNUNET_CADET_AX_KX
 118 {
 119   /**
 120    * Type: GNUNET_MESSAGE_TYPE_CADET_AX_KX.
 121    */
 122   struct GNUNET_MessageHeader header;
 123
 124   /**
 125    * An EdDSA signature of the permanent ECDH key with the Peer's ID key.
 126    */
 127   struct GNUNET_CRYPTO_EddsaSignature signature;
 128
 129   /**
 130    * Information about what is being signed (@a permanent_key).
 131    */
 132   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 133
 134   /**
 135    * Sender's permanent_key public ECC key encoded in a
 136    * format suitable for network transmission, as created
 137    * using 'gcry_sexp_sprint'.
 138    */
 139   struct GNUNET_CRYPTO_EcdhePublicKey permanent_key;
 140
 141   /**
 142    * Sender's ephemeral public ECC key encoded in a
 143    * format suitable for network transmission, as created
 144    * using 'gcry_sexp_sprint'.
 145    */
 146   struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
 147
 148   /**
 149    * Sender's next ephemeral public ECC key encoded in a
 150    * format suitable for network transmission, as created
 151    * using 'gcry_sexp_sprint'.
 152    */
 153   struct GNUNET_CRYPTO_EcdhePublicKey ratchet_key;
 154 };
 155
 156
 157 /**
 158  * Message transmitted with the signed ephemeral key of a peer.  The
 159  * session key is then derived from the two ephemeral keys (ECDHE).
 160  *
 161  * As far as possible, same as CORE's EphemeralKeyMessage.
 162  */
 163 struct GNUNET_CADET_KX_Ephemeral
 164 {
 165
 166   /**
 167    * Message type is GNUNET_MESSAGE_TYPE_CADET_KX_EPHEMERAL.
 168    */
 169   struct GNUNET_MessageHeader header;
 170
 171   /**
 172    * Status of the sender (should be in "enum PeerStateMachine"), nbo.
 173    */
 174   int32_t sender_status GNUNET_PACKED;
 175
 176   /**
 177    * An ECC signature of the 'origin' asserting the validity of
 178    * the given ephemeral key.
 179    */
 180   struct GNUNET_CRYPTO_EddsaSignature signature;
 181
 182   /**
 183    * Information about what is being signed.
 184    */
 185   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 186
 187   /**
 188    * At what time was this key created (beginning of validity).
 189    */
 190   struct GNUNET_TIME_AbsoluteNBO creation_time;
 191
 192   /**
 193    * When does the given ephemeral key expire (end of validity).
 194    */
 195   struct GNUNET_TIME_AbsoluteNBO expiration_time;
 196
 197   /**
 198    * Ephemeral public ECC key (always for NIST P-521) encoded in a format
 199    * suitable for network transmission as created using 'gcry_sexp_sprint'.
 200    */
 201   struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
 202
 203   /**
 204    * Public key of the signing peer
 205    * (persistent version, not the ephemeral public key).
 206    */
 207   struct GNUNET_PeerIdentity origin_identity;
 208
 209   /**
 210    * Seed for the IV of nonce.
 211    */
 212   uint32_t iv GNUNET_PACKED;
 213
 214   /**
 215    * Nonce to check liveness of peer.
 216    */
 217   uint32_t nonce GNUNET_PACKED;
 218 };
 219
 220
 221 /**
 222  * Response to a PING.  Includes data from the original PING.
 223  */
 224 struct GNUNET_CADET_KX_Pong
 225 {
 226   /**
 227    * Message type is GNUNET_MESSAGE_TYPE_CADET_KX_PONG.
 228    */
 229   struct GNUNET_MessageHeader header;
 230
 231   /**
 232    * Seed for the IV
 233    */
 234   uint32_t iv GNUNET_PACKED;
 235
 236   /**
 237    * Same nonce as in the reve.
 238    */
 239   uint32_t nonce GNUNET_PACKED;
 240 };
 241
 242
 243 /**
 244  * Tunnel(ed) message.
 245  */
 246 struct GNUNET_CADET_Encrypted
 247 {
 248   /**
 249    * Type: GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED
 250    */
 251   struct GNUNET_MessageHeader header;
 252
 253   /**
 254    * ID of the connection.
 255    */
 256   struct GNUNET_CADET_Hash cid;
 257
 258   /**
 259    * ID of the packet (hop by hop).
 260    */
 261   uint32_t pid GNUNET_PACKED;
 262
 263   /**
 264    * Number of hops to live.
 265    */
 266   uint32_t ttl GNUNET_PACKED;
 267
 268   /**
 269    * Initialization Vector for payload encryption.
 270    */
 271   uint32_t iv GNUNET_PACKED;
 272
 273   /**
 274    * MAC of the encrypted message, used to verify message integrity.
 275    * Everything after this value  will be encrypted and authenticated.
 276    */
 277   struct GNUNET_CADET_Hash hmac;
 278
 279   /**
 280    * Encrypted content follows.
 281    */
 282 };
 283
 284
 285 /**
 286  * Axolotl tunnel message.
 287  */
 288 struct GNUNET_CADET_AX
 289 {
 290   /**
 291    * Type: GNUNET_MESSAGE_TYPE_CADET_AXOLOTL_DATA
 292    */
 293   struct GNUNET_MessageHeader header;
 294
 295   /**
 296    * ID of the connection.
 297    */
 298   struct GNUNET_CADET_Hash cid;
 299
 300   /**
 301    * ID of the packet (hop by hop).
 302    */
 303   uint32_t pid GNUNET_PACKED;
 304
 305   /**
 306    * Number of hops to live.
 307    */
 308   uint32_t ttl GNUNET_PACKED;
 309
 310   /**
 311    * Initialization Vector for payload encryption.
 312    */
 313   uint32_t iv GNUNET_PACKED;
 314
 315   /**
 316    * MAC of the encrypted message, used to verify message integrity.
 317    * Everything after this value  will be encrypted and authenticated.
 318    */
 319   struct GNUNET_CADET_Hash hmac;
 320
 321   /**
 322    * Encrypted content follows.
 323    */
 324 };
 325
 326
 327 /**
 328  * Message to create a Channel.
 329  */
 330 struct GNUNET_CADET_ChannelCreate
 331 {
 332   /**
 333    * Type: GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE
 334    */
 335   struct GNUNET_MessageHeader header;
 336
 337   /**
 338    * ID of the channel
 339    */
 340   CADET_ChannelNumber chid GNUNET_PACKED;
 341
 342   /**
 343    * Destination port.
 344    */
 345   uint32_t port GNUNET_PACKED;
 346
 347   /**
 348    * Channel options.
 349    */
 350   uint32_t opt GNUNET_PACKED;
 351 };
 352
 353
 354 /**
 355  * Message to manage a Channel (ACK, NACK, Destroy).
 356  */
 357 struct GNUNET_CADET_ChannelManage
 358 {
 359   /**
 360    * Type: GNUNET_MESSAGE_TYPE_CADET_CHANNEL_{ACK|NACK|DESTROY}
 361    */
 362   struct GNUNET_MessageHeader header;
 363
 364   /**
 365    * ID of the channel
 366    */
 367   CADET_ChannelNumber chid GNUNET_PACKED;
 368 };
 369
 370
 371 /**
 372  * Message for cadet data traffic.
 373  */
 374 struct GNUNET_CADET_Data
 375 {
 376     /**
 377      * Type: GNUNET_MESSAGE_TYPE_CADET_UNICAST,
 378      *       GNUNET_MESSAGE_TYPE_CADET_TO_ORIGIN
 379      */
 380   struct GNUNET_MessageHeader header;
 381
 382     /**
 383      * Unique ID of the payload message
 384      */
 385   uint32_t mid GNUNET_PACKED;
 386
 387     /**
 388      * ID of the channel
 389      */
 390   CADET_ChannelNumber chid GNUNET_PACKED;
 391
 392     /**
 393      * Payload follows
 394      */
 395 };
 396
 397
 398 /**
 399  * Message to acknowledge end-to-end data.
 400  */
 401 struct GNUNET_CADET_DataACK
 402 {
 403   /**
 404    * Type: GNUNET_MESSAGE_TYPE_CADET_DATA_ACK
 405    */
 406   struct GNUNET_MessageHeader header;
 407
 408   /**
 409    * ID of the channel
 410    */
 411   CADET_ChannelNumber chid GNUNET_PACKED;
 412
 413   /**
 414    * Bitfield of already-received newer messages
 415    * pid +  1 @ LSB
 416    * pid + 64 @ MSB
 417    */
 418   uint64_t futures GNUNET_PACKED;
 419
 420   /**
 421    * Last message ID received.
 422    */
 423   uint32_t mid GNUNET_PACKED;
 424 };
 425
 426
 427 /**
 428  * Message to acknowledge cadet encrypted traffic.
 429  */
 430 struct GNUNET_CADET_ACK
 431 {
 432     /**
 433      * Type: GNUNET_MESSAGE_TYPE_CADET_ACK
 434      */
 435   struct GNUNET_MessageHeader header;
 436
 437     /**
 438      * Maximum packet ID authorized.
 439      */
 440   uint32_t ack GNUNET_PACKED;
 441
 442     /**
 443      * ID of the connection.
 444      */
 445   struct GNUNET_CADET_Hash cid;
 446 };
 447
 448
 449 /**
 450  * Message to query a peer about its Flow Control status regarding a tunnel.
 451  */
 452 struct GNUNET_CADET_Poll
 453 {
 454     /**
 455      * Type: GNUNET_MESSAGE_TYPE_CADET_POLL
 456      */
 457   struct GNUNET_MessageHeader header;
 458
 459     /**
 460      * Last packet sent.
 461      */
 462   uint32_t pid GNUNET_PACKED;
 463
 464     /**
 465      * ID of the connection.
 466      */
 467   struct GNUNET_CADET_Hash cid;
 468
 469 };
 470
 471
 472 /**
 473  * Message for notifying a disconnection in a path
 474  */
 475 struct GNUNET_CADET_ConnectionBroken
 476 {
 477     /**
 478      * Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
 479      */
 480   struct GNUNET_MessageHeader header;
 481
 482     /**
 483      * ID of the connection.
 484      */
 485   struct GNUNET_CADET_Hash cid;
 486
 487     /**
 488      * ID of the endpoint
 489      */
 490   struct GNUNET_PeerIdentity peer1;
 491
 492     /**
 493      * ID of the endpoint
 494      */
 495   struct GNUNET_PeerIdentity peer2;
 496 };
 497
 498
 499 /**
 500  * Message to destroy a connection.
 501  */
 502 struct GNUNET_CADET_ConnectionDestroy
 503 {
 504     /**
 505      * Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY
 506      */
 507   struct GNUNET_MessageHeader header;
 508
 509     /**
 510      * ID of the connection.
 511      */
 512   struct GNUNET_CADET_Hash cid;
 513 };
 514
 515
 516 GNUNET_NETWORK_STRUCT_END
 517
 518 #if 0                           /* keep Emacsens' auto-indent happy */
 519 {
 520 #endif
 521 #ifdef __cplusplus
 522 }
 523 #endif
 524
 525 /* ifndef CADET_PROTOCOL_H */
 526 #endif
 527 /* end of cadet_protocol.h */