gnunet_crypto_lib.h

Go to the documentation of this file.

/*
 file is part of GNUnet.
     Copyright (C) 2001-2023 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
 */
 
#if ! defined (__GNUNET_UTIL_LIB_H_INSIDE__)
#error "Only <gnunet_util_lib.h> can be included directly."
#endif
 
#ifndef GNUNET_CRYPTO_LIB_H
#define GNUNET_CRYPTO_LIB_H
 
#ifdef __cplusplus
extern "C" {
#if 0 /* keep Emacsens' auto-indent happy */
}
#endif
#endif
 
 
#include "gnunet_common.h"
#include <stdbool.h>
#include <sodium.h>
 
struct GNUNET_PeerIdentity;
 
#include <gcrypt.h>
 
 
#define GNUNET_CRYPTO_ECC_SIGNATURE_DATA_ENCODING_LENGTH 126
 
 
enum GNUNET_CRYPTO_Quality
{
  GNUNET_CRYPTO_QUALITY_WEAK,
 
  GNUNET_CRYPTO_QUALITY_STRONG,
 
  GNUNET_CRYPTO_QUALITY_NONCE
};
 
 
#define GNUNET_CRYPTO_AES_KEY_LENGTH (256 / 8)
 
#define GNUNET_CRYPTO_AES_IV_LENGTH (128 / 8)
 
#define GNUNET_CRYPTO_XSALSA20_KEY_LENGTH \
        crypto_secretbox_xsalsa20poly1305_KEYBYTES
 
#define GNUNET_CRYPTO_XSALSA20_IV_LENGTH \
        crypto_secretbox_xsalsa20poly1305_NONCEBYTES
 
#define GNUNET_CRYPTO_HASH_LENGTH (512 / 8)
 
#define GNUNET_CRYPTO_PKEY_ASCII_LENGTH 52
 
struct GNUNET_CRYPTO_HashAsciiEncoded
{
  unsigned char encoding[104];
};
 
 
GNUNET_NETWORK_STRUCT_BEGIN
 
 
struct GNUNET_CRYPTO_SignaturePurpose
{
  uint32_t size GNUNET_PACKED;
 
  uint32_t purpose GNUNET_PACKED;
};
 
 
struct GNUNET_CRYPTO_EddsaSignature
{
  unsigned char r[256 / 8];
 
  unsigned char s[256 / 8];
};
 
 
struct GNUNET_CRYPTO_EcdsaSignature
{
  unsigned char r[256 / 8];
 
  unsigned char s[256 / 8];
};
 
 
struct GNUNET_CRYPTO_EddsaPublicKey
{
  unsigned char q_y[256 / 8];
};
 
 
struct GNUNET_CRYPTO_EcdsaPublicKey
{
  unsigned char q_y[256 / 8];
};
 
 
struct GNUNET_PeerIdentity
{
  struct GNUNET_CRYPTO_EddsaPublicKey public_key;
};
 
struct GNUNET_CRYPTO_EcdhePublicKey
{
  unsigned char q_y[256 / 8];
};
 
 
struct GNUNET_CRYPTO_EcdhePrivateKey
{
  unsigned char d[256 / 8];
};
 
struct GNUNET_CRYPTO_EcdsaPrivateKey
{
  unsigned char d[256 / 8];
};
 
struct GNUNET_CRYPTO_EddsaPrivateKey
{
  unsigned char d[256 / 8];
};
 
 
struct GNUNET_CRYPTO_EddsaPrivateScalar
{
  unsigned char s[512 / 8];
};
 
struct GNUNET_CRYPTO_Edx25519PrivateKey
{
  unsigned char a[256 / 8];
 
  unsigned char b[256 / 8];
};
 
 
struct GNUNET_CRYPTO_Edx25519PublicKey
{
  unsigned char q_y[256 / 8];
};
 
struct GNUNET_CRYPTO_Edx25519Signature
{
  unsigned char r[256 / 8];
 
  unsigned char s[256 / 8];
};
 
struct GNUNET_CRYPTO_ElligatorEcdhePrivateKey
{
  unsigned char d[256 / 8];
};
 
struct GNUNET_CRYPTO_ElligatorRepresentative
{
  uint8_t r[256 / 8];
};
 
enum GNUNET_CRYPTO_KeyType
{
  GNUNET_PUBLIC_KEY_TYPE_ECDSA = 65536,
 
  GNUNET_PUBLIC_KEY_TYPE_EDDSA = 65556
};
 
enum GNUNET_CRYPTO_HpkeKeyType
{
  GNUNET_CRYPTO_HPKE_KEY_TYPE_X25519 = 0
};
 
struct GNUNET_CRYPTO_BlindablePrivateKey
{
  uint32_t type;
 
  union
  {
    struct GNUNET_CRYPTO_EcdsaPrivateKey ecdsa_key;
 
    struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_key;
  };
};
 
 
struct GNUNET_CRYPTO_BlindablePublicKey
{
  uint32_t type;
 
  union
  {
    struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_key;
 
    struct GNUNET_CRYPTO_EddsaPublicKey eddsa_key;
  };
};
 
struct GNUNET_CRYPTO_HpkePrivateKey
{
  uint32_t type;
 
  union
  {
    struct GNUNET_CRYPTO_EcdhePrivateKey ecdhe_key;
 
  };
};
 
 
struct GNUNET_CRYPTO_HpkePublicKey
{
  uint32_t type;
 
  union
  {
    struct GNUNET_CRYPTO_EcdhePublicKey ecdhe_key;
 
  };
};
 
struct GNUNET_CRYPTO_BlindableKeySignature
{
  uint32_t type;
 
  union
  {
    struct GNUNET_CRYPTO_EcdsaSignature ecdsa_signature;
 
    struct GNUNET_CRYPTO_EddsaSignature eddsa_signature;
  };
};
 
struct GNUNET_CRYPTO_SymmetricSessionKey
{
  unsigned char aes_key[GNUNET_CRYPTO_AES_KEY_LENGTH];
 
  unsigned char twofish_key[GNUNET_CRYPTO_AES_KEY_LENGTH];
};
 
struct GNUNET_CRYPTO_ChallengeNonceP
{
  struct GNUNET_ShortHashCode value;
};
 
GNUNET_NETWORK_STRUCT_END
 
struct GNUNET_CRYPTO_SymmetricInitializationVector
{
  unsigned char aes_iv[GNUNET_CRYPTO_AES_KEY_LENGTH / 2];
 
  unsigned char twofish_iv[GNUNET_CRYPTO_AES_KEY_LENGTH / 2];
};
 
 
struct GNUNET_CRYPTO_AuthKey
{
  unsigned char key[GNUNET_CRYPTO_HASH_LENGTH];
};
 
 
#define GNUNET_CRYPTO_PAILLIER_BITS 2048
 
 
struct GNUNET_CRYPTO_PaillierPublicKey
{
  unsigned char n[GNUNET_CRYPTO_PAILLIER_BITS / 8];
};
 
 
struct GNUNET_CRYPTO_PaillierPrivateKey
{
  unsigned char lambda[GNUNET_CRYPTO_PAILLIER_BITS / 8];
  unsigned char mu[GNUNET_CRYPTO_PAILLIER_BITS / 8];
};
 
 
struct GNUNET_CRYPTO_PaillierCiphertext
{
  int32_t remaining_ops GNUNET_PACKED;
 
  unsigned char bits[GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8];
};
 
 
struct GNUNET_CRYPTO_Cs25519Scalar
{
  unsigned char d[crypto_core_ed25519_SCALARBYTES];
};
 
 
struct GNUNET_CRYPTO_Cs25519Point
{
  unsigned char y[crypto_core_ed25519_BYTES];
};
 
 
struct GNUNET_CRYPTO_CsPrivateKey
{
  struct GNUNET_CRYPTO_Cs25519Scalar scalar;
};
 
 
struct GNUNET_CRYPTO_CsPublicKey
{
  struct GNUNET_CRYPTO_Cs25519Point point;
};
 
 
struct GNUNET_CRYPTO_CsBlindingSecret
{
  struct GNUNET_CRYPTO_Cs25519Scalar alpha;
  struct GNUNET_CRYPTO_Cs25519Scalar beta;
};
 
 
struct GNUNET_CRYPTO_CsRSecret
{
  struct GNUNET_CRYPTO_Cs25519Scalar scalar;
};
 
 
struct GNUNET_CRYPTO_CsRPublic
{
  struct GNUNET_CRYPTO_Cs25519Point point;
};
 
 
struct GNUNET_CRYPTO_CsC
{
  struct GNUNET_CRYPTO_Cs25519Scalar scalar;
};
 
 
struct GNUNET_CRYPTO_CsS
{
  struct GNUNET_CRYPTO_Cs25519Scalar scalar;
};
 
 
struct GNUNET_CRYPTO_CsBlindS
{
  struct GNUNET_CRYPTO_Cs25519Scalar scalar;
};
 
 
struct GNUNET_CRYPTO_CsSignature
{
  struct GNUNET_CRYPTO_CsS s_scalar;
 
  struct GNUNET_CRYPTO_CsRPublic r_point;
};
 
 
struct GNUNET_CRYPTO_CsSessionNonce
{
  /*a nonce*/
  unsigned char snonce[256 / 8];
};
 
 
struct GNUNET_CRYPTO_CsBlindingNonce
{
  /*a nonce*/
  unsigned char bnonce[256 / 8];
};
 
 
/* **************** Functions and Macros ************* */
 
void
GNUNET_CRYPTO_seed_weak_random (int32_t seed);
 
 
uint8_t
GNUNET_CRYPTO_crc8_n (const void *buf, size_t len);
 
 
uint32_t
GNUNET_CRYPTO_crc16_step (uint32_t sum, const void *buf, size_t len);
 
 
uint16_t
GNUNET_CRYPTO_crc16_finish (uint32_t sum);
 
 
uint16_t
GNUNET_CRYPTO_crc16_n (const void *buf, size_t len);
 
 
int32_t
GNUNET_CRYPTO_crc32_n (const void *buf, size_t len);
 
void
GNUNET_CRYPTO_zero_keys (void *buffer, size_t length);
 
 
void
GNUNET_CRYPTO_random_block (enum GNUNET_CRYPTO_Quality mode,
                            void *buffer,
                            size_t length);
 
 
void
GNUNET_CRYPTO_random_timeflake (enum GNUNET_CRYPTO_Quality mode,
                                struct GNUNET_Uuid *uuid);
 
 
uint32_t
GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, uint32_t i);
 
 
uint64_t
GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode, uint64_t max);
 
 
unsigned int *
GNUNET_CRYPTO_random_permute (enum GNUNET_CRYPTO_Quality mode, unsigned int n);
 
 
void
GNUNET_CRYPTO_symmetric_create_session_key (
  struct GNUNET_CRYPTO_SymmetricSessionKey *key);
 
 
[[ deprecated ("Use HPKE or other AEAD schemes for encryption") ]]
ssize_t
GNUNET_CRYPTO_symmetric_encrypt (
  const void *block,
  size_t size,
  const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
  const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
  void *result);
 
 
[[ deprecated ("Use HPKE or other AEAD schemes for encryption") ]]
ssize_t
GNUNET_CRYPTO_symmetric_decrypt (
  const void *block,
  size_t size,
  const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
  const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
  void *result);
 
 
void
GNUNET_CRYPTO_aes_ctr (
  const void *in_buf,
  size_t in_buf_len,
  const unsigned char key[GNUNET_CRYPTO_AES_KEY_LENGTH],
  const unsigned char iv[GNUNET_CRYPTO_AES_IV_LENGTH],
  void *out_buf);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_xsalsa20poly1305_decrypt (
  size_t in_buf_len,
  const unsigned char in_buf[in_buf_len],
  const unsigned char key[GNUNET_CRYPTO_XSALSA20_KEY_LENGTH],
  const unsigned char nonce[GNUNET_CRYPTO_XSALSA20_IV_LENGTH],
  void *out_buf);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_xsalsa20poly1305_encrypt (
  size_t in_buf_len,
  const unsigned char in_buf[in_buf_len],
  const unsigned char key[GNUNET_CRYPTO_XSALSA20_KEY_LENGTH],
  const unsigned char nonce[GNUNET_CRYPTO_XSALSA20_IV_LENGTH],
  void *out_buf);
 
void
GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block,
                           struct GNUNET_CRYPTO_HashAsciiEncoded *result);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hash_from_string2 (const char *enc,
                                 size_t enclen,
                                 struct GNUNET_HashCode *result);
 
 
#define GNUNET_CRYPTO_hash_from_string(enc, result) \
        GNUNET_CRYPTO_hash_from_string2 (enc, strlen (enc), result)
 
 
uint32_t
GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode *a,
                                 const struct GNUNET_HashCode *b);
 
 
void
GNUNET_CRYPTO_hash (const void *block,
                    size_t size,
                    struct GNUNET_HashCode *ret);
 
 
struct GNUNET_CRYPTO_PowSalt
{
  char salt[crypto_pwhash_argon2id_SALTBYTES];
};
 
 
void
GNUNET_CRYPTO_pow_hash (const struct GNUNET_CRYPTO_PowSalt *salt,
                        const void *buf,
                        size_t buf_len,
                        struct GNUNET_HashCode *result);
 
 
struct GNUNET_HashContext;
 
 
struct GNUNET_HashContext *
GNUNET_CRYPTO_hash_context_start (void);
 
 
struct GNUNET_HashContext *
GNUNET_CRYPTO_hash_context_copy (const struct GNUNET_HashContext *hc);
 
 
void
GNUNET_CRYPTO_hash_context_read (struct GNUNET_HashContext *hc,
                                 const void *buf,
                                 size_t size);
 
 
void
GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc,
                                   struct GNUNET_HashCode *r_hash);
 
 
void
GNUNET_CRYPTO_hash_context_abort (struct GNUNET_HashContext *hc);
 
 
void
GNUNET_CRYPTO_hmac_raw (const void *key,
                        size_t key_len,
                        const void *plaintext,
                        size_t plaintext_len,
                        struct GNUNET_HashCode *hmac);
 
 
void
GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key,
                    const void *plaintext,
                    size_t plaintext_len,
                    struct GNUNET_HashCode *hmac);
 
 
typedef void
(*GNUNET_CRYPTO_HashCompletedCallback) (
  void *cls,
  const struct GNUNET_HashCode *res);
 
 
struct GNUNET_CRYPTO_FileHashContext;
 
 
struct GNUNET_CRYPTO_FileHashContext *
GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
                         const char *filename,
                         size_t blocksize,
                         GNUNET_CRYPTO_HashCompletedCallback callback,
                         void *callback_cls);
 
 
void
GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc);
 
 
void
GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
                                  struct GNUNET_HashCode *result);
 
 
void
GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode *a,
                               const struct GNUNET_HashCode *b,
                               struct GNUNET_HashCode *result);
 
 
void
GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode *a,
                        const struct GNUNET_HashCode *delta,
                        struct GNUNET_HashCode *result);
 
 
void
GNUNET_CRYPTO_hash_xor (const struct GNUNET_HashCode *a,
                        const struct GNUNET_HashCode *b,
                        struct GNUNET_HashCode *result);
 
 
unsigned int
GNUNET_CRYPTO_hash_count_leading_zeros (const struct GNUNET_HashCode *h);
 
 
unsigned int
GNUNET_CRYPTO_hash_count_tailing_zeros (const struct GNUNET_HashCode *h);
 
 
void
GNUNET_CRYPTO_hash_to_aes_key (
  const struct GNUNET_HashCode *hc,
  struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
  struct GNUNET_CRYPTO_SymmetricInitializationVector *iv);
 
 
int
GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
                        const struct GNUNET_HashCode *h2);
 
 
int
GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode *h1,
                           const struct GNUNET_HashCode *h2,
                           const struct GNUNET_HashCode *target);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hkdf_extract (struct GNUNET_ShortHashCode *prk,
                            const void *salt,
                            size_t salt_len,
                            const void *ikm,
                            size_t ikm_len);
 
struct GNUNET_CRYPTO_KdfInputArgument
{
 
  // The data that is input into HKDF-Expand
  const void *data;
 
  // The length of data in bytes
  size_t data_length;
 
};
 
#define GNUNET_CRYPTO_kdf_arg_string(d) \
        ((struct GNUNET_CRYPTO_KdfInputArgument) \
  {                                   \
    (const void*) d,                                \
    strlen (d)                        \
  })
 
 
#define GNUNET_CRYPTO_kdf_arg_auto(d) \
        ((struct GNUNET_CRYPTO_KdfInputArgument) \
  {                                   \
    (const void*) d,                                \
    sizeof (*d)                        \
  })
 
 
#define GNUNET_CRYPTO_kdf_arg(d,s) \
        ((struct GNUNET_CRYPTO_KdfInputArgument) \
  {                                   \
    (const void*) d,                                \
    s                                 \
  })
 
 
#define _HKDF_ARGS_VEC_HELPER(...) \
        (struct \
         GNUNET_CRYPTO_KdfInputArgument[]) { __VA_ARGS__ }
 
#define _HKDF_ARGS_VECLEN_HELPER(...) \
        sizeof(_HKDF_ARGS_VEC_HELPER (__VA_ARGS__)) / sizeof ( \
          struct GNUNET_CRYPTO_KdfInputArgument)
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hkdf_gnunet_v (
  void *result,
  size_t out_len,
  const void *xts,
  size_t xts_len,
  const void *skm,
  size_t skm_len,
  size_t hkdf_args_count,
  const struct GNUNET_CRYPTO_KdfInputArgument hkdf_args[
    hkdf_args_count]);
 
 
#define GNUNET_CRYPTO_hkdf_gnunet(result, \
                                  out_len, \
                                  xts, \
                                  xts_len, \
                                  skm, \
                                  skm_len, ...) \
        GNUNET_CRYPTO_hkdf_gnunet_v (result, out_len, xts, xts_len, skm, \
                                     skm_len, \
                                     _HKDF_ARGS_VECLEN_HELPER (__VA_ARGS__ \
                                                               ), \
                                     _HKDF_ARGS_VEC_HELPER (__VA_ARGS__))
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hkdf_expand_v (
  void *result,
  size_t out_len,
  const struct GNUNET_ShortHashCode *prk,
  size_t hkdf_args_count,
  const struct GNUNET_CRYPTO_KdfInputArgument hkdf_args[
    hkdf_args_count]);
 
#define GNUNET_CRYPTO_hkdf_expand(result, \
                                  out_len, \
                                  prk, \
                                  ...) \
        GNUNET_CRYPTO_hkdf_expand_v (result, out_len, \
                                     prk, \
                                     _HKDF_ARGS_VECLEN_HELPER (__VA_ARGS__ \
                                                               ), \
                                     _HKDF_ARGS_VEC_HELPER (__VA_ARGS__))
 
 
void
GNUNET_CRYPTO_kdf_mod_mpi (gcry_mpi_t *r,
                           gcry_mpi_t n,
                           const void *xts,
                           size_t xts_len,
                           const void *skm,
                           size_t skm_len,
                           const char *ctx);
 
 
// #define GNUNET_CRYPTO_kdf GNUNET_CRYPTO_hkdf_gnunet
 
 
void
GNUNET_CRYPTO_ecdsa_key_get_public (
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
  struct GNUNET_CRYPTO_EcdsaPublicKey *pub);
 
void
GNUNET_CRYPTO_eddsa_key_get_public (
  const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
  struct GNUNET_CRYPTO_EddsaPublicKey *pub);
 
void
GNUNET_CRYPTO_edx25519_key_get_public (
  const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv,
  struct GNUNET_CRYPTO_Edx25519PublicKey *pub);
 
void
GNUNET_CRYPTO_ecdhe_key_get_public (
  const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
  struct GNUNET_CRYPTO_EcdhePublicKey *pub);
 
 
char *
GNUNET_CRYPTO_ecdsa_public_key_to_string (
  const struct GNUNET_CRYPTO_EcdsaPublicKey *pub);
 
char *
GNUNET_CRYPTO_ecdsa_private_key_to_string (
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv);
 
 
char *
GNUNET_CRYPTO_eddsa_private_key_to_string (
  const struct GNUNET_CRYPTO_EddsaPrivateKey *priv);
 
 
char *
GNUNET_CRYPTO_eddsa_public_key_to_string (
  const struct GNUNET_CRYPTO_EddsaPublicKey *pub);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdsa_public_key_from_string (
  const char *enc,
  size_t enclen,
  struct GNUNET_CRYPTO_EcdsaPublicKey *pub);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_private_key_from_string (
  const char *enc,
  size_t enclen,
  struct GNUNET_CRYPTO_EddsaPrivateKey *priv);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_public_key_from_string (
  const char *enc,
  size_t enclen,
  struct GNUNET_CRYPTO_EddsaPublicKey *pub);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdsa_key_from_file (const char *filename,
                                   int do_create,
                                   struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_key_from_file (const char *filename,
                                   int do_create,
                                   struct GNUNET_CRYPTO_EddsaPrivateKey *pkey);
 
 
struct GNUNET_CONFIGURATION_Handle;
 
 
struct GNUNET_CRYPTO_EddsaPrivateKey *
GNUNET_CRYPTO_eddsa_key_create_from_configuration (
  const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 
void
GNUNET_CRYPTO_ecdsa_key_create (struct GNUNET_CRYPTO_EcdsaPrivateKey *pk);
 
 
void
GNUNET_CRYPTO_eddsa_key_create (struct GNUNET_CRYPTO_EddsaPrivateKey *pk);
 
 
void
GNUNET_CRYPTO_edx25519_key_create (struct GNUNET_CRYPTO_Edx25519PrivateKey *pk);
 
void
GNUNET_CRYPTO_edx25519_key_create_from_seed (
  const void *seed,
  size_t seedsize,
  struct GNUNET_CRYPTO_Edx25519PrivateKey *pk);
 
void
GNUNET_CRYPTO_ecdhe_key_create (struct GNUNET_CRYPTO_EcdhePrivateKey *pk);
 
 
void
GNUNET_CRYPTO_eddsa_key_clear (struct GNUNET_CRYPTO_EddsaPrivateKey *pk);
 
 
void
GNUNET_CRYPTO_ecdsa_key_clear (struct GNUNET_CRYPTO_EcdsaPrivateKey *pk);
 
void
GNUNET_CRYPTO_edx25519_key_clear (struct GNUNET_CRYPTO_Edx25519PrivateKey *pk);
 
void
GNUNET_CRYPTO_ecdhe_key_clear (struct GNUNET_CRYPTO_EcdhePrivateKey *pk);
 
void
GNUNET_CRYPTO_private_key_clear (struct GNUNET_CRYPTO_BlindablePrivateKey *pk);
 
 
const struct GNUNET_CRYPTO_EcdsaPrivateKey *
GNUNET_CRYPTO_ecdsa_key_get_anonymous (void);
 
 
void
GNUNET_CRYPTO_eddsa_setup_hostkey (const char *cfg_name);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_get_peer_identity (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                 struct GNUNET_PeerIdentity *dst);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blinded_key_sign_by_peer_identity (const struct
                                                 GNUNET_CONFIGURATION_Handle *
                                                 cfg,
                                                 const struct
                                                 GNUNET_CRYPTO_SignaturePurpose
                                                 *purpose,
                                                 struct
                                                 GNUNET_CRYPTO_EddsaSignature *
                                                 sig);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_verify_peer_identity (uint32_t purpose,
                                    const struct
                                    GNUNET_CRYPTO_SignaturePurpose *validate,
                                    const struct
                                    GNUNET_CRYPTO_EddsaSignature *sig,
                                    const struct GNUNET_PeerIdentity *identity);
 
 
struct GNUNET_CRYPTO_EccDlogContext;
 
 
struct GNUNET_CRYPTO_EccPoint
{
  unsigned char v[256 / 8];
};
 
struct GNUNET_CRYPTO_EccScalar
{
  unsigned char v[256 / 8];
};
 
struct GNUNET_CRYPTO_EccDlogContext *
GNUNET_CRYPTO_ecc_dlog_prepare (unsigned int max,
                                unsigned int mem);
 
 
int
GNUNET_CRYPTO_ecc_dlog (struct GNUNET_CRYPTO_EccDlogContext *edc,
                        const struct GNUNET_CRYPTO_EccPoint *input);
 
 
void
GNUNET_CRYPTO_ecc_dexp (int val,
                        struct GNUNET_CRYPTO_EccPoint*r);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecc_dexp_mpi (const struct GNUNET_CRYPTO_EccScalar *val,
                            struct GNUNET_CRYPTO_EccPoint *r);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecc_pmul_mpi (const struct GNUNET_CRYPTO_EccPoint *p,
                            const struct GNUNET_CRYPTO_EccScalar *val,
                            struct GNUNET_CRYPTO_EccPoint *r);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecc_add (const struct GNUNET_CRYPTO_EccPoint *a,
                       const struct GNUNET_CRYPTO_EccPoint *b,
                       struct GNUNET_CRYPTO_EccPoint *r);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecc_rnd (struct GNUNET_CRYPTO_EccPoint *r,
                       struct GNUNET_CRYPTO_EccPoint *r_inv);
 
 
void
GNUNET_CRYPTO_ecc_rnd_mpi (struct GNUNET_CRYPTO_EccScalar *r,
                           struct GNUNET_CRYPTO_EccScalar *r_neg);
 
 
void
GNUNET_CRYPTO_ecc_random_mod_n (struct GNUNET_CRYPTO_EccScalar*r);
 
 
void
GNUNET_CRYPTO_ecc_dlog_release (struct GNUNET_CRYPTO_EccDlogContext *dlc);
 
 
void
GNUNET_CRYPTO_ecc_scalar_from_int (int64_t val,
                                   struct GNUNET_CRYPTO_EccScalar *r);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecc_ecdh (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
                        const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
                        struct GNUNET_HashCode *key_material);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_ecdh (const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
                          const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
                          struct GNUNET_HashCode *key_material);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_x25519_ecdh (const struct GNUNET_CRYPTO_EcdhePrivateKey *sk,
                           const struct GNUNET_CRYPTO_EcdhePublicKey *pk,
                           struct GNUNET_CRYPTO_EcdhePublicKey *dh);
 
 
enum GNUNET_CRYPTO_HpkeMode
{
  GNUNET_CRYPTO_HPKE_MODE_BASE = 0x00,
  GNUNET_CRYPTO_HPKE_MODE_PSK = 0x01,
  GNUNET_CRYPTO_HPKE_MODE_AUTH = 0x02,
  GNUNET_CRYPTO_HPKE_MODE_AUTH_PSK = 0x03
};
 
// Nt
#define GNUNET_CRYPTO_HPKE_AEAD_ID 0x0003
 
// Nn
#define GNUNET_CRYPTO_HPKE_NONCE_LEN 12
 
// Nk
#define GNUNET_CRYPTO_HPKE_KEY_LEN 32
 
// Nt
#define GNUNET_CRYPTO_HPKE_TAG_LEN 16
 
// Overhead required for ciphertext
#define GNUNET_CRYPTO_HPKE_SEAL_OVERHEAD_BYTES GNUNET_CRYPTO_HPKE_TAG_LEN
 
// Overhead required for ciphertext
#define GNUNET_CRYPTO_HPKE_SEAL_ONESHOT_OVERHEAD_BYTES \
        GNUNET_CRYPTO_HPKE_SEAL_OVERHEAD_BYTES   \
        + sizeof (struct GNUNET_CRYPTO_HpkeEncapsulation)
 
enum GNUNET_CRYPTO_HpkeRole
{
  // Receiver
  GNUNET_CRYPTO_HPKE_ROLE_R = 0,
  // Sender
  GNUNET_CRYPTO_HPKE_ROLE_S = 1
};
 
 
struct GNUNET_CRYPTO_HpkeContext
{
  // Participant role
  enum GNUNET_CRYPTO_HpkeRole role;
 
  // Encapsulated/Decapsulated key
  uint8_t key[GNUNET_CRYPTO_HPKE_KEY_LEN];
 
  // Base nonce
  uint8_t base_nonce[GNUNET_CRYPTO_HPKE_NONCE_LEN];
 
  // Sequence number
  uint64_t seq;
 
  // Exporter secret
  struct GNUNET_ShortHashCode exporter_secret;
};
 
enum GNUNET_CRYPTO_HpkeKem
{
  // Non-elligator X25519 KEM using HKDF256
  GNUNET_CRYPTO_HPKE_KEM_DH_X25519_HKDF256 = 0x0020,
  // Elligator X25519 KEM using HKDF256
  GNUNET_CRYPTO_HPKE_KEM_DH_X25519ELLIGATOR_HKDF256 = 0x0030,
};
 
 
struct GNUNET_CRYPTO_HpkeEncapsulation
{
  unsigned char q_y[256 / 8];
};
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_sk_to_x25519 (const struct
                                 GNUNET_CRYPTO_BlindablePrivateKey *sk,
                                 struct GNUNET_CRYPTO_HpkePrivateKey *sk_enc);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_pk_to_x25519 (const struct GNUNET_CRYPTO_BlindablePublicKey *
                                 pk,
                                 struct GNUNET_CRYPTO_HpkePublicKey *pk_enc);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_kem_decaps (const struct
                               GNUNET_CRYPTO_HpkePrivateKey *priv,
                               const struct GNUNET_CRYPTO_HpkeEncapsulation *c,
                               struct GNUNET_ShortHashCode *prk);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_kem_encaps (const struct GNUNET_CRYPTO_HpkePublicKey *pkR,
                               struct GNUNET_CRYPTO_HpkeEncapsulation *c,
                               struct GNUNET_ShortHashCode *prk);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_kem_encaps_norand (const struct
                                      GNUNET_CRYPTO_HpkePublicKey *pkR,
                                      struct GNUNET_CRYPTO_HpkeEncapsulation *c,
                                      const struct
                                      GNUNET_CRYPTO_HpkePrivateKey *skE,
                                      struct GNUNET_ShortHashCode *prk);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_elligator_kem_encaps_norand (
  uint8_t random_tweak,
  const struct GNUNET_CRYPTO_HpkePublicKey *pkR,
  struct GNUNET_CRYPTO_HpkeEncapsulation *c,
  const struct GNUNET_CRYPTO_ElligatorEcdhePrivateKey *skE,
  struct GNUNET_ShortHashCode *shared_secret);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_elligator_kem_encaps (
  const struct GNUNET_CRYPTO_HpkePublicKey *pkR,
  struct GNUNET_CRYPTO_HpkeEncapsulation *c,
  struct GNUNET_ShortHashCode *shared_secret);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_elligator_kem_decaps (
  const struct GNUNET_CRYPTO_HpkePrivateKey *skR,
  const struct GNUNET_CRYPTO_HpkeEncapsulation *c,
  struct GNUNET_ShortHashCode *shared_secret);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_kem_decaps (const struct
                                GNUNET_CRYPTO_EddsaPrivateKey *priv,
                                const struct GNUNET_CRYPTO_HpkeEncapsulation *c,
                                struct GNUNET_ShortHashCode *prk);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_kem_encaps (const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
                                struct GNUNET_CRYPTO_HpkeEncapsulation *c,
                                struct GNUNET_ShortHashCode *prk);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_sender_setup (const struct GNUNET_CRYPTO_HpkePublicKey *pkR,
                                 const uint8_t *info, size_t info_len,
                                 struct GNUNET_CRYPTO_HpkeEncapsulation *enc,
                                 struct GNUNET_CRYPTO_HpkeContext *ctx);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_sender_setup2 (
  enum GNUNET_CRYPTO_HpkeKem kem,
  enum GNUNET_CRYPTO_HpkeMode mode,
  struct GNUNET_CRYPTO_HpkePrivateKey *skE,
  struct GNUNET_CRYPTO_HpkePrivateKey *skS,
  const struct GNUNET_CRYPTO_HpkePublicKey *pkR,
  const uint8_t *info, size_t info_len,
  const uint8_t *psk, size_t psk_len,
  const uint8_t *psk_id, size_t psk_id_len,
  struct GNUNET_CRYPTO_HpkeEncapsulation *enc,
  struct GNUNET_CRYPTO_HpkeContext *ctx);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_receiver_setup2 (
  enum GNUNET_CRYPTO_HpkeKem kem,
  enum GNUNET_CRYPTO_HpkeMode mode,
  const struct GNUNET_CRYPTO_HpkeEncapsulation *enc,
  const struct GNUNET_CRYPTO_HpkePrivateKey *skR,
  const struct GNUNET_CRYPTO_HpkePublicKey *pkS,
  const uint8_t *info, size_t info_len,
  const uint8_t *psk, size_t psk_len,
  const uint8_t *psk_id, size_t psk_id_len,
  struct GNUNET_CRYPTO_HpkeContext *ctx);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_receiver_setup (
  const struct GNUNET_CRYPTO_HpkeEncapsulation *enc,
  const struct GNUNET_CRYPTO_HpkePrivateKey *skR,
  const uint8_t *info,
  size_t info_len,
  struct GNUNET_CRYPTO_HpkeContext *ctx);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_seal (struct GNUNET_CRYPTO_HpkeContext *ctx,
                         const uint8_t *aad,
                         size_t aad_len,
                         const uint8_t *pt,
                         size_t pt_len,
                         uint8_t *ct,
                         unsigned long long *ct_len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_seal_oneshot (const struct GNUNET_CRYPTO_HpkePublicKey *pkR,
                                 const uint8_t *info, size_t info_len,
                                 const uint8_t*aad, size_t aad_len,
                                 const uint8_t *pt, size_t pt_len,
                                 uint8_t *ct, unsigned long long *ct_len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_open (struct GNUNET_CRYPTO_HpkeContext *ctx,
                         const uint8_t*aad, size_t aad_len,
                         const uint8_t *ct, size_t ct_len,
                         uint8_t *pt, unsigned long long *pt_len_p);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_open_oneshot (
  const struct GNUNET_CRYPTO_HpkePrivateKey *skR,
  const uint8_t *info, size_t info_len,
  const uint8_t*aad, size_t aad_len,
  const uint8_t *ct, size_t ct_len,
  uint8_t *pt, unsigned long long *pt_len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdsa_ecdh (const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
                          const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
                          struct GNUNET_HashCode *key_material);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdh_eddsa (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
                          const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
                          struct GNUNET_HashCode *key_material);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdh_x25519 (const struct GNUNET_CRYPTO_EcdhePrivateKey *
                           priv,
                           const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
                           struct GNUNET_CRYPTO_EcdhePublicKey *dh);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdh_ecdsa (const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
                          const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
                          struct GNUNET_HashCode *key_material);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_sign_ (
  const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
  const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
  struct GNUNET_CRYPTO_EddsaSignature *sig);
 
 
#define GNUNET_CRYPTO_eddsa_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_CRYPTO_eddsa_sign_ (priv,                \
                                                    &(ps)->purpose,      \
                                                    sig));               \
} while (0)
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdsa_sign_ (
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
  const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
  struct GNUNET_CRYPTO_EcdsaSignature *sig);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_sign_raw (
  const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
  void *data,
  size_t size,
  struct GNUNET_CRYPTO_EddsaSignature *sig);
 
#define GNUNET_CRYPTO_ecdsa_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_CRYPTO_ecdsa_sign_ (priv,                \
                                                    &(ps)->purpose,      \
                                                    sig));               \
} while (0)
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_edx25519_sign_ (
  const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv,
  const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
  struct GNUNET_CRYPTO_Edx25519Signature *sig);
 
 
#define GNUNET_CRYPTO_edx25519_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_CRYPTO_edx25519_sign_ (priv,             \
                                                       &(ps)->purpose,   \
                                                       sig));            \
} while (0)
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_verify_ (
  uint32_t purpose,
  const struct GNUNET_CRYPTO_SignaturePurpose *validate,
  const struct GNUNET_CRYPTO_EddsaSignature *sig,
  const struct GNUNET_CRYPTO_EddsaPublicKey *pub);
 
 
#define GNUNET_CRYPTO_eddsa_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_CRYPTO_eddsa_verify_ (purp,                             \
                                 &(ps)->purpose,                   \
                                 sig,                              \
                                 pub);                             \
  })
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdsa_verify_ (
  uint32_t purpose,
  const struct GNUNET_CRYPTO_SignaturePurpose *validate,
  const struct GNUNET_CRYPTO_EcdsaSignature *sig,
  const struct GNUNET_CRYPTO_EcdsaPublicKey *pub);
 
 
#define GNUNET_CRYPTO_ecdsa_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_CRYPTO_ecdsa_verify_ (purp,                             \
                                 &(ps)->purpose,                   \
                                 sig,                              \
                                 pub);                             \
  })
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_edx25519_verify_ (
  uint32_t purpose,
  const struct GNUNET_CRYPTO_SignaturePurpose *validate,
  const struct GNUNET_CRYPTO_Edx25519Signature *sig,
  const struct GNUNET_CRYPTO_Edx25519PublicKey *pub);
 
 
#define GNUNET_CRYPTO_edx25519_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_CRYPTO_edx25519_verify_ (purp,                         \
                                    &(ps)->purpose,               \
                                    sig,                          \
                                    pub);                         \
  })
 
struct GNUNET_CRYPTO_EcdsaPrivateKey *
GNUNET_CRYPTO_ecdsa_private_key_derive (
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
  const char *label,
  const char *context);
 
 
void
GNUNET_CRYPTO_ecdsa_public_key_derive (
  const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
  const char *label,
  const char *context,
  struct GNUNET_CRYPTO_EcdsaPublicKey *result);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdsa_sign_derived (
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
  const char *label,
  const char *context,
  const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
  struct GNUNET_CRYPTO_EcdsaSignature *sig);
 
 
void
GNUNET_CRYPTO_eddsa_private_key_derive (
  const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
  const char *label,
  const char *context,
  struct GNUNET_CRYPTO_EddsaPrivateScalar *result);
 
 
void
GNUNET_CRYPTO_eddsa_public_key_derive (
  const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
  const char *label,
  const char *context,
  struct GNUNET_CRYPTO_EddsaPublicKey *result);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_eddsa_sign_derived (
  const struct GNUNET_CRYPTO_EddsaPrivateKey *pkey,
  const char *label,
  const char *context,
  const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
  struct GNUNET_CRYPTO_EddsaSignature *sig);
 
 
void
GNUNET_CRYPTO_eddsa_key_get_public_from_scalar (
  const struct GNUNET_CRYPTO_EddsaPrivateScalar *s,
  struct GNUNET_CRYPTO_EddsaPublicKey *pkey);
 
void
GNUNET_CRYPTO_edx25519_private_key_derive (
  const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv,
  const void *seed,
  size_t seedsize,
  struct GNUNET_CRYPTO_Edx25519PrivateKey *result);
 
 
void
GNUNET_CRYPTO_edx25519_public_key_derive (
  const struct GNUNET_CRYPTO_Edx25519PublicKey *pub,
  const void *seed,
  size_t seedsize,
  struct GNUNET_CRYPTO_Edx25519PublicKey *result);
 
 
void
GNUNET_CRYPTO_ecdhe_elligator_decoding (
  struct GNUNET_CRYPTO_EcdhePublicKey *point,
  bool *high_y,
  const struct GNUNET_CRYPTO_ElligatorRepresentative *representative);
 
 
bool
GNUNET_CRYPTO_ecdhe_elligator_encoding (
  uint8_t random_tweak,
  struct GNUNET_CRYPTO_ElligatorRepresentative *r,
  const struct GNUNET_CRYPTO_EcdhePublicKey *pub);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdhe_elligator_key_get_public_norand (
  uint8_t random_tweak,
  const struct GNUNET_CRYPTO_ElligatorEcdhePrivateKey *sk,
  struct GNUNET_CRYPTO_EcdhePublicKey *pub,
  struct GNUNET_CRYPTO_ElligatorRepresentative *repr);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_ecdhe_elligator_key_get_public (
  const struct GNUNET_CRYPTO_ElligatorEcdhePrivateKey *sk,
  struct GNUNET_CRYPTO_EcdhePublicKey *pub,
  struct GNUNET_CRYPTO_ElligatorRepresentative *repr);
 
 
void
GNUNET_CRYPTO_ecdhe_elligator_key_create (
  struct GNUNET_CRYPTO_ElligatorEcdhePrivateKey *sk);
 
 
void
GNUNET_CRYPTO_mpi_print_unsigned (void *buf,
                                  size_t size,
                                  gcry_mpi_t val);
 
 
void
GNUNET_CRYPTO_mpi_scan_unsigned (gcry_mpi_t *result,
                                 const void *data,
                                 size_t size);
 
 
void
GNUNET_CRYPTO_paillier_create (
  struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
  struct GNUNET_CRYPTO_PaillierPrivateKey *private_key);
 
 
int
GNUNET_CRYPTO_paillier_encrypt (
  const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
  const gcry_mpi_t m,
  int desired_ops,
  struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext);
 
 
void
GNUNET_CRYPTO_paillier_decrypt (
  const struct GNUNET_CRYPTO_PaillierPrivateKey *private_key,
  const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
  const struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext,
  gcry_mpi_t m);
 
 
int
GNUNET_CRYPTO_paillier_hom_add (
  const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
  const struct GNUNET_CRYPTO_PaillierCiphertext *c1,
  const struct GNUNET_CRYPTO_PaillierCiphertext *c2,
  struct GNUNET_CRYPTO_PaillierCiphertext *result);
 
 
int
GNUNET_CRYPTO_paillier_hom_get_remaining (
  const struct GNUNET_CRYPTO_PaillierCiphertext *c);
 
 
/* ********* Chaum-style RSA-based blind signatures ******************* */
 
 
struct GNUNET_CRYPTO_RsaPrivateKey;
 
struct GNUNET_CRYPTO_RsaPublicKey;
 
struct GNUNET_CRYPTO_RsaBlindingKeySecret
{
  uint32_t pre_secret[8] GNUNET_PACKED;
};
 
struct GNUNET_CRYPTO_RsaSignature;
 
 
struct GNUNET_CRYPTO_RsaPrivateKey *
GNUNET_CRYPTO_rsa_private_key_create (unsigned int len);
 
 
void
GNUNET_CRYPTO_rsa_private_key_free (struct GNUNET_CRYPTO_RsaPrivateKey *key);
 
 
size_t
GNUNET_CRYPTO_rsa_private_key_encode (
  const struct GNUNET_CRYPTO_RsaPrivateKey *key,
  void **buffer);
 
 
struct GNUNET_CRYPTO_RsaPrivateKey *
GNUNET_CRYPTO_rsa_private_key_decode (const void *buf,
                                      size_t buf_size);
 
 
struct GNUNET_CRYPTO_RsaPrivateKey *
GNUNET_CRYPTO_rsa_private_key_dup (
  const struct GNUNET_CRYPTO_RsaPrivateKey *key);
 
 
struct GNUNET_CRYPTO_RsaPublicKey *
GNUNET_CRYPTO_rsa_private_key_get_public (
  const struct GNUNET_CRYPTO_RsaPrivateKey *priv);
 
 
void
GNUNET_CRYPTO_rsa_public_key_hash (
  const struct GNUNET_CRYPTO_RsaPublicKey *key,
  struct GNUNET_HashCode *hc);
 
 
bool
GNUNET_CRYPTO_rsa_public_key_check (
  const struct GNUNET_CRYPTO_RsaPublicKey *key);
 
unsigned int
GNUNET_CRYPTO_rsa_public_key_len (const struct GNUNET_CRYPTO_RsaPublicKey *key);
 
 
void
GNUNET_CRYPTO_rsa_public_key_free (struct GNUNET_CRYPTO_RsaPublicKey *key);
 
 
size_t
GNUNET_CRYPTO_rsa_public_key_encode (
  const struct GNUNET_CRYPTO_RsaPublicKey *key,
  void **buffer);
 
 
struct GNUNET_CRYPTO_RsaPublicKey *
GNUNET_CRYPTO_rsa_public_key_decode (const char *buf,
                                     size_t len);
 
 
struct GNUNET_CRYPTO_RsaPublicKey *
GNUNET_CRYPTO_rsa_public_key_dup (const struct GNUNET_CRYPTO_RsaPublicKey *key);
 
 
int
GNUNET_CRYPTO_rsa_signature_cmp (const struct GNUNET_CRYPTO_RsaSignature *s1,
                                 const struct GNUNET_CRYPTO_RsaSignature *s2);
 
int
GNUNET_CRYPTO_rsa_private_key_cmp (
  const struct GNUNET_CRYPTO_RsaPrivateKey *p1,
  const struct GNUNET_CRYPTO_RsaPrivateKey *p2);
 
 
int
GNUNET_CRYPTO_rsa_public_key_cmp (const struct GNUNET_CRYPTO_RsaPublicKey *p1,
                                  const struct GNUNET_CRYPTO_RsaPublicKey *p2);
 
 
struct GNUNET_CRYPTO_RsaBlindedMessage
{
  void *blinded_msg;
 
  size_t blinded_msg_size;
};
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_rsa_blind (const void *message,
                         size_t message_size,
                         const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
                         struct GNUNET_CRYPTO_RsaPublicKey *pkey,
                         struct GNUNET_CRYPTO_RsaBlindedMessage *bm);
 
 
struct GNUNET_CRYPTO_RsaSignature *
GNUNET_CRYPTO_rsa_sign_blinded (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
                                const struct
                                GNUNET_CRYPTO_RsaBlindedMessage *bm);
 
 
struct GNUNET_CRYPTO_RsaSignature *
GNUNET_CRYPTO_rsa_sign_fdh (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
                            const void *message,
                            size_t message_size);
 
 
void
GNUNET_CRYPTO_rsa_blinded_message_free (
  struct GNUNET_CRYPTO_RsaBlindedMessage *bm);
 
 
void
GNUNET_CRYPTO_rsa_signature_free (struct GNUNET_CRYPTO_RsaSignature *sig);
 
 
size_t
GNUNET_CRYPTO_rsa_signature_encode (
  const struct GNUNET_CRYPTO_RsaSignature *sig,
  void **buffer);
 
 
struct GNUNET_CRYPTO_RsaSignature *
GNUNET_CRYPTO_rsa_signature_decode (
  const void *buf,
  size_t buf_size);
 
 
struct GNUNET_CRYPTO_RsaSignature *
GNUNET_CRYPTO_rsa_signature_dup (
  const struct GNUNET_CRYPTO_RsaSignature *sig);
 
 
struct GNUNET_CRYPTO_RsaSignature *
GNUNET_CRYPTO_rsa_unblind (const struct GNUNET_CRYPTO_RsaSignature *sig,
                           const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
                           struct GNUNET_CRYPTO_RsaPublicKey *pkey);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_rsa_verify (const void *message,
                          size_t message_size,
                          const struct GNUNET_CRYPTO_RsaSignature *sig,
                          const struct GNUNET_CRYPTO_RsaPublicKey *public_key);
 
 
void
GNUNET_CRYPTO_cs_private_key_generate (struct GNUNET_CRYPTO_CsPrivateKey *priv);
 
 
void
GNUNET_CRYPTO_cs_private_key_get_public (
  const struct GNUNET_CRYPTO_CsPrivateKey *priv,
  struct GNUNET_CRYPTO_CsPublicKey *pub);
 
 
void
GNUNET_CRYPTO_cs_r_derive (
  const struct GNUNET_CRYPTO_CsSessionNonce *nonce,
  const char *seed,
  const struct GNUNET_CRYPTO_CsPrivateKey *lts,
  struct GNUNET_CRYPTO_CsRSecret r[2]);
 
 
void
GNUNET_CRYPTO_cs_r_get_public (
  const struct GNUNET_CRYPTO_CsRSecret *r_priv,
  struct GNUNET_CRYPTO_CsRPublic *r_pub);
 
 
void
GNUNET_CRYPTO_cs_blinding_secrets_derive (
  const struct GNUNET_CRYPTO_CsBlindingNonce *blind_seed,
  struct GNUNET_CRYPTO_CsBlindingSecret bs[2]);
 
 
struct GNUNET_CRYPTO_CsBlindedMessage
{
  struct GNUNET_CRYPTO_CsC c[2];
 
  struct GNUNET_CRYPTO_CsSessionNonce nonce;
 
};
 
 
struct GNUNET_CRYPTO_CSPublicRPairP
{
  struct GNUNET_CRYPTO_CsRPublic r_pub[2];
};
 
 
void
GNUNET_CRYPTO_cs_calc_blinded_c (
  const struct GNUNET_CRYPTO_CsBlindingSecret bs[2],
  const struct GNUNET_CRYPTO_CsRPublic r_pub[2],
  const struct GNUNET_CRYPTO_CsPublicKey *pub,
  const void *msg,
  size_t msg_len,
  struct GNUNET_CRYPTO_CsC blinded_c[2],
  struct GNUNET_CRYPTO_CSPublicRPairP *r_pub_blind);
 
 
struct GNUNET_CRYPTO_CsBlindSignature
{
  unsigned int b;
 
  struct GNUNET_CRYPTO_CsBlindS s_scalar;
};
 
 
void
GNUNET_CRYPTO_cs_sign_derive (
  const struct GNUNET_CRYPTO_CsPrivateKey *priv,
  const struct GNUNET_CRYPTO_CsRSecret r[2],
  const struct GNUNET_CRYPTO_CsBlindedMessage *bm,
  struct GNUNET_CRYPTO_CsBlindSignature *cs_blind_sig);
 
 
void
GNUNET_CRYPTO_cs_unblind (
  const struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar,
  const struct GNUNET_CRYPTO_CsBlindingSecret *bs,
  struct GNUNET_CRYPTO_CsS *signature_scalar);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_cs_verify (
  const struct GNUNET_CRYPTO_CsSignature *sig,
  const struct GNUNET_CRYPTO_CsPublicKey *pub,
  const void *msg,
  size_t msg_len);
 
 
enum GNUNET_CRYPTO_BlindSignatureAlgorithm
{
 
  GNUNET_CRYPTO_BSA_INVALID = 0,
 
  GNUNET_CRYPTO_BSA_RSA = 1,
 
  GNUNET_CRYPTO_BSA_CS = 2
};
 
 
struct GNUNET_CRYPTO_UnblindedSignature
{
 
  enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher;
 
  unsigned int rc;
 
  union
  {
    struct GNUNET_CRYPTO_CsSignature cs_signature;
 
    struct GNUNET_CRYPTO_RsaSignature *rsa_signature;
 
  } details;
 
};
 
 
struct GNUNET_CRYPTO_BlindedSignature
{
 
  enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher;
 
  unsigned int rc;
 
  union
  {
    struct GNUNET_CRYPTO_CsBlindSignature blinded_cs_answer;
 
    struct GNUNET_CRYPTO_RsaSignature *blinded_rsa_signature;
 
  } details;
 
};
 
 
struct GNUNET_CRYPTO_BlindSignPublicKey
{
 
  enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher;
 
  unsigned int rc;
 
  struct GNUNET_HashCode pub_key_hash;
 
  union
  {
    struct GNUNET_CRYPTO_CsPublicKey cs_public_key;
 
    struct GNUNET_CRYPTO_RsaPublicKey *rsa_public_key;
 
  } details;
};
 
 
struct GNUNET_CRYPTO_BlindSignPrivateKey
{
 
  enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher;
 
  unsigned int rc;
 
  union
  {
    struct GNUNET_CRYPTO_CsPrivateKey cs_private_key;
 
    struct GNUNET_CRYPTO_RsaPrivateKey *rsa_private_key;
 
  } details;
};
 
 
struct GNUNET_CRYPTO_BlindedMessage
{
  enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher;
 
  unsigned int rc;
 
  union
  {
    struct GNUNET_CRYPTO_CsBlindedMessage cs_blinded_message;
 
    struct GNUNET_CRYPTO_RsaBlindedMessage rsa_blinded_message;
 
  } details;
};
 
 
struct GNUNET_CRYPTO_CSPrivateRPairP
{
  struct GNUNET_CRYPTO_CsRSecret r[2];
};
 
 
struct GNUNET_CRYPTO_BlindingInputValues
{
 
  enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher;
 
  unsigned int rc;
 
  union
  {
    struct GNUNET_CRYPTO_CSPublicRPairP cs_values;
 
  } details;
 
};
 
 
union GNUNET_CRYPTO_BlindSessionNonce
{
  struct GNUNET_CRYPTO_CsSessionNonce cs_nonce;
};
 
 
struct GNUNET_CRYPTO_BlindingInputValues *
GNUNET_CRYPTO_get_blinding_input_values (
  const struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv,
  const union GNUNET_CRYPTO_BlindSessionNonce *nonce,
  const char *salt);
 
 
void
GNUNET_CRYPTO_blind_sign_pub_decref (
  struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub);
 
 
void
GNUNET_CRYPTO_blind_sign_priv_decref (
  struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv);
 
 
void
GNUNET_CRYPTO_unblinded_sig_decref (
  struct GNUNET_CRYPTO_UnblindedSignature *ub_sig);
 
 
void
GNUNET_CRYPTO_blinded_sig_decref (
  struct GNUNET_CRYPTO_BlindedSignature *blind_sig);
 
 
void
GNUNET_CRYPTO_blinded_message_decref (
  struct GNUNET_CRYPTO_BlindedMessage *bm);
 
 
struct GNUNET_CRYPTO_BlindedMessage *
GNUNET_CRYPTO_blinded_message_incref (
  struct GNUNET_CRYPTO_BlindedMessage *bm);
 
 
struct GNUNET_CRYPTO_BlindingInputValues *
GNUNET_CRYPTO_blinding_input_values_incref (
  struct GNUNET_CRYPTO_BlindingInputValues *bm);
 
 
void
GNUNET_CRYPTO_blinding_input_values_decref (
  struct GNUNET_CRYPTO_BlindingInputValues *bm);
 
 
struct GNUNET_CRYPTO_BlindSignPublicKey *
GNUNET_CRYPTO_bsign_pub_incref (
  struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub);
 
 
struct GNUNET_CRYPTO_BlindSignPrivateKey *
GNUNET_CRYPTO_bsign_priv_incref (
  struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv);
 
 
struct GNUNET_CRYPTO_UnblindedSignature *
GNUNET_CRYPTO_ub_sig_incref (struct GNUNET_CRYPTO_UnblindedSignature *ub_sig);
 
 
struct GNUNET_CRYPTO_BlindedSignature *
GNUNET_CRYPTO_blind_sig_incref (
  struct GNUNET_CRYPTO_BlindedSignature *blind_sig);
 
 
int
GNUNET_CRYPTO_bsign_pub_cmp (
  const struct GNUNET_CRYPTO_BlindSignPublicKey *bp1,
  const struct GNUNET_CRYPTO_BlindSignPublicKey *bp2);
 
 
int
GNUNET_CRYPTO_ub_sig_cmp (const struct GNUNET_CRYPTO_UnblindedSignature *sig1,
                          const struct GNUNET_CRYPTO_UnblindedSignature *sig2);
 
 
int
GNUNET_CRYPTO_blind_sig_cmp (
  const struct GNUNET_CRYPTO_BlindedSignature *sig1,
  const struct GNUNET_CRYPTO_BlindedSignature *sig2);
 
 
int
GNUNET_CRYPTO_blinded_message_cmp (
  const struct GNUNET_CRYPTO_BlindedMessage *bp1,
  const struct GNUNET_CRYPTO_BlindedMessage *bp2);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blind_sign_keys_create (
  struct GNUNET_CRYPTO_BlindSignPrivateKey **bsign_priv,
  struct GNUNET_CRYPTO_BlindSignPublicKey **bsign_pub,
  enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher,
  ...);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blind_sign_keys_create_va (
  struct GNUNET_CRYPTO_BlindSignPrivateKey **bsign_priv,
  struct GNUNET_CRYPTO_BlindSignPublicKey **bsign_pub,
  enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher,
  va_list ap);
 
 
union GNUNET_CRYPTO_BlindingSecretP
{
  struct GNUNET_CRYPTO_CsBlindingNonce nonce;
 
  struct GNUNET_CRYPTO_RsaBlindingKeySecret rsa_bks;
};
 
 
struct GNUNET_CRYPTO_BlindedMessage *
GNUNET_CRYPTO_message_blind_to_sign (
  const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub,
  const union GNUNET_CRYPTO_BlindingSecretP *bks,
  const union GNUNET_CRYPTO_BlindSessionNonce *nonce,
  const void *message,
  size_t message_size,
  const struct GNUNET_CRYPTO_BlindingInputValues *alg_values);
 
 
struct GNUNET_CRYPTO_BlindedSignature *
GNUNET_CRYPTO_blind_sign (
  const struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv,
  const char *salt,
  const struct GNUNET_CRYPTO_BlindedMessage *blinded_message);
 
 
struct GNUNET_CRYPTO_UnblindedSignature *
GNUNET_CRYPTO_blind_sig_unblind (
  const struct GNUNET_CRYPTO_BlindedSignature *blinded_sig,
  const union GNUNET_CRYPTO_BlindingSecretP *bks,
  const void *message,
  size_t message_size,
  const struct GNUNET_CRYPTO_BlindingInputValues *alg_values,
  const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blind_sig_verify (
  const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub,
  const struct GNUNET_CRYPTO_UnblindedSignature *ub_sig,
  const void *message,
  size_t message_size);
 
 
ssize_t
GNUNET_CRYPTO_blindable_pk_get_length (
  const struct GNUNET_CRYPTO_BlindablePublicKey *key);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_read_blindable_pk_from_buffer (
  const void *buffer,
  size_t len,
  struct GNUNET_CRYPTO_BlindablePublicKey *key,
  size_t *read);
 
ssize_t
GNUNET_CRYPTO_blindable_sk_get_length (
  const struct GNUNET_CRYPTO_BlindablePrivateKey *key);
 
 
ssize_t
GNUNET_CRYPTO_write_blindable_pk_to_buffer (
  const struct GNUNET_CRYPTO_BlindablePublicKey *key,
  void*buffer,
  size_t len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_read_private_key_from_buffer (
  const void*buffer,
  size_t len,
  struct GNUNET_CRYPTO_BlindablePrivateKey *key,
  size_t *read);
 
 
ssize_t
GNUNET_CRYPTO_write_blindable_sk_to_buffer (
  const struct GNUNET_CRYPTO_BlindablePrivateKey *key,
  void*buffer,
  size_t len);
 
 
ssize_t
GNUNET_CRYPTO_blinded_key_signature_get_length (
  const struct GNUNET_CRYPTO_BlindableKeySignature *sig);
 
 
ssize_t
GNUNET_CRYPTO_blinded_key_signature_get_length_by_type (uint32_t type);
 
 
ssize_t
GNUNET_CRYPTO_read_blinded_key_signature_from_buffer (
  struct GNUNET_CRYPTO_BlindableKeySignature *sig,
  const void*buffer,
  size_t len);
 
 
ssize_t
GNUNET_CRYPTO_write_blinded_key_signature_to_buffer (
  const struct GNUNET_CRYPTO_BlindableKeySignature *sig,
  void*buffer,
  size_t len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blinded_key_sign_ (
  const struct GNUNET_CRYPTO_BlindablePrivateKey *priv,
  const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
  struct GNUNET_CRYPTO_BlindableKeySignature *sig);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blinded_key_sign_raw_ (
  const struct GNUNET_CRYPTO_BlindablePrivateKey *priv,
  const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
  unsigned char *sig);
 
 
#define GNUNET_CRYPTO_blinded_key_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_CRYPTO_blinded_key_sign_ (priv,               \
                                                          &(ps)->purpose,             \
                                                          sig));                      \
} while (0)
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blinded_key_signature_verify_ (
  uint32_t purpose,
  const struct GNUNET_CRYPTO_SignaturePurpose *validate,
  const struct GNUNET_CRYPTO_BlindableKeySignature *sig,
  const struct GNUNET_CRYPTO_BlindablePublicKey *pub);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blinded_key_signature_verify_raw_ (
  uint32_t purpose,
  const struct GNUNET_CRYPTO_SignaturePurpose *validate,
  const unsigned char *sig,
  const struct GNUNET_CRYPTO_BlindablePublicKey *pub);
 
 
#define GNUNET_CRYPTO_blinded_key_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_CRYPTO_blinded_key_signature_verify_ (purp,                              \
                                                 &(ps)->purpose,                    \
                                                 sig,                               \
                                                 pub);                              \
  })
 
 
char *
GNUNET_CRYPTO_blindable_public_key_to_string (
  const struct GNUNET_CRYPTO_BlindablePublicKey *key);
 
 
char *
GNUNET_CRYPTO_blindable_private_key_to_string (
  const struct GNUNET_CRYPTO_BlindablePrivateKey *key);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blindable_public_key_from_string (const char*str,
                                                struct
                                                GNUNET_CRYPTO_BlindablePublicKey
                                                *key);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blindable_private_key_from_string (const char*str,
                                                 struct
                                                 GNUNET_CRYPTO_BlindablePrivateKey
                                                 *key);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_blindable_key_get_public (const struct
                                        GNUNET_CRYPTO_BlindablePrivateKey *
                                        privkey,
                                        struct GNUNET_CRYPTO_BlindablePublicKey
                                        *key);
 
ssize_t
GNUNET_CRYPTO_hpke_pk_get_length (
  const struct GNUNET_CRYPTO_HpkePublicKey *key);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_read_hpke_pk_from_buffer (
  const void *buffer,
  size_t len,
  struct GNUNET_CRYPTO_HpkePublicKey *key,
  size_t *read);
 
ssize_t
GNUNET_CRYPTO_write_hpke_pk_to_buffer (
  const struct GNUNET_CRYPTO_HpkePublicKey *key,
  void*buffer,
  size_t len);
 
void
GNUNET_CRYPTO_hpke_sk_clear (struct GNUNET_CRYPTO_HpkePrivateKey *key);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_sk_create2 (enum GNUNET_CRYPTO_HpkeKeyType type,
                               const char *ikm,
                               size_t ikm_len,
                               struct GNUNET_CRYPTO_HpkePrivateKey *sk);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_sk_create (enum GNUNET_CRYPTO_HpkeKeyType type,
                              struct GNUNET_CRYPTO_HpkePrivateKey *pk);
 
ssize_t
GNUNET_CRYPTO_hpke_sk_get_length (const struct
                                  GNUNET_CRYPTO_HpkePrivateKey *key);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_read_hpke_sk_from_buffer (const void *buffer,
                                        size_t len,
                                        struct
                                        GNUNET_CRYPTO_HpkePrivateKey *
                                        key,
                                        size_t *read);
 
ssize_t
GNUNET_CRYPTO_write_hpke_sk_to_buffer (const struct
                                       GNUNET_CRYPTO_HpkePrivateKey *
                                       key,
                                       void *buffer,
                                       size_t len);
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hpke_sk_get_public (const struct
                                  GNUNET_CRYPTO_HpkePrivateKey *
                                  privkey,
                                  struct GNUNET_CRYPTO_HpkePublicKey
                                  *key);
 
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
 
/* ifndef GNUNET_CRYPTO_LIB_H */
#endif
 
 
/* end of gnunet_crypto_lib.h */