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    * Sender's ephemeral public ECC key (always for NIST P-521) encoded in a
 126    * format suitable for network transmission, as created
 127    * using 'gcry_sexp_sprint'.
 128    */
 129   struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
 130
 131   /**
 132    * Sender's next ephemeral public ECC key (always for NIST P-521) encoded in a
 133    * format suitable for network transmission, as created
 134    * using 'gcry_sexp_sprint'.
 135    */
 136   struct GNUNET_CRYPTO_EcdhePublicKey ratchet_key;
 137 };
 138
 139
 140 /**
 141  * Message transmitted with the signed ephemeral key of a peer.  The
 142  * session key is then derived from the two ephemeral keys (ECDHE).
 143  *
 144  * As far as possible, same as CORE's EphemeralKeyMessage.
 145  */
 146 struct GNUNET_CADET_KX_Ephemeral
 147 {
 148
 149   /**
 150    * Message type is GNUNET_MESSAGE_TYPE_CADET_KX_EPHEMERAL.
 151    */
 152   struct GNUNET_MessageHeader header;
 153
 154   /**
 155    * Status of the sender (should be in "enum PeerStateMachine"), nbo.
 156    */
 157   int32_t sender_status GNUNET_PACKED;
 158
 159   /**
 160    * An ECC signature of the 'origin' asserting the validity of
 161    * the given ephemeral key.
 162    */
 163   struct GNUNET_CRYPTO_EddsaSignature signature;
 164
 165   /**
 166    * Information about what is being signed.
 167    */
 168   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 169
 170   /**
 171    * At what time was this key created (beginning of validity).
 172    */
 173   struct GNUNET_TIME_AbsoluteNBO creation_time;
 174
 175   /**
 176    * When does the given ephemeral key expire (end of validity).
 177    */
 178   struct GNUNET_TIME_AbsoluteNBO expiration_time;
 179
 180   /**
 181    * Ephemeral public ECC key (always for NIST P-521) encoded in a format
 182    * suitable for network transmission as created using 'gcry_sexp_sprint'.
 183    */
 184   struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
 185
 186   /**
 187    * Public key of the signing peer
 188    * (persistent version, not the ephemeral public key).
 189    */
 190   struct GNUNET_PeerIdentity origin_identity;
 191
 192   /**
 193    * Seed for the IV of nonce.
 194    */
 195   uint32_t iv GNUNET_PACKED;
 196
 197   /**
 198    * Nonce to check liveness of peer.
 199    */
 200   uint32_t nonce GNUNET_PACKED;
 201 };
 202
 203
 204 /**
 205  * Response to a PING.  Includes data from the original PING.
 206  */
 207 struct GNUNET_CADET_KX_Pong
 208 {
 209   /**
 210    * Message type is GNUNET_MESSAGE_TYPE_CADET_KX_PONG.
 211    */
 212   struct GNUNET_MessageHeader header;
 213
 214   /**
 215    * Seed for the IV
 216    */
 217   uint32_t iv GNUNET_PACKED;
 218
 219   /**
 220    * Same nonce as in the reve.
 221    */
 222   uint32_t nonce GNUNET_PACKED;
 223 };
 224
 225
 226 /**
 227  * Tunnel(ed) message.
 228  */
 229 struct GNUNET_CADET_Encrypted
 230 {
 231   /**
 232    * Type: GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED
 233    */
 234   struct GNUNET_MessageHeader header;
 235
 236   /**
 237    * ID of the connection.
 238    */
 239   struct GNUNET_CADET_Hash cid;
 240
 241   /**
 242    * ID of the packet (hop by hop).
 243    */
 244   uint32_t pid GNUNET_PACKED;
 245
 246   /**
 247    * Number of hops to live.
 248    */
 249   uint32_t ttl GNUNET_PACKED;
 250
 251   /**
 252    * Initialization Vector for payload encryption.
 253    */
 254   uint32_t iv GNUNET_PACKED;
 255
 256   /**
 257    * MAC of the encrypted message, used to verify message integrity.
 258    * Everything after this value  will be encrypted and authenticated.
 259    */
 260   struct GNUNET_CADET_Hash hmac;
 261
 262   /**
 263    * Encrypted content follows.
 264    */
 265 };
 266
 267
 268 /**
 269  * Axolotl tunnel message.
 270  */
 271 struct GNUNET_CADET_AX
 272 {
 273   /**
 274    * Type: GNUNET_MESSAGE_TYPE_CADET_AXOLOTL_DATA
 275    */
 276   struct GNUNET_MessageHeader header;
 277
 278   /**
 279    * ID of the connection.
 280    */
 281   struct GNUNET_CADET_Hash cid;
 282
 283   /**
 284    * ID of the packet (hop by hop).
 285    */
 286   uint32_t pid GNUNET_PACKED;
 287
 288   /**
 289    * Number of hops to live.
 290    */
 291   uint32_t ttl GNUNET_PACKED;
 292
 293   /**
 294    * Initialization Vector for payload encryption.
 295    */
 296   uint32_t iv GNUNET_PACKED;
 297
 298   /**
 299    * MAC of the encrypted message, used to verify message integrity.
 300    * Everything after this value  will be encrypted and authenticated.
 301    */
 302   struct GNUNET_CADET_Hash hmac;
 303
 304   /**
 305    * Encrypted content follows.
 306    */
 307 };
 308
 309
 310 /**
 311  * Message to create a Channel.
 312  */
 313 struct GNUNET_CADET_ChannelCreate
 314 {
 315   /**
 316    * Type: GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE
 317    */
 318   struct GNUNET_MessageHeader header;
 319
 320   /**
 321    * ID of the channel
 322    */
 323   CADET_ChannelNumber chid GNUNET_PACKED;
 324
 325   /**
 326    * Destination port.
 327    */
 328   uint32_t port GNUNET_PACKED;
 329
 330   /**
 331    * Channel options.
 332    */
 333   uint32_t opt GNUNET_PACKED;
 334 };
 335
 336
 337 /**
 338  * Message to manage a Channel (ACK, NACK, Destroy).
 339  */
 340 struct GNUNET_CADET_ChannelManage
 341 {
 342   /**
 343    * Type: GNUNET_MESSAGE_TYPE_CADET_CHANNEL_{ACK|NACK|DESTROY}
 344    */
 345   struct GNUNET_MessageHeader header;
 346
 347   /**
 348    * ID of the channel
 349    */
 350   CADET_ChannelNumber chid GNUNET_PACKED;
 351 };
 352
 353
 354 /**
 355  * Message for cadet data traffic.
 356  */
 357 struct GNUNET_CADET_Data
 358 {
 359     /**
 360      * Type: GNUNET_MESSAGE_TYPE_CADET_UNICAST,
 361      *       GNUNET_MESSAGE_TYPE_CADET_TO_ORIGIN
 362      */
 363   struct GNUNET_MessageHeader header;
 364
 365     /**
 366      * Unique ID of the payload message
 367      */
 368   uint32_t mid GNUNET_PACKED;
 369
 370     /**
 371      * ID of the channel
 372      */
 373   CADET_ChannelNumber chid GNUNET_PACKED;
 374
 375     /**
 376      * Payload follows
 377      */
 378 };
 379
 380
 381 /**
 382  * Message to acknowledge end-to-end data.
 383  */
 384 struct GNUNET_CADET_DataACK
 385 {
 386   /**
 387    * Type: GNUNET_MESSAGE_TYPE_CADET_DATA_ACK
 388    */
 389   struct GNUNET_MessageHeader header;
 390
 391   /**
 392    * ID of the channel
 393    */
 394   CADET_ChannelNumber chid GNUNET_PACKED;
 395
 396   /**
 397    * Bitfield of already-received newer messages
 398    * pid +  1 @ LSB
 399    * pid + 64 @ MSB
 400    */
 401   uint64_t futures GNUNET_PACKED;
 402
 403   /**
 404    * Last message ID received.
 405    */
 406   uint32_t mid GNUNET_PACKED;
 407 };
 408
 409
 410 /**
 411  * Message to acknowledge cadet encrypted traffic.
 412  */
 413 struct GNUNET_CADET_ACK
 414 {
 415     /**
 416      * Type: GNUNET_MESSAGE_TYPE_CADET_ACK
 417      */
 418   struct GNUNET_MessageHeader header;
 419
 420     /**
 421      * Maximum packet ID authorized.
 422      */
 423   uint32_t ack GNUNET_PACKED;
 424
 425     /**
 426      * ID of the connection.
 427      */
 428   struct GNUNET_CADET_Hash cid;
 429 };
 430
 431
 432 /**
 433  * Message to query a peer about its Flow Control status regarding a tunnel.
 434  */
 435 struct GNUNET_CADET_Poll
 436 {
 437     /**
 438      * Type: GNUNET_MESSAGE_TYPE_CADET_POLL
 439      */
 440   struct GNUNET_MessageHeader header;
 441
 442     /**
 443      * Last packet sent.
 444      */
 445   uint32_t pid GNUNET_PACKED;
 446
 447     /**
 448      * ID of the connection.
 449      */
 450   struct GNUNET_CADET_Hash cid;
 451
 452 };
 453
 454
 455 /**
 456  * Message for notifying a disconnection in a path
 457  */
 458 struct GNUNET_CADET_ConnectionBroken
 459 {
 460     /**
 461      * Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
 462      */
 463   struct GNUNET_MessageHeader header;
 464
 465     /**
 466      * ID of the connection.
 467      */
 468   struct GNUNET_CADET_Hash cid;
 469
 470     /**
 471      * ID of the endpoint
 472      */
 473   struct GNUNET_PeerIdentity peer1;
 474
 475     /**
 476      * ID of the endpoint
 477      */
 478   struct GNUNET_PeerIdentity peer2;
 479 };
 480
 481
 482 /**
 483  * Message to destroy a connection.
 484  */
 485 struct GNUNET_CADET_ConnectionDestroy
 486 {
 487     /**
 488      * Type: GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY
 489      */
 490   struct GNUNET_MessageHeader header;
 491
 492     /**
 493      * ID of the connection.
 494      */
 495   struct GNUNET_CADET_Hash cid;
 496 };
 497
 498
 499 GNUNET_NETWORK_STRUCT_END
 500
 501 #if 0                           /* keep Emacsens' auto-indent happy */
 502 {
 503 #endif
 504 #ifdef __cplusplus
 505 }
 506 #endif
 507
 508 /* ifndef CADET_PROTOCOL_H */
 509 #endif
 510 /* end of cadet_protocol.h */