gnutls_cipher_hd_t

  typedef struct api_cipher_hd_st *gnutls_cipher_hd_t;

gnutls_cipher_init ()

int                 gnutls_cipher_init                  (gnutls_cipher_hd_t *handle,
                                                         gnutls_cipher_algorithm_t cipher,
                                                         const gnutls_datum_t *key,
                                                         const gnutls_datum_t *iv);

This function will initialize an context that can be used for encryption/decryption of data. This will effectively use the current crypto backend in use by gnutls or the cryptographic accelerator in use.

Since 2.10.0

gnutls_cipher_encrypt ()

int                 gnutls_cipher_encrypt               (const gnutls_cipher_hd_t handle,
                                                         void *text,
                                                         size_t textlen);

This function will encrypt the given data using the algorithm specified by the context.

Since 2.10.0

gnutls_cipher_decrypt ()

int                 gnutls_cipher_decrypt               (const gnutls_cipher_hd_t handle,
                                                         void *ciphertext,
                                                         size_t ciphertextlen);

This function will decrypt the given data using the algorithm specified by the context.

Since 2.10.0

gnutls_cipher_decrypt2 ()

int                 gnutls_cipher_decrypt2              (gnutls_cipher_hd_t handle,
                                                         const void *ciphertext,
                                                         size_t ciphertextlen,
                                                         void *text,
                                                         size_t textlen);

This function will decrypt the given data using the algorithm specified by the context.

Since 2.12.0

gnutls_cipher_encrypt2 ()

int                 gnutls_cipher_encrypt2              (gnutls_cipher_hd_t handle,
                                                         const void *text,
                                                         size_t textlen,
                                                         void *ciphertext,
                                                         size_t ciphertextlen);

This function will encrypt the given data using the algorithm specified by the context.

Since 2.12.0

gnutls_cipher_deinit ()

void                gnutls_cipher_deinit                (gnutls_cipher_hd_t handle);

This function will deinitialize all resources occupied by the given encryption context.

Since 2.10.0

gnutls_cipher_get_block_size ()

int                 gnutls_cipher_get_block_size        (gnutls_cipher_algorithm_t algorithm);

Get block size for encryption algorithm.

Since 2.10.0

gnutls_hash_hd_t

  typedef struct hash_hd_st *gnutls_hash_hd_t;

gnutls_hmac_hd_t

  typedef struct hmac_hd_st *gnutls_hmac_hd_t;

gnutls_hmac_init ()

int                 gnutls_hmac_init                    (gnutls_hmac_hd_t *dig,
                                                         gnutls_mac_algorithm_t algorithm,
                                                         const void *key,
                                                         size_t keylen);

This function will initialize an context that can be used to produce a Message Authentication Code (MAC) of data. This will effectively use the current crypto backend in use by gnutls or the cryptographic accelerator in use.

Since 2.10.0

gnutls_hmac ()

int                 gnutls_hmac                         (gnutls_hmac_hd_t handle,
                                                         const void *text,
                                                         size_t textlen);

This function will hash the given data using the algorithm specified by the context.

Since 2.10.0

gnutls_hmac_output ()

void                gnutls_hmac_output                  (gnutls_hmac_hd_t handle,
                                                         void *digest);

This function will output the current MAC value.

Since 2.10.0

gnutls_hmac_deinit ()

void                gnutls_hmac_deinit                  (gnutls_hmac_hd_t handle,
                                                         void *digest);

This function will deinitialize all resources occupied by the given hmac context.

Since 2.10.0

gnutls_hmac_get_len ()

int                 gnutls_hmac_get_len                 (gnutls_mac_algorithm_t algorithm);

This function will return the length of the output data of the given hmac algorithm.

Since 2.10.0

gnutls_hmac_fast ()

int                 gnutls_hmac_fast                    (gnutls_mac_algorithm_t algorithm,
                                                         const void *key,
                                                         size_t keylen,
                                                         const void *text,
                                                         size_t textlen,
                                                         void *digest);

This convenience function will hash the given data and return output on a single call.

Since 2.10.0

gnutls_hash_init ()

int                 gnutls_hash_init                    (gnutls_hash_hd_t *dig,
                                                         gnutls_digest_algorithm_t algorithm);

This function will initialize an context that can be used to produce a Message Digest of data. This will effectively use the current crypto backend in use by gnutls or the cryptographic accelerator in use.

Since 2.10.0

gnutls_hash ()

int                 gnutls_hash                         (gnutls_hash_hd_t handle,
                                                         const void *text,
                                                         size_t textlen);

This function will hash the given data using the algorithm specified by the context.

Since 2.10.0

gnutls_hash_output ()

void                gnutls_hash_output                  (gnutls_hash_hd_t handle,
                                                         void *digest);

This function will output the current hash value.

Since 2.10.0

gnutls_hash_deinit ()

void                gnutls_hash_deinit                  (gnutls_hash_hd_t handle,
                                                         void *digest);

This function will deinitialize all resources occupied by the given hash context.

Since 2.10.0

gnutls_hash_get_len ()

int                 gnutls_hash_get_len                 (gnutls_digest_algorithm_t algorithm);

This function will return the length of the output data of the given hash algorithm.

Since 2.10.0

gnutls_hash_fast ()

int                 gnutls_hash_fast                    (gnutls_digest_algorithm_t algorithm,
                                                         const void *text,
                                                         size_t textlen,
                                                         void *digest);

This convenience function will hash the given data and return output on a single call.

Since 2.10.0

gnutls_crypto_single_cipher_st

# define gnutls_crypto_single_cipher_st gnutls_crypto_cipher_st

gnutls_crypto_single_mac_st

# define gnutls_crypto_single_mac_st gnutls_crypto_mac_st

gnutls_crypto_single_digest_st

# define gnutls_crypto_single_digest_st gnutls_crypto_digest_st

init ()

int                 (*init)                             (gnutls_cipher_algorithm_t Param1,
                                                         void **ctx,
                                                         int enc);

setkey ()

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

setiv ()

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

encrypt ()

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

decrypt ()

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

deinit ()

void                (*deinit)                           (void *ctx);

hash ()

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

output ()

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

enum gnutls_rnd_level_t

typedef enum {
    GNUTLS_RND_NONCE = 0,
    GNUTLS_RND_RANDOM = 1,
    GNUTLS_RND_KEY = 2
} gnutls_rnd_level_t;

Enumeration of random quality levels.

gnutls_rnd ()

int                 gnutls_rnd                          (gnutls_rnd_level_t level,
                                                         void *data,
                                                         size_t len);

This function will generate random data and store it to output buffer.

Since 2.12.0

enum gnutls_pk_flag_t

typedef enum {
    GNUTLS_PK_FLAG_NONE = 0
} gnutls_pk_flag_t;

Enumeration of public-key flag.

rnd ()

int                 (*rnd)                              (void *ctx,
                                                         int level,
                                                         void *data,
                                                         size_t datasize);

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;

Enumeration of different bignum integer encoding formats.

bigint_new ()

bigint_t            (*bigint_new)                       (int nbits);

bigint_release ()

void                (*bigint_release)                   (bigint_t n);

bigint_cmp ()

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

bigint_cmp_ui ()

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

bigint_mod ()

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

bigint_set ()

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

bigint_set_ui ()

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

int ()

unsigned            int                                 ();

bigint_powm ()

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

bigint_addm ()

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

bigint_subm ()

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

bigint_mulm ()

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

bigint_mul ()

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

bigint_add_ui ()

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

bigint_sub_ui ()

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

bigint_mul_ui ()

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

bigint_div ()

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

bigint_prime_check ()

int                 (*bigint_prime_check)               (const bigint_t pp);

bigint_generate_group ()

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

bigint_scan ()

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

bigint_print ()

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

GNUTLS_MAX_PK_PARAMS

#define GNUTLS_MAX_PK_PARAMS 16

gnutls_pk_params_release ()

void                gnutls_pk_params_release            (gnutls_pk_params_st *p);

gnutls_pk_params_init ()

void                gnutls_pk_params_init               (gnutls_pk_params_st *p);

enum gnutls_direction_t

typedef enum {
    GNUTLS_IMPORT = 0,
    GNUTLS_EXPORT = 1
} gnutls_direction_t;

Enumeration of different directions.

sign ()

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

verify ()

int                 (*verify)                           (gnutls_pk_algorithm_t Param1,
                                                         const gnutls_datum_t *data,
                                                         const gnutls_datum_t *sig,
                                                         const gnutls_pk_params_st *pub);

generate ()

void                generate                            (unsigned int bits);

pk_fixup_private_params ()

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

gnutls_crypto_single_cipher_register ()

int                 gnutls_crypto_single_cipher_register
                                                        (gnutls_cipher_algorithm_t algorithm,
                                                         int priority,
                                                         const gnutls_crypto_single_cipher_st *s);

gnutls_crypto_single_mac_register ()

int                 gnutls_crypto_single_mac_register   (gnutls_mac_algorithm_t algorithm,
                                                         int priority,
                                                         const gnutls_crypto_single_mac_st *s);

gnutls_crypto_single_digest_register ()

int                 gnutls_crypto_single_digest_register
                                                        (gnutls_digest_algorithm_t algorithm,
                                                         int priority,
                                                         const gnutls_crypto_single_digest_st *s);

gnutls_crypto_cipher_register ()

int                 gnutls_crypto_cipher_register       (int priority,
                                                         const gnutls_crypto_cipher_st *s);

gnutls_crypto_mac_register ()

int                 gnutls_crypto_mac_register          (int priority,
                                                         const gnutls_crypto_mac_st *s);

gnutls_crypto_digest_register ()

int                 gnutls_crypto_digest_register       (int priority,
                                                         const gnutls_crypto_digest_st *s);

gnutls_crypto_rnd_register ()

int                 gnutls_crypto_rnd_register          (int priority,
                                                         const gnutls_crypto_rnd_st *s);

gnutls_crypto_pk_register ()

int                 gnutls_crypto_pk_register           (int priority,
                                                         const gnutls_crypto_pk_st *s);

gnutls_crypto_bigint_register ()

int                 gnutls_crypto_bigint_register       (int priority,
                                                         const gnutls_crypto_bigint_st *s);