src/include/gnunet_identity_provider_service.h

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2016 GNUnet e.V.
   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 /**
  22  * @author Martin Schanzenbach
  23  *
  24  * @file
  25  * Identity provider service; implements identity provider for GNUnet
  26  *
  27  * @defgroup identity-provider  Identity Provider service
  28  * @{
  29  */
  30 #ifndef GNUNET_IDENTITY_PROVIDER_SERVICE_H
  31 #define GNUNET_IDENTITY_PROVIDER_SERVICE_H
  32
  33 #ifdef __cplusplus
  34 extern "C"
  35 {
  36 #if 0                           /* keep Emacsens' auto-indent happy */
  37 }
  38 #endif
  39 #endif
  40
  41 #include "gnunet_util_lib.h"
  42 #include "gnunet_identity_attribute_lib.h"
  43
  44 /**
  45  * Version number of GNUnet Identity Provider API.
  46  */
  47 #define GNUNET_IDENTITY_PROVIDER_VERSION 0x00000000
  48
  49 /**
  50  * Handle to access the identity service.
  51  */
  52 struct GNUNET_IDENTITY_PROVIDER_Handle;
  53
  54 /**
  55  * Handle for a token.
  56  */
  57 struct GNUNET_IDENTITY_PROVIDER_Token;
  58
  59 /**
  60  * The ticket
  61  */
  62 struct GNUNET_IDENTITY_PROVIDER_Ticket
  63 {
  64   /**
  65    * The ticket issuer
  66    */
  67   struct GNUNET_CRYPTO_EcdsaPublicKey identity;
  68
  69   /**
  70    * The ticket audience
  71    */
  72   struct GNUNET_CRYPTO_EcdsaPublicKey audience;
  73
  74   /**
  75    * The ticket random (NBO)
  76    */
  77   uint64_t rnd;
  78 };
  79
  80 /**
  81  * Handle for an operation with the identity provider service.
  82  */
  83 struct GNUNET_IDENTITY_PROVIDER_Operation;
  84
  85
  86 /**
  87  * Connect to the identity provider service.
  88  *
  89  * @param cfg Configuration to contact the identity provider service.
  90  * @return handle to communicate with identity provider service
  91  */
  92 struct GNUNET_IDENTITY_PROVIDER_Handle *
  93 GNUNET_IDENTITY_PROVIDER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg);
  94
  95 /**
  96  * Continuation called to notify client about result of the
  97  * operation.
  98  *
  99  * @param cls closure
 100  * @param success #GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate)
 101  *                #GNUNET_NO if content was already there or not found
 102  *                #GNUNET_YES (or other positive value) on success
 103  * @param emsg NULL on success, otherwise an error message
 104  */
 105 typedef void
 106 (*GNUNET_IDENTITY_PROVIDER_ContinuationWithStatus) (void *cls,
 107                                             int32_t success,
 108                                             const char *emsg);
 109
 110
 111 /**
 112  * Store an attribute.  If the attribute is already present,
 113  * it is replaced with the new attribute.
 114  *
 115  * @param h handle to the identity provider
 116  * @param pkey private key of the identity
 117  * @param attr the attribute
 118  * @param exp_interval the relative expiration interval for the attribute
 119  * @param cont continuation to call when done
 120  * @param cont_cls closure for @a cont
 121  * @return handle to abort the request
 122  */
 123 struct GNUNET_IDENTITY_PROVIDER_Operation *
 124 GNUNET_IDENTITY_PROVIDER_attribute_store (struct GNUNET_IDENTITY_PROVIDER_Handle *h,
 125                                           const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
 126                                           const struct GNUNET_IDENTITY_ATTRIBUTE_Claim *attr,
 127                                           const struct GNUNET_TIME_Relative *exp_interval,
 128                                           GNUNET_IDENTITY_PROVIDER_ContinuationWithStatus cont,
 129                                           void *cont_cls);
 130
 131
 132 /**
 133  * Process an attribute that was stored in the idp.
 134  *
 135  * @param cls closure
 136  * @param identity the identity
 137  * @param attr the attribute
 138  */
 139 typedef void
 140 (*GNUNET_IDENTITY_PROVIDER_AttributeResult) (void *cls,
 141                                    const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
 142                                    const struct GNUNET_IDENTITY_ATTRIBUTE_Claim *attr);
 143
 144
 145
 146 /**
 147  * List all attributes for a local identity.
 148  * This MUST lock the `struct GNUNET_IDENTITY_PROVIDER_Handle`
 149  * for any other calls than #GNUNET_IDENTITY_PROVIDER_get_attributes_next() and
 150  * #GNUNET_IDENTITY_PROVIDER_get_attributes_stop. @a proc will be called once
 151  * immediately, and then again after
 152  * #GNUNET_IDENTITY_PROVIDER_get_attributes_next() is invoked.
 153  *
 154  * On error (disconnect), @a error_cb will be invoked.
 155  * On normal completion, @a finish_cb proc will be
 156  * invoked.
 157  *
 158  * @param h handle to the idp
 159  * @param identity identity to access
 160  * @param error_cb function to call on error (i.e. disconnect),
 161  *        the handle is afterwards invalid
 162  * @param error_cb_cls closure for @a error_cb
 163  * @param proc function to call on each attribute; it
 164  *        will be called repeatedly with a value (if available)
 165  * @param proc_cls closure for @a proc
 166  * @param finish_cb function to call on completion
 167  *        the handle is afterwards invalid
 168  * @param finish_cb_cls closure for @a finish_cb
 169  * @return an iterator handle to use for iteration
 170  */
 171 struct GNUNET_IDENTITY_PROVIDER_AttributeIterator *
 172 GNUNET_IDENTITY_PROVIDER_get_attributes_start (struct GNUNET_IDENTITY_PROVIDER_Handle *h,
 173                                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
 174                                                GNUNET_SCHEDULER_TaskCallback error_cb,
 175                                                void *error_cb_cls,
 176                                                GNUNET_IDENTITY_PROVIDER_AttributeResult proc,
 177                                                void *proc_cls,
 178                                                GNUNET_SCHEDULER_TaskCallback finish_cb,
 179                                                void *finish_cb_cls);
 180
 181
 182 /**
 183  * Calls the record processor specified in #GNUNET_IDENTITY_PROVIDER_get_attributes_start
 184  * for the next record.
 185  *
 186  * @param it the iterator
 187  */
 188 void
 189 GNUNET_IDENTITY_PROVIDER_get_attributes_next (struct GNUNET_IDENTITY_PROVIDER_AttributeIterator *it);
 190
 191
 192 /**
 193  * Stops iteration and releases the idp handle for further calls.  Must
 194  * be called on any iteration that has not yet completed prior to calling
 195  * #GNUNET_IDENTITY_PROVIDER_disconnect.
 196  *
 197  * @param it the iterator
 198  */
 199 void
 200 GNUNET_IDENTITY_PROVIDER_get_attributes_stop (struct GNUNET_IDENTITY_PROVIDER_AttributeIterator *it);
 201
 202
 203 /**
 204  * Method called when a token has been issued.
 205  * On success returns a ticket that can be given to the audience to retrive the
 206  * token
 207  *
 208  * @param cls closure
 209  * @param ticket the ticket
 210  */
 211 typedef void
 212 (*GNUNET_IDENTITY_PROVIDER_TicketCallback)(void *cls,
 213                             const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket);
 214
 215 /**
 216  * Issues a ticket to another identity. The identity may use
 217  * GNUNET_IDENTITY_PROVIDER_ticket_consume to consume the ticket
 218  * and retrieve the attributes specified in the AttributeList.
 219  *
 220  * @param h the identity provider to use
 221  * @param iss the issuing identity
 222  * @param rp the subject of the ticket (the relying party)
 223  * @param attrs the attributes that the relying party is given access to
 224  * @param cb the callback
 225  * @param cb_cls the callback closure
 226  * @return handle to abort the operation
 227  */
 228 struct GNUNET_IDENTITY_PROVIDER_Operation *
 229 GNUNET_IDENTITY_PROVIDER_ticket_issue (struct GNUNET_IDENTITY_PROVIDER_Handle *h,
 230                                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss,
 231                                        const struct GNUNET_CRYPTO_EcdsaPublicKey *rp,
 232                                        const struct GNUNET_IDENTITY_ATTRIBUTE_ClaimList *attrs,
 233                                        GNUNET_IDENTITY_PROVIDER_TicketCallback cb,
 234                                        void *cb_cls);
 235
 236 /**
 237  * Revoked an issued ticket. The relying party will be unable to retrieve
 238  * updated attributes.
 239  *
 240  * @param h the identity provider to use
 241  * @param identity the issuing identity
 242  * @param ticket the ticket to revoke
 243  * @param cb the callback
 244  * @param cb_cls the callback closure
 245  * @return handle to abort the operation
 246  */
 247 struct GNUNET_IDENTITY_PROVIDER_Operation *
 248 GNUNET_IDENTITY_PROVIDER_ticket_revoke (struct GNUNET_IDENTITY_PROVIDER_Handle *h,
 249                                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
 250                                         const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket,
 251                                         GNUNET_IDENTITY_PROVIDER_ContinuationWithStatus cb,
 252                                         void *cb_cls);
 253
 254
 255
 256 /**
 257  * Consumes an issued ticket. The ticket is persisted
 258  * and used to retrieve identity information from the issuer
 259  *
 260  * @param h the identity provider to use
 261  * @param identity the identity that is the subject of the issued ticket (the audience)
 262  * @param ticket the issued ticket to consume
 263  * @param cb the callback to call
 264  * @param cb_cls the callback closure
 265  * @return handle to abort the operation
 266  */
 267 struct GNUNET_IDENTITY_PROVIDER_Operation *
 268 GNUNET_IDENTITY_PROVIDER_ticket_consume (struct GNUNET_IDENTITY_PROVIDER_Handle *h,
 269                                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
 270                                          const struct GNUNET_IDENTITY_PROVIDER_Ticket *ticket,
 271                                          GNUNET_IDENTITY_PROVIDER_AttributeResult cb,
 272                                          void *cb_cls);
 273
 274 /**
 275  * Lists all tickets that have been issued to remote
 276  * identites (relying parties)
 277  *
 278  * @param h the identity provider to use
 279  * @param identity the issuing identity
 280  * @param error_cb function to call on error (i.e. disconnect),
 281  *        the handle is afterwards invalid
 282  * @param error_cb_cls closure for @a error_cb
 283  * @param proc function to call on each ticket; it
 284  *        will be called repeatedly with a value (if available)
 285  * @param proc_cls closure for @a proc
 286  * @param finish_cb function to call on completion
 287  *        the handle is afterwards invalid
 288  * @param finish_cb_cls closure for @a finish_cb
 289  * @return an iterator handle to use for iteration
 290  */
 291 struct GNUNET_IDENTITY_PROVIDER_TicketIterator *
 292 GNUNET_IDENTITY_PROVIDER_ticket_iteration_start (struct GNUNET_IDENTITY_PROVIDER_Handle *h,
 293                                                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
 294                                                  GNUNET_SCHEDULER_TaskCallback error_cb,
 295                                                  void *error_cb_cls,
 296                                                  GNUNET_IDENTITY_PROVIDER_TicketCallback proc,
 297                                                  void *proc_cls,
 298                                                  GNUNET_SCHEDULER_TaskCallback finish_cb,
 299                                                  void *finish_cb_cls);
 300
 301 /**
 302  * Lists all tickets that have been issued to remote
 303  * identites (relying parties)
 304  *
 305  * @param h the identity provider to use
 306  * @param identity the issuing identity
 307  * @param error_cb function to call on error (i.e. disconnect),
 308  *        the handle is afterwards invalid
 309  * @param error_cb_cls closure for @a error_cb
 310  * @param proc function to call on each ticket; it
 311  *        will be called repeatedly with a value (if available)
 312  * @param proc_cls closure for @a proc
 313  * @param finish_cb function to call on completion
 314  *        the handle is afterwards invalid
 315  * @param finish_cb_cls closure for @a finish_cb
 316  * @return an iterator handle to use for iteration
 317  */
 318 struct GNUNET_IDENTITY_PROVIDER_TicketIterator *
 319 GNUNET_IDENTITY_PROVIDER_ticket_iteration_start_rp (struct GNUNET_IDENTITY_PROVIDER_Handle *h,
 320                                                     const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
 321                                                     GNUNET_SCHEDULER_TaskCallback error_cb,
 322                                                     void *error_cb_cls,
 323                                                     GNUNET_IDENTITY_PROVIDER_TicketCallback proc,
 324                                                     void *proc_cls,
 325                                                     GNUNET_SCHEDULER_TaskCallback finish_cb,
 326                                                     void *finish_cb_cls);
 327
 328 /**
 329  * Calls the record processor specified in #GNUNET_IDENTITY_PROVIDER_ticket_iteration_start
 330  * for the next record.
 331  *
 332  * @param it the iterator
 333  */
 334 void
 335 GNUNET_IDENTITY_PROVIDER_ticket_iteration_next (struct GNUNET_IDENTITY_PROVIDER_TicketIterator *it);
 336
 337 /**
 338  * Stops iteration and releases the idp handle for further calls.  Must
 339  * be called on any iteration that has not yet completed prior to calling
 340  * #GNUNET_IDENTITY_PROVIDER_disconnect.
 341  *
 342  * @param it the iterator
 343  */
 344 void
 345 GNUNET_IDENTITY_PROVIDER_ticket_iteration_stop (struct GNUNET_IDENTITY_PROVIDER_TicketIterator *it);
 346
 347 /**
 348  * Disconnect from identity provider service.
 349  *
 350  * @param h identity provider service to disconnect
 351  */
 352 void
 353 GNUNET_IDENTITY_PROVIDER_disconnect (struct GNUNET_IDENTITY_PROVIDER_Handle *h);
 354
 355
 356 /**
 357  * Cancel an identity provider operation.  Note that the operation MAY still
 358  * be executed; this merely cancels the continuation; if the request
 359  * was already transmitted, the service may still choose to complete
 360  * the operation.
 361  *
 362  * @param op operation to cancel
 363  */
 364 void
 365 GNUNET_IDENTITY_PROVIDER_cancel (struct GNUNET_IDENTITY_PROVIDER_Operation *op);
 366
 367 #if 0                           /* keep Emacsens' auto-indent happy */
 368 {
 369 #endif
 370 #ifdef __cplusplus
 371 }
 372 #endif
 373
 374
 375 /* ifndef GNUNET_IDENTITY_PROVIDER_SERVICE_H */
 376 #endif
 377
 378 /** @} */ /* end of group identity */
 379
 380 /* end of gnunet_identity_provider_service.h */