crypto

crypto

Synopsis

#define             GNUTLS_CRYPTO_API_VERSION
int                 (*init)                             (void **ctx);
int                 (*setkey)                           (void *ctx,
                                                         const void *key,
                                                         size_t keysize);
int                 (*setiv)                            (void *ctx,
                                                         const void *iv,
                                                         size_t ivsize);
int                 (*encrypt)                          (void *ctx,
                                                         const void *plain,
                                                         size_t plainsize,
                                                         void *encr,
                                                         size_t encrsize);
int                 (*decrypt)                          (void *ctx,
                                                         const void *encr,
                                                         size_t encrsize,
                                                         void *plain,
                                                         size_t plainsize);
void                (*deinit)                           (void *ctx);
int                 (*hash)                             (void *ctx,
                                                         const void *text,
                                                         size_t textsize);
int                 (*copy)                             (void **dst_ctx,
                                                         void *src_ctx);
int                 (*output)                           (void *src_ctx,
                                                         void *digest,
                                                         size_t digestsize);
typedef             gnutls_crypto_single_digest_st;
typedef             gnutls_crypto_digest_st;
enum                gnutls_rnd_level_t;
enum                gnutls_pk_flag_t;
int                 (*rnd)                              (void *ctx);
typedef             bigint_t;
enum                gnutls_bigint_format_t;
bigint_t            (*bigint_new)                       (int nbits);
void                (*bigint_release)                   (bigint_t n);
int                 (*bigint_cmp)                       (const bigint_t m1,
                                                         const bigint_t m2);
int                 (*bigint_cmp_ui)                    (const bigint_t m1,
                                                         unsigned long  m2);
bigint_t            (*bigint_mod)                       (const bigint_t a,
                                                         const bigint_t b);
bigint_t            (*bigint_set)                       (bigint_t a,
                                                         const bigint_t b);
bigint_t            (*bigint_set_ui)                    (bigint_t a,
                                                         unsigned long  b);
unsigned            int                                 ();
bigint_t            (*bigint_powm)                      (bigint_t w,
                                                         const bigint_t b,
                                                         const bigint_t e,
                                                         const bigint_t m);
bigint_t            (*bigint_addm)                      (bigint_t w,
                                                         const bigint_t a,
                                                         const bigint_t b,
                                                         const bigint_t m);
bigint_t            (*bigint_subm)                      (bigint_t w,
                                                         const bigint_t a,
                                                         const bigint_t b,
                                                         const bigint_t m);
bigint_t            (*bigint_mulm)                      (bigint_t w,
                                                         const bigint_t a,
                                                         const bigint_t b,
                                                         const bigint_t m);
bigint_t            (*bigint_mul)                       (bigint_t w,
                                                         const bigint_t a,
                                                         const bigint_t b);
bigint_t            (*bigint_add_ui)                    (bigint_t w,
                                                         const bigint_t a,
                                                         unsigned long  b);
bigint_t            (*bigint_sub_ui)                    (bigint_t w,
                                                         const bigint_t a,
                                                         unsigned long  b);
bigint_t            (*bigint_mul_ui)                    (bigint_t w,
                                                         const bigint_t a,
                                                         unsigned long  b);
bigint_t            (*bigint_div)                       (bigint_t q,
                                                         const bigint_t a,
                                                         const bigint_t b);
int                 (*bigint_prime_check)               (const bigint_t pp);
int                 (*bigint_generate_group)            (gnutls_group_st *gg,
                                                         unsigned int bits);
bigint_t            (*bigint_scan)                      (const void *buf,
                                                         size_t buf_size,
                                                         gnutls_bigint_format_t format);
int                 (*bigint_print)                     (const bigint_t a,
                                                         void *buf,
                                                         size_t *buf_size,
                                                         gnutls_bigint_format_t format);
#define             GNUTLS_MAX_PK_PARAMS
void                gnutls_pk_params_release            (gnutls_pk_params_st *p);
void                gnutls_pk_params_init               (gnutls_pk_params_st *p);
enum                gnutls_direction_t;
int                 (*sign)                             (gnutls_pk_algorithm_t Param1,
                                                         gnutls_datum_t *signature,
                                                         const gnutls_datum_t *data);
int                 (*verify)                           (gnutls_pk_algorithm_t Param1,
                                                         const gnutls_datum_t *data,
                                                         const gnutls_datum_t *signature);
int                 (*generate)                         (gnutls_pk_algorithm_t Param1);
int                 (*pk_fixup_private_params)          (gnutls_pk_algorithm_t Param1,
                                                         gnutls_direction_t Param2,
                                                         gnutls_pk_params_st *Param3);
#define             gnutls_crypto_single_cipher_register(algo,
                                                         prio,
                                                         st)
#define             gnutls_crypto_single_mac_register   (algo,
                                                         prio,
                                                         st)
#define             gnutls_crypto_single_digest_register(algo,
                                                         prio,
                                                         st)
int                 gnutls_crypto_single_cipher_register2
                                                        (gnutls_cipher_algorithm_t algorithm,
                                                         int priority,
                                                         int version,
                                                         gnutls_crypto_single_cipher_st *s);
int                 gnutls_crypto_single_mac_register2  (gnutls_mac_algorithm_t algorithm,
                                                         int priority,
                                                         int version,
                                                         gnutls_crypto_single_mac_st *s);
int                 gnutls_crypto_single_digest_register2
                                                        (gnutls_digest_algorithm_t algorithm,
                                                         int priority,
                                                         int version,
                                                         gnutls_crypto_single_digest_st *s);
#define             gnutls_crypto_cipher_register       (prio,
                                                         st)
#define             gnutls_crypto_mac_register          (prio,
                                                         st)
#define             gnutls_crypto_digest_register       (prio,
                                                         st)
int                 gnutls_crypto_cipher_register2      (int priority,
                                                         int version,
                                                         gnutls_crypto_cipher_st *s);
int                 gnutls_crypto_mac_register2         (int priority,
                                                         int version,
                                                         gnutls_crypto_mac_st *s);
int                 gnutls_crypto_digest_register2      (int priority,
                                                         int version,
                                                         gnutls_crypto_digest_st *s);
#define             gnutls_crypto_rnd_register          (prio,
                                                         st)
#define             gnutls_crypto_pk_register           (prio,
                                                         st)
#define             gnutls_crypto_bigint_register       (prio,
                                                         st)
int                 gnutls_crypto_rnd_register2         (int priority,
                                                         int version,
                                                         gnutls_crypto_rnd_st *s);
int                 gnutls_crypto_pk_register2          (int priority,
                                                         int version,
                                                         gnutls_crypto_pk_st *s);
int                 gnutls_crypto_bigint_register2      (int priority,
                                                         int version,
                                                         gnutls_crypto_bigint_st *s);

Description

Details

GNUTLS_CRYPTO_API_VERSION

# define GNUTLS_CRYPTO_API_VERSION 0x01


init ()

int                 (*init)                             (void **ctx);

ctx :

Returns :


setkey ()

int                 (*setkey)                           (void *ctx,
                                                         const void *key,
                                                         size_t keysize);

ctx :

key :

keysize :

Returns :


setiv ()

int                 (*setiv)                            (void *ctx,
                                                         const void *iv,
                                                         size_t ivsize);

ctx :

iv :

ivsize :

Returns :


encrypt ()

int                 (*encrypt)                          (void *ctx,
                                                         const void *plain,
                                                         size_t plainsize,
                                                         void *encr,
                                                         size_t encrsize);

ctx :

plain :

plainsize :

encr :

encrsize :

Returns :


decrypt ()

int                 (*decrypt)                          (void *ctx,
                                                         const void *encr,
                                                         size_t encrsize,
                                                         void *plain,
                                                         size_t plainsize);

ctx :

encr :

encrsize :

plain :

plainsize :

Returns :


deinit ()

void                (*deinit)                           (void *ctx);

ctx :


hash ()

int                 (*hash)                             (void *ctx,
                                                         const void *text,
                                                         size_t textsize);

ctx :

text :

textsize :

Returns :


copy ()

int                 (*copy)                             (void **dst_ctx,
                                                         void *src_ctx);

dst_ctx :

src_ctx :

Returns :


output ()

int                 (*output)                           (void *src_ctx,
                                                         void *digest,
                                                         size_t digestsize);

src_ctx :

digest :

digestsize :

Returns :


gnutls_crypto_single_digest_st

typedef gnutls_crypto_single_mac_st gnutls_crypto_single_digest_st;


gnutls_crypto_digest_st

typedef gnutls_crypto_mac_st gnutls_crypto_digest_st;


enum gnutls_rnd_level_t

typedef enum gnutls_rnd_level
{
  /* fatal in parts of session if broken, i.e., vulnerable to
     statistical analysis */
  GNUTLS_RND_NONCE = 0,
  /* fatal in session if broken */
  GNUTLS_RND_RANDOM = 1,
  /* fatal in many sessions if broken */
  GNUTLS_RND_KEY = 2
} gnutls_rnd_level_t;


enum gnutls_pk_flag_t

typedef enum
{
  GNUTLS_PK_FLAG_NONE = 0
} gnutls_pk_flag_t;


rnd ()

int                 (*rnd)                              (void *ctx);

ctx :

Returns :


bigint_t

typedef void *bigint_t;


enum gnutls_bigint_format_t

typedef enum
{
  /* raw unsigned integer format */
  GNUTLS_MPI_FORMAT_USG = 0,
  /* raw signed integer format - always a leading zero when positive */
  GNUTLS_MPI_FORMAT_STD = 1,
  /* the pgp integer format */
  GNUTLS_MPI_FORMAT_PGP = 2
} gnutls_bigint_format_t;


bigint_new ()

bigint_t            (*bigint_new)                       (int nbits);

nbits :

Returns :


bigint_release ()

void                (*bigint_release)                   (bigint_t n);

n :


bigint_cmp ()

int                 (*bigint_cmp)                       (const bigint_t m1,
                                                         const bigint_t m2);

m1 :

m2 :

Returns :


bigint_cmp_ui ()

int                 (*bigint_cmp_ui)                    (const bigint_t m1,
                                                         unsigned long  m2);

m1 :

m2 :

Returns :


bigint_mod ()

bigint_t            (*bigint_mod)                       (const bigint_t a,
                                                         const bigint_t b);

a :

b :

Returns :


bigint_set ()

bigint_t            (*bigint_set)                       (bigint_t a,
                                                         const bigint_t b);

a :

b :

Returns :


bigint_set_ui ()

bigint_t            (*bigint_set_ui)                    (bigint_t a,
                                                         unsigned long  b);

a :

b :

Returns :


int ()

unsigned            int                                 ();

Returns :


bigint_powm ()

bigint_t            (*bigint_powm)                      (bigint_t w,
                                                         const bigint_t b,
                                                         const bigint_t e,
                                                         const bigint_t m);

w :

b :

e :

m :

Returns :


bigint_addm ()

bigint_t            (*bigint_addm)                      (bigint_t w,
                                                         const bigint_t a,
                                                         const bigint_t b,
                                                         const bigint_t m);

w :

a :

b :

m :

Returns :


bigint_subm ()

bigint_t            (*bigint_subm)                      (bigint_t w,
                                                         const bigint_t a,
                                                         const bigint_t b,
                                                         const bigint_t m);

w :

a :

b :

m :

Returns :


bigint_mulm ()

bigint_t            (*bigint_mulm)                      (bigint_t w,
                                                         const bigint_t a,
                                                         const bigint_t b,
                                                         const bigint_t m);

w :

a :

b :

m :

Returns :


bigint_mul ()

bigint_t            (*bigint_mul)                       (bigint_t w,
                                                         const bigint_t a,
                                                         const bigint_t b);

w :

a :

b :

Returns :


bigint_add_ui ()

bigint_t            (*bigint_add_ui)                    (bigint_t w,
                                                         const bigint_t a,
                                                         unsigned long  b);

w :

a :

b :

Returns :


bigint_sub_ui ()

bigint_t            (*bigint_sub_ui)                    (bigint_t w,
                                                         const bigint_t a,
                                                         unsigned long  b);

w :

a :

b :

Returns :


bigint_mul_ui ()

bigint_t            (*bigint_mul_ui)                    (bigint_t w,
                                                         const bigint_t a,
                                                         unsigned long  b);

w :

a :

b :

Returns :


bigint_div ()

bigint_t            (*bigint_div)                       (bigint_t q,
                                                         const bigint_t a,
                                                         const bigint_t b);

q :

a :

b :

Returns :


bigint_prime_check ()

int                 (*bigint_prime_check)               (const bigint_t pp);

pp :

Returns :


bigint_generate_group ()

int                 (*bigint_generate_group)            (gnutls_group_st *gg,
                                                         unsigned int bits);

gg :

bits :

Returns :


bigint_scan ()

bigint_t            (*bigint_scan)                      (const void *buf,
                                                         size_t buf_size,
                                                         gnutls_bigint_format_t format);

buf :

buf_size :

format :

Returns :


bigint_print ()

int                 (*bigint_print)                     (const bigint_t a,
                                                         void *buf,
                                                         size_t *buf_size,
                                                         gnutls_bigint_format_t format);

a :

buf :

buf_size :

format :

Returns :


GNUTLS_MAX_PK_PARAMS

#define GNUTLS_MAX_PK_PARAMS 6


gnutls_pk_params_release ()

void                gnutls_pk_params_release            (gnutls_pk_params_st *p);

p :


gnutls_pk_params_init ()

void                gnutls_pk_params_init               (gnutls_pk_params_st *p);

p :


enum gnutls_direction_t

typedef enum
{
  GNUTLS_IMPORT,
  GNUTLS_EXPORT
} gnutls_direction_t;


sign ()

int                 (*sign)                             (gnutls_pk_algorithm_t Param1,
                                                         gnutls_datum_t *signature,
                                                         const gnutls_datum_t *data);

Param1 :

signature :

data :

Returns :


verify ()

int                 (*verify)                           (gnutls_pk_algorithm_t Param1,
                                                         const gnutls_datum_t *data,
                                                         const gnutls_datum_t *signature);

Param1 :

data :

signature :

Returns :


generate ()

int                 (*generate)                         (gnutls_pk_algorithm_t Param1);

Param1 :

Returns :


pk_fixup_private_params ()

int                 (*pk_fixup_private_params)          (gnutls_pk_algorithm_t Param1,
                                                         gnutls_direction_t Param2,
                                                         gnutls_pk_params_st *Param3);

Param1 :

Param2 :

Param3 :

Returns :


gnutls_crypto_single_cipher_register()

#define             gnutls_crypto_single_cipher_register(algo, prio, st)

algo :

prio :

st :


gnutls_crypto_single_mac_register()

#define             gnutls_crypto_single_mac_register(algo, prio, st)

algo :

prio :

st :


gnutls_crypto_single_digest_register()

#define             gnutls_crypto_single_digest_register(algo, prio, st)

algo :

prio :

st :


gnutls_crypto_single_cipher_register2 ()

int                 gnutls_crypto_single_cipher_register2
                                                        (gnutls_cipher_algorithm_t algorithm,
                                                         int priority,
                                                         int version,
                                                         gnutls_crypto_single_cipher_st *s);

algorithm :

priority :

version :

s :

Returns :


gnutls_crypto_single_mac_register2 ()

int                 gnutls_crypto_single_mac_register2  (gnutls_mac_algorithm_t algorithm,
                                                         int priority,
                                                         int version,
                                                         gnutls_crypto_single_mac_st *s);

algorithm :

priority :

version :

s :

Returns :


gnutls_crypto_single_digest_register2 ()

int                 gnutls_crypto_single_digest_register2
                                                        (gnutls_digest_algorithm_t algorithm,
                                                         int priority,
                                                         int version,
                                                         gnutls_crypto_single_digest_st *s);

algorithm :

priority :

version :

s :

Returns :


gnutls_crypto_cipher_register()

#define             gnutls_crypto_cipher_register(prio, st)

prio :

st :


gnutls_crypto_mac_register()

#define             gnutls_crypto_mac_register(prio, st)

prio :

st :


gnutls_crypto_digest_register()

#define             gnutls_crypto_digest_register(prio, st)

prio :

st :


gnutls_crypto_cipher_register2 ()

int                 gnutls_crypto_cipher_register2      (int priority,
                                                         int version,
                                                         gnutls_crypto_cipher_st *s);

priority :

version :

s :

Returns :


gnutls_crypto_mac_register2 ()

int                 gnutls_crypto_mac_register2         (int priority,
                                                         int version,
                                                         gnutls_crypto_mac_st *s);

priority :

version :

s :

Returns :


gnutls_crypto_digest_register2 ()

int                 gnutls_crypto_digest_register2      (int priority,
                                                         int version,
                                                         gnutls_crypto_digest_st *s);

priority :

version :

s :

Returns :


gnutls_crypto_rnd_register()

#define             gnutls_crypto_rnd_register(prio, st)

prio :

st :


gnutls_crypto_pk_register()

#define             gnutls_crypto_pk_register(prio, st)

prio :

st :


gnutls_crypto_bigint_register()

#define             gnutls_crypto_bigint_register(prio, st)

prio :

st :


gnutls_crypto_rnd_register2 ()

int                 gnutls_crypto_rnd_register2         (int priority,
                                                         int version,
                                                         gnutls_crypto_rnd_st *s);

priority :

version :

s :

Returns :


gnutls_crypto_pk_register2 ()

int                 gnutls_crypto_pk_register2          (int priority,
                                                         int version,
                                                         gnutls_crypto_pk_st *s);

priority :

version :

s :

Returns :


gnutls_crypto_bigint_register2 ()

int                 gnutls_crypto_bigint_register2      (int priority,
                                                         int version,
                                                         gnutls_crypto_bigint_st *s);

priority :

version :

s :

Returns :