gnunet_identity_service.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2013 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#ifndef GNUNET_IDENTITY_SERVICE_H
#define GNUNET_IDENTITY_SERVICE_H
 
#ifdef __cplusplus
extern "C" {
#if 0 /* keep Emacsens' auto-indent happy */
}
#endif
#endif
 
 
#include "gnunet_util_lib.h"
 
 
#define GNUNET_IDENTITY_VERSION 0x00000100
 
enum GNUNET_IDENTITY_KeyType
{
  GNUNET_IDENTITY_TYPE_ECDSA = 65536,
 
  GNUNET_IDENTITY_TYPE_EDDSA = 65556
};
 
struct GNUNET_IDENTITY_Handle;
 
struct GNUNET_IDENTITY_Ego;
 
struct GNUNET_IDENTITY_PrivateKey
{
  uint32_t type;
 
  union
  {
    struct GNUNET_CRYPTO_EcdsaPrivateKey ecdsa_key;
 
    struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_key;
  };
};
 
 
struct GNUNET_IDENTITY_PublicKey
{
  uint32_t type;
 
  union
  {
    struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_key;
 
    struct GNUNET_CRYPTO_EddsaPublicKey eddsa_key;
  };
};
 
 
struct GNUNET_IDENTITY_Signature
{
  uint32_t type;
 
  union
  {
    struct GNUNET_CRYPTO_EcdsaSignature ecdsa_signature;
 
    struct GNUNET_CRYPTO_EddsaSignature eddsa_signature;
  };
};
 
 
struct GNUNET_IDENTITY_Operation;
 
 
const struct GNUNET_IDENTITY_PrivateKey *
GNUNET_IDENTITY_ego_get_private_key (const struct GNUNET_IDENTITY_Ego *ego);
 
 
struct GNUNET_IDENTITY_Ego *
GNUNET_IDENTITY_ego_get_anonymous (void);
 
 
void
GNUNET_IDENTITY_ego_get_public_key (struct GNUNET_IDENTITY_Ego *ego,
                                    struct GNUNET_IDENTITY_PublicKey *pk);
 
 
typedef void
(*GNUNET_IDENTITY_Callback) (void *cls,
                             struct GNUNET_IDENTITY_Ego *ego,
                             void **ctx,
                             const char *name);
 
 
struct GNUNET_IDENTITY_Handle *
GNUNET_IDENTITY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
                         GNUNET_IDENTITY_Callback cb,
                         void *cb_cls);
 
 
struct GNUNET_IDENTITY_Operation *
GNUNET_IDENTITY_get (struct GNUNET_IDENTITY_Handle *id,
                     const char *service_name,
                     GNUNET_IDENTITY_Callback cb,
                     void *cb_cls);
 
 
typedef void
(*GNUNET_IDENTITY_Continuation) (void *cls,
                                 enum GNUNET_ErrorCode ec);
 
 
struct GNUNET_IDENTITY_Operation *
GNUNET_IDENTITY_set (struct GNUNET_IDENTITY_Handle *id,
                     const char *service_name,
                     struct GNUNET_IDENTITY_Ego *ego,
                     GNUNET_IDENTITY_Continuation cont,
                     void *cont_cls);
 
 
void
GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h);
 
 
typedef void
(*GNUNET_IDENTITY_CreateContinuation) (
  void *cls,
  const struct GNUNET_IDENTITY_PrivateKey *pk,
  enum GNUNET_ErrorCode ec);
 
 
struct GNUNET_IDENTITY_Operation *
GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *id,
                        const char *name,
                        const struct GNUNET_IDENTITY_PrivateKey *privkey,
                        enum GNUNET_IDENTITY_KeyType ktype,
                        GNUNET_IDENTITY_CreateContinuation cont,
                        void *cont_cls);
 
 
struct GNUNET_IDENTITY_Operation *
GNUNET_IDENTITY_rename (struct GNUNET_IDENTITY_Handle *id,
                        const char *old_name,
                        const char *new_name,
                        GNUNET_IDENTITY_Continuation cb,
                        void *cb_cls);
 
 
struct GNUNET_IDENTITY_Operation *
GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *id,
                        const char *name,
                        GNUNET_IDENTITY_Continuation cb,
                        void *cb_cls);
 
 
void
GNUNET_IDENTITY_cancel (struct GNUNET_IDENTITY_Operation *op);
 
 
ssize_t
GNUNET_IDENTITY_public_key_get_length (const struct GNUNET_IDENTITY_PublicKey *key);
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_read_public_key_from_buffer (const void *buffer,
                                             size_t len,
                                             struct
                                             GNUNET_IDENTITY_PublicKey *key,
                                             size_t *read);
 
ssize_t
GNUNET_IDENTITY_private_key_get_length (const struct
                                        GNUNET_IDENTITY_PrivateKey *key);
 
 
ssize_t
GNUNET_IDENTITY_write_public_key_to_buffer (const struct
                                            GNUNET_IDENTITY_PublicKey *key,
                                            void*buffer,
                                            size_t len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_read_private_key_from_buffer (const void*buffer,
                                              size_t len,
                                              struct
                                              GNUNET_IDENTITY_PrivateKey *key,
                                              size_t *read);
 
 
ssize_t
GNUNET_IDENTITY_write_private_key_to_buffer (const struct
                                             GNUNET_IDENTITY_PrivateKey *key,
                                             void*buffer,
                                             size_t len);
 
 
ssize_t
GNUNET_IDENTITY_signature_get_length (const struct
                                      GNUNET_IDENTITY_Signature *sig);
 
 
ssize_t
GNUNET_IDENTITY_signature_get_raw_length_by_type (const uint32_t type);
 
 
 
ssize_t
GNUNET_IDENTITY_read_signature_from_buffer (struct
                                            GNUNET_IDENTITY_Signature *sig,
                                            const void*buffer,
                                            size_t len);
 
 
ssize_t
GNUNET_IDENTITY_write_signature_to_buffer (const struct
                                           GNUNET_IDENTITY_Signature *sig,
                                           void*buffer,
                                           size_t len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_sign_ (const struct
                       GNUNET_IDENTITY_PrivateKey *priv,
                       const struct
                       GNUNET_CRYPTO_EccSignaturePurpose *purpose,
                       struct GNUNET_IDENTITY_Signature *sig);
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_sign_raw_ (const struct
                           GNUNET_IDENTITY_PrivateKey *priv,
                           const struct
                           GNUNET_CRYPTO_EccSignaturePurpose *purpose,
                           unsigned char *sig);
 
 
#define GNUNET_IDENTITY_sign(priv,ps,sig) do {                \
    /* check size is set correctly */                                     \
    GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps)));         \
    /* check 'ps' begins with the purpose */                              \
    GNUNET_static_assert (((void*) (ps)) ==                               \
                          ((void*) &(ps)->purpose));                      \
    GNUNET_assert (GNUNET_OK ==                                           \
                   GNUNET_IDENTITY_sign_ (priv,               \
                                          &(ps)->purpose,             \
                                          sig));                      \
} while (0)
 
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_signature_verify_ (uint32_t purpose,
                                   const struct
                                   GNUNET_CRYPTO_EccSignaturePurpose *validate,
                                   const struct GNUNET_IDENTITY_Signature *sig,
                                   const struct
                                   GNUNET_IDENTITY_PublicKey *pub);
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_signature_verify_raw_ (uint32_t purpose,
                                       const struct
                                       GNUNET_CRYPTO_EccSignaturePurpose *
                                       validate,
                                       const unsigned char *sig,
                                       const struct
                                       GNUNET_IDENTITY_PublicKey *pub);
 
 
#define GNUNET_IDENTITY_signature_verify(purp,ps,sig,pub) ({             \
    /* check size is set correctly */                                     \
    GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps)));         \
    /* check 'ps' begins with the purpose */                              \
    GNUNET_static_assert (((void*) (ps)) ==                               \
                          ((void*) &(ps)->purpose));                      \
    GNUNET_IDENTITY_signature_verify_ (purp,                              \
                                       &(ps)->purpose,                    \
                                       sig,                               \
                                       pub);                              \
  })
 
 
ssize_t
GNUNET_IDENTITY_encrypt (const void *block,
                         size_t size,
                         const struct GNUNET_IDENTITY_PublicKey *pub,
                         struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
                         void *result);
 
 
ssize_t
GNUNET_IDENTITY_decrypt (const void *block,
                         size_t size,
                         const struct
                         GNUNET_IDENTITY_PrivateKey *priv,
                         const struct
                         GNUNET_CRYPTO_EcdhePublicKey *ecc,
                         void *result);
 
 
char *
GNUNET_IDENTITY_public_key_to_string (const struct
                                      GNUNET_IDENTITY_PublicKey *key);
 
 
char *
GNUNET_IDENTITY_private_key_to_string (const struct
                                       GNUNET_IDENTITY_PrivateKey *key);
 
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_public_key_from_string (const char*str,
                                        struct GNUNET_IDENTITY_PublicKey *key);
 
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_private_key_from_string (const char*str,
                                         struct GNUNET_IDENTITY_PrivateKey *key);
 
 
enum GNUNET_GenericReturnValue
GNUNET_IDENTITY_key_get_public (const struct
                                GNUNET_IDENTITY_PrivateKey *privkey,
                                struct GNUNET_IDENTITY_PublicKey *key);
 
 
/* ************* convenience API to lookup an ego ***************** */
 
typedef void
(*GNUNET_IDENTITY_EgoCallback) (void *cls,
                                struct GNUNET_IDENTITY_Ego *ego);
 
struct GNUNET_IDENTITY_EgoLookup;
 
 
struct GNUNET_IDENTITY_EgoLookup *
GNUNET_IDENTITY_ego_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg,
                            const char *name,
                            GNUNET_IDENTITY_EgoCallback cb,
                            void *cb_cls);
 
 
void
GNUNET_IDENTITY_ego_lookup_cancel (struct GNUNET_IDENTITY_EgoLookup *el);
 
typedef void
(*GNUNET_IDENTITY_EgoSuffixCallback) (
  void *cls,
  const struct GNUNET_IDENTITY_PrivateKey *priv,
  const char *ego_name);
 
 
struct GNUNET_IDENTITY_EgoSuffixLookup;
 
 
struct GNUNET_IDENTITY_EgoSuffixLookup *
GNUNET_IDENTITY_ego_lookup_by_suffix (const struct
                                      GNUNET_CONFIGURATION_Handle *cfg,
                                      const char *suffix,
                                      GNUNET_IDENTITY_EgoSuffixCallback cb,
                                      void *cb_cls);
 
 
void
GNUNET_IDENTITY_ego_lookup_by_suffix_cancel (
  struct GNUNET_IDENTITY_EgoSuffixLookup *el);
 
 
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
/* ifndef GNUNET_IDENTITY_SERVICE_H */
#endif
 /* end of group identity */
 /* end of group addition */
 
/* end of gnunet_identity_service.h */