src/identity-provider/identity_token.h

   1 /*
   2    This file is part of GNUnet.
   3    Copyright (C) 2012-2015 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., 51 Franklin Street, Fifth Floor,
  18    Boston, MA 02110-1301, USA.
  19    */
  20 /**
  21  * @author Martin Schanzenbach
  22  * @file include/gnunet_identity_provider_lib.h
  23  * @brief GNUnet Identity Provider library
  24  *
  25  */
  26 #ifndef IDENTITY_TOKEN_H
  27 #define IDENTITY_TOKEN_H
  28
  29 #include "gnunet_crypto_lib.h"
  30 #include <jansson.h>
  31
  32 struct IdentityToken
  33 {
  34   /**
  35    * DLL
  36    */
  37   struct TokenAttr *attr_head;
  38
  39   /**
  40    * DLL
  41    */
  42   struct TokenAttr *attr_tail;
  43
  44   /**
  45    * Token Signature
  46    */
  47   struct GNUNET_CRYPTO_EcdsaSignature signature;
  48
  49   /**
  50    * Audience Pubkey
  51    */
  52   struct GNUNET_CRYPTO_EcdsaPublicKey aud_key;
  53 };
  54
  55 struct TokenAttr
  56 {
  57   /**
  58    * DLL
  59    */
  60   struct TokenAttr *next;
  61
  62   /**
  63    * DLL
  64    */
  65   struct TokenAttr *prev;
  66
  67   /**
  68    * Attribute name
  69    */
  70   char *name;
  71
  72   /**
  73    * Attribute value DLL
  74    */
  75   struct TokenAttrValue *val_head;
  76
  77   /**
  78    * Attribute value DLL
  79    */
  80   struct TokenAttrValue *val_tail;
  81
  82 };
  83
  84 struct TokenAttrValue
  85 {
  86   /**
  87    * DLL
  88    */
  89   struct TokenAttrValue *next;
  90
  91   /**
  92    * DLL
  93    */
  94   struct TokenAttrValue *prev;
  95
  96   /**
  97    * Attribute value
  98    */
  99   char *value;
 100 };
 101
 102 struct TokenTicketPayload
 103 {
 104   /**
 105    * Nonce
 106    */
 107   char* nonce;
 108
 109   /**
 110    * Label
 111    */
 112   char *label;
 113
 114   /**
 115    * Issuing Identity
 116    */
 117   struct GNUNET_CRYPTO_EcdsaPublicKey identity_key;
 118 };
 119
 120
 121 struct TokenTicket
 122 {
 123   /**
 124    * Meta info
 125    */
 126   struct TokenTicketPayload *payload;
 127
 128   /**
 129    * ECDH Pubkey
 130    */
 131   struct GNUNET_CRYPTO_EcdhePublicKey ecdh_pubkey;
 132
 133   /**
 134    * Signature
 135    */
 136   struct GNUNET_CRYPTO_EcdsaSignature signature;
 137
 138   /**
 139    * Target identity
 140    */
 141   struct GNUNET_CRYPTO_EcdsaPublicKey aud_key;
 142 };
 143
 144
 145
 146 /**
 147  * Create an identity token
 148  *
 149  * @param iss the issuer string for the token
 150  * @param aud the audience of the token
 151  *
 152  * @return a new token
 153  */
 154 struct IdentityToken*
 155 token_create (const struct GNUNET_CRYPTO_EcdsaPublicKey *iss,
 156                                        const struct GNUNET_CRYPTO_EcdsaPublicKey* aud);
 157
 158 /**
 159  * Destroy an identity token
 160  *
 161  * @param token the token to destroy
 162  */
 163 void
 164 token_destroy (struct IdentityToken*token);
 165
 166 /**
 167  * Add a new key value pair to the token
 168  *
 169  * @param token the token to modify
 170  * @param key the key
 171  * @param value the value
 172  */
 173 void
 174 token_add_attr (struct IdentityToken *token,
 175                 const char* key,
 176                 const char* value);
 177
 178 /**
 179  * Add a value to a TokenAttribute
 180  *
 181  * @param attr the token attribute
 182  * @param value value to add
 183  */
 184   void
 185   token_attr_add_value (const struct TokenAttr *attr,
 186                         const char *value);
 187
 188 /**
 189  * Add a new key value pair to the token with the value as json
 190  *
 191  * @param the token to modify
 192  * @param key the key
 193  * @param value the value
 194  *
 195  */
 196 void
 197 token_add_json (const struct IdentityToken *token,
 198                 const char* key,
 199                 json_t* value);
 200
 201 /**
 202  * Serialize a token. The token will be signed and base64 according to the
 203  * JWT format. The signature is base32-encoded ECDSA.
 204  * The resulting JWT is encrypted using
 205  * ECDHE for the audience and Base64
 206  * encoded in result. The audience requires the ECDHE public key P
 207  * to decrypt the token T. The key P is included in the result and prepended
 208  * before the token
 209  *
 210  * @param token the token to serialize
 211  * @param priv_key the private key used to sign the token
 212  * @param ecdhe_privkey the ECDHE private key used to encrypt the token
 213  * @param result P,Base64(E(T))
 214  *
 215  * @return GNUNET_OK on success
 216  */
 217 int
 218 token_serialize (const struct IdentityToken*token,
 219                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 220                  struct GNUNET_CRYPTO_EcdhePrivateKey **ecdhe_privkey,
 221                  char **result);
 222
 223 /**
 224  * Parses the serialized token and returns a token
 225  *
 226  * @param data the serialized token
 227  * @param priv_key the private key of the audience
 228  * @param result the token
 229  *
 230  * @return GNUNET_OK on success
 231  */
 232   int
 233   token_parse (const char* data,
 234                const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 235                struct IdentityToken **result);
 236
 237 /**
 238  * Parses the serialized token and returns a token
 239  * This variant is intended for the party that issued the token and also
 240  * wants to decrypt the serialized token.
 241  *
 242  * @param data the serialized token
 243  * @param priv_key the private (!) ECDHE key
 244  * @param aud_key the identity of the audience
 245  * @param result the token
 246  *
 247  * @return GNUNET_OK on success
 248  */
 249 int
 250 token_parse2 (const char* data,
 251               const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_key,
 252               const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key,
 253               struct IdentityToken **result);
 254
 255
 256 /**
 257  *
 258  * Returns a JWT-string representation of the token
 259  *
 260  * @param token the token
 261  * @param priv_key the private key used to sign the JWT
 262  * @param result the JWT
 263  *
 264  * @return GNUNET_OK on success
 265  */
 266 int
 267 token_to_string (const struct IdentityToken *token,
 268                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 269                  char **result);
 270
 271 /**
 272  *
 273  * Creates a ticket that can be exchanged by the audience for
 274  * the token. The token must be placed under the label
 275  *
 276  * @param nonce_str nonce provided by the audience that requested the ticket
 277  * @param iss_pkey the issuer pubkey used to sign the ticket
 278  * @param label the label encoded in the ticket
 279  * @param aud_ley the audience pubkey used to encrypt the ticket payload
 280  *
 281  * @return the ticket
 282  */
 283 struct TokenTicket*
 284 ticket_create (const char* nonce_str,
 285                const struct GNUNET_CRYPTO_EcdsaPublicKey* iss_pkey,
 286                const char* lbl_str,
 287                const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key);
 288
 289 /**
 290  * Serialize a ticket. Returns the Base64 representation of the ticket.
 291  * Format: Base64( { payload: E(Payload), ecdhe: K, signature: signature } )
 292  *
 293  * @param ticket the ticket to serialize
 294  * @param priv_key the issuer private key to sign the ticket payload
 295  * @param result the serialized ticket
 296  *
 297  * @return GNUNET_OK on success
 298  */
 299 int
 300 ticket_serialize (struct TokenTicket *ticket,
 301                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 302                   char **result);
 303
 304 /**
 305  * Destroys a ticket
 306  *
 307  * @param the ticket to destroy
 308  */
 309 void
 310 ticket_destroy (struct TokenTicket *ticket);
 311
 312 /**
 313  * Parses a serialized ticket
 314  *
 315  * @param data the serialized ticket
 316  * @param priv_key the audience private key
 317  * @param ticket the ticket
 318  *
 319  * @return GNUNET_OK on success
 320  */
 321 int
 322 ticket_parse (const char* raw_data,
 323               const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
 324               struct TokenTicket **ticket);
 325
 326 #endif