gnunet_crypto_lib.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2001-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
 */
 
#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 <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_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_EccSignaturePurpose
{
  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_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_CsNonce
{
  /*a nonce*/
  unsigned char nonce[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);
 
 
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);
 
 
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_symmetric_derive_iv (
  struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
  const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
  const void *salt,
  size_t salt_len,
  ...);
 
 
void
GNUNET_CRYPTO_symmetric_derive_iv_v (
  struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
  const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
  const void *salt,
  size_t salt_len,
  va_list argp);
 
 
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);
 
 
void
GNUNET_CRYPTO_hmac_derive_key_v (
  struct GNUNET_CRYPTO_AuthKey *key,
  const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
  const void *salt,
  size_t salt_len,
  va_list argp);
 
 
void
GNUNET_CRYPTO_hmac_derive_key (
  struct GNUNET_CRYPTO_AuthKey *key,
  const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
  const void *salt,
  size_t salt_len,
  ...);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hkdf (void *result,
                    size_t out_len,
                    int xtr_algo,
                    int prf_algo,
                    const void *xts,
                    size_t xts_len,
                    const void *skm,
                    size_t skm_len,
                    ...);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_hkdf_v (void *result,
                      size_t out_len,
                      int xtr_algo,
                      int prf_algo,
                      const void *xts,
                      size_t xts_len,
                      const void *skm,
                      size_t skm_len,
                      va_list argp);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_kdf_v (void *result,
                     size_t out_len,
                     const void *xts,
                     size_t xts_len,
                     const void *skm,
                     size_t skm_len,
                     va_list argp);
 
 
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);
 
 
enum GNUNET_GenericReturnValue
GNUNET_CRYPTO_kdf (void *result,
                   size_t out_len,
                   const void *xts,
                   size_t xts_len,
                   const void *skm,
                   size_t skm_len,
                   ...);
 
 
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);
 
 
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);
 
 
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_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_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_EccSignaturePurpose *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_EccSignaturePurpose *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_EccSignaturePurpose *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_EccSignaturePurpose *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_EccSignaturePurpose *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_EccSignaturePurpose *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_EccSignaturePurpose *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_EccSignaturePurpose *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_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);
 
 
int
GNUNET_CRYPTO_rsa_blind (const struct GNUNET_HashCode *hash,
                         const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
                         struct GNUNET_CRYPTO_RsaPublicKey *pkey,
                         void **buf,
                         size_t *buf_size);
 
 
struct GNUNET_CRYPTO_RsaSignature *
GNUNET_CRYPTO_rsa_sign_blinded (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
                                const void *msg,
                                size_t msg_len);
 
 
struct GNUNET_CRYPTO_RsaSignature *
GNUNET_CRYPTO_rsa_sign_fdh (const struct GNUNET_CRYPTO_RsaPrivateKey *key,
                            const struct GNUNET_HashCode *hash);
 
 
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 struct GNUNET_HashCode *hash,
                          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_CsNonce *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_CsNonce *blind_seed,
  struct GNUNET_CRYPTO_CsBlindingSecret bs[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_CsRPublic blinded_r_pub[2]);
 
 
unsigned int
GNUNET_CRYPTO_cs_sign_derive (
  const struct GNUNET_CRYPTO_CsPrivateKey *priv,
  const struct GNUNET_CRYPTO_CsRSecret r[2],
  const struct GNUNET_CRYPTO_CsC c[2],
  const struct GNUNET_CRYPTO_CsNonce *nonce,
  struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar);
 
 
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);
 
 
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
 
/* ifndef GNUNET_CRYPTO_LIB_H */
#endif
 /* end of group addition */
 
/* end of gnunet_crypto_lib.h */