src/scalarproduct/scalarproduct.h

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010, 2011, 2012, 2013 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  * @file   scalarproduct.h
  23  * @brief  Scalar Product Message Types
  24  * @author Christian M. Fuchs
  25  *
  26  * Created on September 2, 2013, 3:43 PM
  27  */
  28
  29 #ifndef SCALARPRODUCT_H
  30 #define SCALARPRODUCT_H
  31
  32 #ifdef  __cplusplus
  33 extern "C"
  34 {
  35 #endif
  36 ///////////////////////////////////////////////////////////////////////////////
  37 //                      Defines
  38 ///////////////////////////////////////////////////////////////////////////////
  39 /**
  40  * Length of the key used for encryption
  41  */
  42 #define KEYBITS 2048
  43
  44 /**
  45  * When performing our crypto, we may add two encrypted values with each
  46  * a maximal length of GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH.
  47  * thus we can receive a slightly longer element (+1 byte)
  48  */
  49 #define PAILLIER_ELEMENT_LENGTH (2*KEYBITS/8 +1)
  50
  51 /**
  52  * Maximum count of elements we can put into a multipart message
  53  */
  54 #define MULTIPART_ELEMENT_CAPACITY ((GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct GNUNET_SCALARPRODUCT_multipart_message)) / PAILLIER_ELEMENT_LENGTH)
  55
  56 /**
  57  * Log an error message at log-level 'level' that indicates
  58  * a failure of the command 'cmd' with the message given
  59  * by gcry_strerror(rc).
  60  */
  61 #define LOG_GCRY(level, cmd, rc) do { LOG(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while(0)
  62
  63 ///////////////////////////////////////////////////////////////////////////////
  64 //                     Scalar Product Message Types
  65 ///////////////////////////////////////////////////////////////////////////////
  66
  67 /**
  68  * Message type passed from client to service
  69  * to initiate a request or responder role
  70  */
  71 struct GNUNET_SCALARPRODUCT_client_request
  72 {
  73   /**
  74    * GNUNET message header
  75    */
  76   struct GNUNET_MessageHeader header;
  77
  78   /**
  79    * how many elements the vector in payload contains
  80    */
  81   uint32_t element_count GNUNET_PACKED;
  82
  83   /**
  84    * how many bytes the mask has
  85    */
  86   uint32_t mask_length GNUNET_PACKED;
  87
  88   /**
  89    * the transaction/session key used to identify a session
  90    */
  91   struct GNUNET_HashCode key;
  92
  93   /**
  94    * the identity of a remote peer we want to communicate with
  95    */
  96   struct GNUNET_PeerIdentity peer;
  97
  98   /**
  99    * followed by long vector[element_count] | [unsigned char mask[mask_bytes]]
 100    */
 101 };
 102
 103 /**
 104  * Message type passed from requesting service Alice to responding service Bob
 105  * to initiate a request and make bob participate in our protocol
 106  */
 107 struct GNUNET_SCALARPRODUCT_service_request {
 108   /**
 109    * GNUNET message header
 110    */
 111   struct GNUNET_MessageHeader header;
 112
 113   /**
 114    * how many elements the total message including all multipart msgs contains
 115    */
 116   uint32_t total_element_count GNUNET_PACKED;
 117
 118     /**
 119    * how many elements are actually included after the mask was applied.
 120    */
 121   uint32_t contained_element_count GNUNET_PACKED;
 122
 123   /**
 124    * how many bytes the mask has
 125    */
 126   uint32_t mask_length GNUNET_PACKED;
 127
 128   /**
 129    * the length of the publickey contained within this message
 130    */
 131   uint32_t pk_length GNUNET_PACKED;
 132
 133   /**
 134    * the transaction/session key used to identify a session
 135    */
 136   struct GNUNET_HashCode key;
 137
 138   /**
 139    * how many elements the vector in payload contains
 140    */
 141   uint32_t element_count GNUNET_PACKED;
 142
 143   /**
 144    * followed by mask | public_key | vector[used_element_count]
 145    */
 146 };
 147
 148 /**
 149  * Multipart Message type passed between to supply additional elements for the peer
 150  */
 151 struct GNUNET_SCALARPRODUCT_multipart_message {
 152   /**
 153    * GNUNET message header
 154    */
 155   struct GNUNET_MessageHeader header;
 156
 157   /**
 158    * how many elements we supply within this message
 159    */
 160   uint32_t multipart_element_count GNUNET_PACKED;
 161
 162   // followed by vector[multipart_element_count] or k[i][perm]
 163 };
 164
 165 /**
 166  * Message type passed from responding service Bob to responding service Alice
 167  * to complete a request and allow Alice to compute the result
 168  */
 169 struct GNUNET_SCALARPRODUCT_service_response {
 170   /**
 171    * GNUNET message header
 172    */
 173   struct GNUNET_MessageHeader header;
 174
 175   /**
 176    * how many elements the session input had
 177    */
 178   uint32_t total_element_count GNUNET_PACKED;
 179
 180   /**
 181    * how many elements were included after the mask was applied including all multipart msgs.
 182    */
 183   uint32_t used_element_count GNUNET_PACKED;
 184
 185   /**
 186    * how many elements this individual message delivers
 187    */
 188   uint32_t contained_element_count GNUNET_PACKED;
 189
 190   /**
 191    * the transaction/session key used to identify a session
 192    */
 193   struct GNUNET_HashCode key;
 194
 195   /**
 196    * followed by s | s' | k[i][perm]
 197    */
 198 };
 199
 200 /**
 201  * Message type passed from service client
 202  * to finalize a session as requester or responder
 203  */
 204 struct GNUNET_SCALARPRODUCT_client_response
 205 {
 206   /**
 207    * GNUNET message header
 208    */
 209   struct GNUNET_MessageHeader header;
 210
 211   /**
 212    * 0 if no product attached
 213    */
 214   uint32_t product_length GNUNET_PACKED;
 215
 216   /**
 217    * the transaction/session key used to identify a session
 218    */
 219   struct GNUNET_HashCode key;
 220
 221   /**
 222    * the identity of a remote peer we want to communicate with
 223    */
 224   struct GNUNET_PeerIdentity peer;
 225
 226   /**
 227    * Workaround for libgcrypt: -1 if negative, 0 if zero, else 1
 228    */
 229   int8_t range;
 230
 231   /**
 232    * followed by product of length product_length (or nothing)
 233    */
 234 };
 235
 236 #ifdef  __cplusplus
 237 }
 238 #endif
 239
 240 #endif  /* SCALARPRODUCT_H */
 241