mirrors/libmicrohttpd
2
0 Fork 0
mirror of https://git.gnunet.org/libmicrohttpd.git synced 2026-10-07 04:02:18 +03:00
Code Issues Packages Projects Releases Wiki Activity

mega-renaming to avoid exporting symbols not starting with MHD

Browse Source
This commit is contained in:
Christian Grothoff committed 2008-10-09 21:26:26 +00:00
1 parent 7ba36f02ae
commit 6ff7b62145
156 files changed
+9535 -9575
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/daemon/https/gnutls.h
+340 -340
View File
@@ -60,7 +60,7 @@ extern "C"
{
GNUTLS_PARAMS_RSA_EXPORT = 1,
GNUTLS_PARAMS_DH
} gnutls_params_type_t;
} MHD_gnutls_params_type_t;
/* exported for other gnutls headers. This is the maximum number of
* algorithms (ciphers, kx or macs).
@@ -72,13 +72,13 @@ extern "C"
{
GNUTLS_SERVER = 1,
GNUTLS_CLIENT
} gnutls_connection_end_t;
} MHD_gnutls_connection_end_t;
typedef enum
{
GNUTLS_AL_WARNING = 1,
GNUTLS_AL_FATAL
} gnutls_alert_level_t;
} MHD_gnutls_alert_level_t;
typedef enum
{
@@ -110,7 +110,7 @@ extern "C"
GNUTLS_A_CERTIFICATE_UNOBTAINABLE = 111,
GNUTLS_A_UNRECOGNIZED_NAME = 112,
GNUTLS_A_UNKNOWN_PSK_IDENTITY = 115,
} gnutls_alert_description_t;
} MHD_gnutls_alert_description_t;
typedef enum
{ GNUTLS_HANDSHAKE_HELLO_REQUEST = 0,
@@ -124,7 +124,7 @@ extern "C"
GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE = 16,
GNUTLS_HANDSHAKE_FINISHED = 20,
GNUTLS_HANDSHAKE_SUPPLEMENTAL = 23
} gnutls_handshake_description_t;
} MHD_gnutls_handshake_description_t;
typedef enum
{
@@ -141,26 +141,26 @@ extern "C"
GNUTLS_CERT_SIGNER_NOT_FOUND = 64,
GNUTLS_CERT_SIGNER_NOT_CA = 128,
GNUTLS_CERT_INSECURE_ALGORITHM = 256
} gnutls_certificate_status_t;
} MHD_gnutls_certificate_status_t;
typedef enum
{
GNUTLS_CERT_IGNORE,
GNUTLS_CERT_REQUEST = 1,
GNUTLS_CERT_REQUIRE
} gnutls_certificate_request_t;
} MHD_gnutls_certificate_request_t;
typedef enum
{
GNUTLS_SHUT_RDWR = 0,
GNUTLS_SHUT_WR = 1
} gnutls_close_request_t;
} MHD_gnutls_close_request_t;
typedef enum
{
GNUTLS_X509_FMT_DER,
GNUTLS_X509_FMT_PEM
} gnutls_x509_crt_fmt_t;
} MHD_gnutls_x509_crt_fmt_t;
typedef enum
{
@@ -173,92 +173,92 @@ extern "C"
GNUTLS_SIGN_RSA_SHA256,
GNUTLS_SIGN_RSA_SHA384,
GNUTLS_SIGN_RSA_SHA512
} gnutls_sign_algorithm_t;
} MHD_gnutls_sign_algorithm_t;
/* If you want to change this, then also change the define in
* gnutls_int.h, and recompile.
* MHD_gnutls_int.h, and recompile.
*/
typedef void *gnutls_transport_ptr_t;
typedef void *MHD_gnutls_transport_ptr_t;
struct MHD_gtls_session_int;
typedef struct MHD_gtls_session_int *mhd_gtls_session_t;
typedef struct MHD_gtls_session_int *MHD_gtls_session_t;
struct MHD_gtls_dh_params_int;
typedef struct MHD_gtls_dh_params_int *mhd_gtls_dh_params_t;
typedef struct MHD_gtls_dh_params_int *MHD_gtls_dh_params_t;
struct MHD_gtls_x509_privkey_int; /* XXX ugly. */
typedef struct MHD_gtls_x509_privkey_int *mhd_gtls_rsa_params_t; /* XXX ugly. */
typedef struct MHD_gtls_x509_privkey_int *MHD_gtls_rsa_params_t; /* XXX ugly. */
struct MHD_gtls_priority_st;
typedef struct MHD_gtls_priority_st *gnutls_priority_t;
typedef struct MHD_gtls_priority_st *MHD_gnutls_priority_t;
typedef struct
{
unsigned char *data;
unsigned int size;
} gnutls_datum_t;
} MHD_gnutls_datum_t;
typedef struct gnutls_params_st
typedef struct MHD_gnutls_params_st
{
gnutls_params_type_t type;
MHD_gnutls_params_type_t type;
union params
{
mhd_gtls_dh_params_t dh;
mhd_gtls_rsa_params_t rsa_export;
MHD_gtls_dh_params_t dh;
MHD_gtls_rsa_params_t rsa_export;
} params;
int deinit;
} gnutls_params_st;
} MHD_gnutls_params_st;
typedef int gnutls_params_function (mhd_gtls_session_t,
gnutls_params_type_t,
gnutls_params_st *);
typedef int MHD_gnutls_params_function (MHD_gtls_session_t,
MHD_gnutls_params_type_t,
MHD_gnutls_params_st *);
/* internal functions */
int MHD_gnutls_global_init (void);
void MHD_gnutls_global_deinit (void);
int MHD__gnutls_global_init (void);
void MHD__gnutls_global_deinit (void);
int MHD_gnutls_init (mhd_gtls_session_t * session,
gnutls_connection_end_t con_end);
void MHD_gnutls_deinit (mhd_gtls_session_t session);
int MHD__gnutls_init (MHD_gtls_session_t * session,
MHD_gnutls_connection_end_t con_end);
void MHD__gnutls_deinit (MHD_gtls_session_t session);
int MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how);
int MHD_gnutls_handshake (mhd_gtls_session_t session);
int MHD_gnutls_rehandshake (mhd_gtls_session_t session);
int MHD__gnutls_bye (MHD_gtls_session_t session, MHD_gnutls_close_request_t how);
int MHD__gnutls_handshake (MHD_gtls_session_t session);
int MHD__gnutls_rehandshake (MHD_gtls_session_t session);
int mhd_gtls_handshake_client (mhd_gtls_session_t session);
int MHD_gtls_handshake_client (MHD_gtls_session_t session);
gnutls_alert_description_t gnutls_alert_get (mhd_gtls_session_t session);
int MHD_gnutls_alert_send (mhd_gtls_session_t session,
gnutls_alert_level_t level,
gnutls_alert_description_t desc);
int MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err);
const char *MHD_gnutls_alert_get_name (gnutls_alert_description_t alert);
MHD_gnutls_alert_description_t MHD_gnutls_alert_get (MHD_gtls_session_t session);
int MHD__gnutls_alert_send (MHD_gtls_session_t session,
MHD_gnutls_alert_level_t level,
MHD_gnutls_alert_description_t desc);
int MHD__gnutls_alert_send_appropriate (MHD_gtls_session_t session, int err);
const char *MHD__gnutls_alert_get_name (MHD_gnutls_alert_description_t alert);
enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get (mhd_gtls_session_t
enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get (MHD_gtls_session_t
session);
// enum MHD_GNUTLS_CipherAlgorithm gnutls_cipher_get (mhd_gtls_session_t session);
// enum MHD_GNUTLS_KeyExchangeAlgorithm gnutls_kx_get (mhd_gtls_session_t session);
// enum MHD_GNUTLS_HashAlgorithm gnutls_mac_get (mhd_gtls_session_t session);
// enum MHD_GNUTLS_CertificateType gnutls_certificate_type_get (mhd_gtls_session_t
// enum MHD_GNUTLS_CipherAlgorithm MHD_gnutls_cipher_get (MHD_gtls_session_t session);
// enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gnutls_kx_get (MHD_gtls_session_t session);
// enum MHD_GNUTLS_HashAlgorithm MHD_gnutls_mac_get (MHD_gtls_session_t session);
// enum MHD_GNUTLS_CertificateType MHD_gnutls_certificate_type_get (MHD_gtls_session_t
// session);
size_t MHD_gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm
size_t MHD__gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm
algorithm);
size_t MHD_gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm
size_t MHD__gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm
algorithm);
/* the name of the specified algorithms */
const char *MHD_gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm
const char *MHD__gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm
algorithm);
const char *MHD_gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm
const char *MHD__gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm
algorithm);
const char *MHD_gtls_compression_get_name (enum
MHD_GNUTLS_CompressionMethod
algorithm);
const char *MHD_gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm
const char *MHD__gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm
algorithm);
const char *MHD_gnutls_certificate_type_get_name (enum
const char *MHD__gnutls_certificate_type_get_name (enum
MHD_GNUTLS_CertificateType
type);
@@ -286,38 +286,38 @@ extern "C"
void MHD_gtls_perror (int error);
const char *MHD_gtls_strerror (int error);
void MHD_gtls_handshake_set_private_extensions (mhd_gtls_session_t session,
void MHD_gtls_handshake_set_private_extensions (MHD_gtls_session_t session,
int allow);
gnutls_handshake_description_t
MHD_gtls_handshake_get_last_out (mhd_gtls_session_t session);
gnutls_handshake_description_t
MHD_gtls_handshake_get_last_in (mhd_gtls_session_t session);
MHD_gnutls_handshake_description_t
MHD_gtls_handshake_get_last_out (MHD_gtls_session_t session);
MHD_gnutls_handshake_description_t
MHD_gtls_handshake_get_last_in (MHD_gtls_session_t session);
/*
* Record layer functions.
*/
ssize_t MHD_gnutls_record_send (mhd_gtls_session_t session,
ssize_t MHD__gnutls_record_send (MHD_gtls_session_t session,
const void *data, size_t sizeofdata);
ssize_t MHD_gnutls_record_recv (mhd_gtls_session_t session, void *data,
ssize_t MHD__gnutls_record_recv (MHD_gtls_session_t session, void *data,
size_t sizeofdata);
/* provides extra compatibility */
void MHD_gtls_record_disable_padding (mhd_gtls_session_t session);
size_t MHD_gtls_record_check_pending (mhd_gtls_session_t session);
void MHD_gtls_record_disable_padding (MHD_gtls_session_t session);
size_t MHD_gtls_record_check_pending (MHD_gtls_session_t session);
int MHD_gnutls_record_get_direction (mhd_gtls_session_t session);
size_t MHD_gnutls_record_get_max_size (mhd_gtls_session_t session);
ssize_t MHD_gnutls_record_set_max_size (mhd_gtls_session_t session,
int MHD__gnutls_record_get_direction (MHD_gtls_session_t session);
size_t MHD__gnutls_record_get_max_size (MHD_gtls_session_t session);
ssize_t MHD__gnutls_record_set_max_size (MHD_gtls_session_t session,
size_t size);
int MHD_gnutls_prf (mhd_gtls_session_t session,
int MHD__gnutls_prf (MHD_gtls_session_t session,
size_t label_size, const char *label,
int server_random_first,
size_t extra_size, const char *extra,
size_t outsize, char *out);
int MHD_gnutls_prf_raw (mhd_gtls_session_t session,
int MHD__gnutls_prf_raw (MHD_gtls_session_t session,
size_t label_size, const char *label,
size_t seed_size, const char *seed,
size_t outsize, char *out);
@@ -328,13 +328,13 @@ extern "C"
typedef enum
{
GNUTLS_NAME_DNS = 1
} gnutls_server_name_type_t;
} MHD_gnutls_server_name_type_t;
int MHD_gnutls_server_name_set (mhd_gtls_session_t session,
gnutls_server_name_type_t type,
int MHD__gnutls_server_name_set (MHD_gtls_session_t session,
MHD_gnutls_server_name_type_t type,
const void *name, size_t name_length);
int MHD_gnutls_server_name_get (mhd_gtls_session_t session,
int MHD__gnutls_server_name_get (MHD_gtls_session_t session,
void *data, size_t * data_length,
unsigned int *type, unsigned int indx);
@@ -343,437 +343,437 @@ extern "C"
*/
void
MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
MHD_gtls_oprfi_enable_client (MHD_gtls_session_t session,
size_t len, unsigned char *data);
typedef int (*gnutls_oprfi_callback_func) (mhd_gtls_session_t session,
typedef int (*MHD_gnutls_oprfi_callback_func) (MHD_gtls_session_t session,
void *userdata,
size_t oprfi_len,
const unsigned char *in_oprfi,
unsigned char *out_oprfi);
void
MHD_gtls_oprfi_enable_server (mhd_gtls_session_t session,
gnutls_oprfi_callback_func cb,
MHD_gtls_oprfi_enable_server (MHD_gtls_session_t session,
MHD_gnutls_oprfi_callback_func cb,
void *userdata);
/* Supplemental data, RFC 4680. */
typedef enum
{
GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0
} gnutls_supplemental_data_format_type_t;
} MHD_gnutls_supplemental_data_format_type_t;
const char *MHD_gtls_supplemental_get_name
(gnutls_supplemental_data_format_type_t type);
(MHD_gnutls_supplemental_data_format_type_t type);
int MHD_gnutls_cipher_set_priority (mhd_gtls_session_t session,
int MHD__gnutls_cipher_set_priority (MHD_gtls_session_t session,
const int *list);
int MHD_gnutls_mac_set_priority (mhd_gtls_session_t session,
int MHD__gnutls_mac_set_priority (MHD_gtls_session_t session,
const int *list);
int MHD_gnutls_compression_set_priority (mhd_gtls_session_t session,
int MHD__gnutls_compression_set_priority (MHD_gtls_session_t session,
const int *list);
int MHD_gnutls_kx_set_priority (mhd_gtls_session_t session,
int MHD__gnutls_kx_set_priority (MHD_gtls_session_t session,
const int *list);
int MHD_gnutls_protocol_set_priority (mhd_gtls_session_t session,
int MHD__gnutls_protocol_set_priority (MHD_gtls_session_t session,
const int *list);
int MHD_gnutls_certificate_type_set_priority (mhd_gtls_session_t session,
int MHD__gnutls_certificate_type_set_priority (MHD_gtls_session_t session,
const int *list);
int MHD_tls_set_default_priority (gnutls_priority_t *, const char *priority,
int MHD_tls_set_default_priority (MHD_gnutls_priority_t *, const char *priority,
const char **err_pos);
void MHD_gnutls_priority_deinit (gnutls_priority_t);
void MHD__gnutls_priority_deinit (MHD_gnutls_priority_t);
int MHD_gnutls_priority_set (mhd_gtls_session_t session, gnutls_priority_t);
int MHD_gnutls_priority_set_direct (mhd_gtls_session_t session,
int MHD__gnutls_priority_set (MHD_gtls_session_t session, MHD_gnutls_priority_t);
int MHD__gnutls_priority_set_direct (MHD_gtls_session_t session,
const char *priority,
const char **err_pos);
/* get the currently used protocol version */
enum MHD_GNUTLS_Protocol MHD_gnutls_protocol_get_version (mhd_gtls_session_t
enum MHD_GNUTLS_Protocol MHD__gnutls_protocol_get_version (MHD_gtls_session_t
session);
const char *MHD_gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version);
const char *MHD__gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version);
/*
* get/set session
*/
// int gnutls_session_set_data (mhd_gtls_session_t session,
// int MHD_gnutls_session_set_data (MHD_gtls_session_t session,
// const void *session_data,
// size_t session_data_size);
// int gnutls_session_get_data (mhd_gtls_session_t session, void *session_data,
// int MHD_gnutls_session_get_data (MHD_gtls_session_t session, void *session_data,
// size_t * session_data_size);
// int gnutls_session_get_data2 (mhd_gtls_session_t session,
// gnutls_datum_t * data);
// int MHD_gnutls_session_get_data2 (MHD_gtls_session_t session,
// MHD_gnutls_datum_t * data);
int MHD_gtls_session_get_id (mhd_gtls_session_t session, void *session_id,
int MHD_gtls_session_get_id (MHD_gtls_session_t session, void *session_id,
size_t * session_id_size);
/* returns security values.
* Do not use them unless you know what you're doing.
*/
const void *MHD_gtls_session_get_server_random (mhd_gtls_session_t session);
const void *MHD_gtls_session_get_client_random (mhd_gtls_session_t session);
const void *MHD_gtls_session_get_master_secret (mhd_gtls_session_t session);
const void *MHD_gtls_session_get_server_random (MHD_gtls_session_t session);
const void *MHD_gtls_session_get_client_random (MHD_gtls_session_t session);
const void *MHD_gtls_session_get_master_secret (MHD_gtls_session_t session);
int MHD_gtls_session_is_resumed (mhd_gtls_session_t session);
int MHD_gtls_session_is_resumed (MHD_gtls_session_t session);
typedef int (*gnutls_handshake_post_client_hello_func) (mhd_gtls_session_t);
typedef int (*MHD_gnutls_handshake_post_client_hello_func) (MHD_gtls_session_t);
void
MHD_gnutls_handshake_set_post_client_hello_function (mhd_gtls_session_t,
gnutls_handshake_post_client_hello_func);
MHD__gnutls_handshake_set_post_client_hello_function (MHD_gtls_session_t,
MHD_gnutls_handshake_post_client_hello_func);
void MHD_gnutls_handshake_set_max_packet_length (mhd_gtls_session_t session,
void MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session,
size_t max);
/*
* Functions for setting/clearing credentials
*/
void MHD_gnutls_credentials_clear (mhd_gtls_session_t session);
void MHD__gnutls_credentials_clear (MHD_gtls_session_t session);
/*
* cred is a structure defined by the kx algorithm
*/
int MHD_gnutls_credentials_set (mhd_gtls_session_t session,
int MHD__gnutls_credentials_set (MHD_gtls_session_t session,
enum MHD_GNUTLS_CredentialsType type,
void *cred);
/* Credential structures - used in MHD_gnutls_credentials_set(); */
struct mhd_gtls_certificate_credentials_st;
typedef struct mhd_gtls_certificate_credentials_st
*mhd_gtls_cert_credentials_t;
typedef mhd_gtls_cert_credentials_t mhd_gtls_cert_server_credentials;
typedef mhd_gtls_cert_credentials_t mhd_gtls_cert_client_credentials;
/* Credential structures - used in MHD__gnutls_credentials_set(); */
struct MHD_gtls_certificate_credentials_st;
typedef struct MHD_gtls_certificate_credentials_st
*MHD_gtls_cert_credentials_t;
typedef MHD_gtls_cert_credentials_t MHD_gtls_cert_server_credentials;
typedef MHD_gtls_cert_credentials_t MHD_gtls_cert_client_credentials;
typedef struct mhd_gtls_anon_server_credentials_st
*mhd_gtls_anon_server_credentials_t;
typedef struct mhd_gtls_anon_client_credentials_st
*mhd_gtls_anon_client_credentials_t;
typedef struct MHD_gtls_anon_server_credentials_st
*MHD_gtls_anon_server_credentials_t;
typedef struct MHD_gtls_anon_client_credentials_st
*MHD_gtls_anon_client_credentials_t;
void
MHD_gnutls_anon_free_server_credentials
(mhd_gtls_anon_server_credentials_t sc);
MHD__gnutls_anon_free_server_credentials
(MHD_gtls_anon_server_credentials_t sc);
int
MHD_gnutls_anon_allocate_server_credentials
(mhd_gtls_anon_server_credentials_t * sc);
MHD__gnutls_anon_allocate_server_credentials
(MHD_gtls_anon_server_credentials_t * sc);
void
MHD_gnutls_anon_set_server_dh_params (mhd_gtls_anon_server_credentials_t
MHD__gnutls_anon_set_server_dh_params (MHD_gtls_anon_server_credentials_t
res,
mhd_gtls_dh_params_t dh_params);
MHD_gtls_dh_params_t dh_params);
void
MHD_gnutls_anon_set_server_params_function
(mhd_gtls_anon_server_credentials_t res, gnutls_params_function * func);
MHD__gnutls_anon_set_server_params_function
(MHD_gtls_anon_server_credentials_t res, MHD_gnutls_params_function * func);
void
MHD_gnutls_anon_free_client_credentials
(mhd_gtls_anon_client_credentials_t sc);
MHD__gnutls_anon_free_client_credentials
(MHD_gtls_anon_client_credentials_t sc);
int
MHD_gnutls_anon_allocate_client_credentials
(mhd_gtls_anon_client_credentials_t * sc);
MHD__gnutls_anon_allocate_client_credentials
(MHD_gtls_anon_client_credentials_t * sc);
void MHD_gnutls_certificate_free_credentials (mhd_gtls_cert_credentials_t
void MHD__gnutls_certificate_free_credentials (MHD_gtls_cert_credentials_t
sc);
int
MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_credentials_t
MHD__gnutls_certificate_allocate_credentials (MHD_gtls_cert_credentials_t
* res);
void MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc);
void MHD_gnutls_certificate_free_cas (mhd_gtls_cert_credentials_t sc);
void MHD_gnutls_certificate_free_ca_names (mhd_gtls_cert_credentials_t sc);
void MHD_gnutls_certificate_free_crls (mhd_gtls_cert_credentials_t sc);
void MHD__gnutls_certificate_free_keys (MHD_gtls_cert_credentials_t sc);
void MHD__gnutls_certificate_free_cas (MHD_gtls_cert_credentials_t sc);
void MHD__gnutls_certificate_free_ca_names (MHD_gtls_cert_credentials_t sc);
void MHD__gnutls_certificate_free_crls (MHD_gtls_cert_credentials_t sc);
void MHD_gnutls_certificate_set_dh_params (mhd_gtls_cert_credentials_t res,
mhd_gtls_dh_params_t dh_params);
void MHD__gnutls_certificate_set_dh_params (MHD_gtls_cert_credentials_t res,
MHD_gtls_dh_params_t dh_params);
void
MHD_gnutls_certificate_set_rsa_export_params (mhd_gtls_cert_credentials_t
MHD__gnutls_certificate_set_rsa_export_params (MHD_gtls_cert_credentials_t
res,
mhd_gtls_rsa_params_t
MHD_gtls_rsa_params_t
rsa_params);
void MHD_gnutls_certificate_set_verify_flags (mhd_gtls_cert_credentials_t
void MHD__gnutls_certificate_set_verify_flags (MHD_gtls_cert_credentials_t
res, unsigned int flags);
void MHD_gnutls_certificate_set_verify_limits (mhd_gtls_cert_credentials_t
void MHD__gnutls_certificate_set_verify_limits (MHD_gtls_cert_credentials_t
res, unsigned int max_bits,
unsigned int max_depth);
int MHD_gnutls_certificate_set_x509_trust_file (mhd_gtls_cert_credentials_t
int MHD__gnutls_certificate_set_x509_trust_file (MHD_gtls_cert_credentials_t
res, const char *CAFILE,
gnutls_x509_crt_fmt_t type);
int MHD_gnutls_certificate_set_x509_trust_mem (mhd_gtls_cert_credentials_t
MHD_gnutls_x509_crt_fmt_t type);
int MHD__gnutls_certificate_set_x509_trust_mem (MHD_gtls_cert_credentials_t
res,
const gnutls_datum_t * CA,
gnutls_x509_crt_fmt_t type);
const MHD_gnutls_datum_t * CA,
MHD_gnutls_x509_crt_fmt_t type);
int MHD_gnutls_certificate_set_x509_crl_file (mhd_gtls_cert_credentials_t
int MHD__gnutls_certificate_set_x509_crl_file (MHD_gtls_cert_credentials_t
res, const char *crlfile,
gnutls_x509_crt_fmt_t type);
int MHD_gnutls_certificate_set_x509_crl_mem (mhd_gtls_cert_credentials_t
MHD_gnutls_x509_crt_fmt_t type);
int MHD__gnutls_certificate_set_x509_crl_mem (MHD_gtls_cert_credentials_t
res,
const gnutls_datum_t * CRL,
gnutls_x509_crt_fmt_t type);
const MHD_gnutls_datum_t * CRL,
MHD_gnutls_x509_crt_fmt_t type);
/*
* CERTFILE is an x509 certificate in PEM form.
* KEYFILE is a pkcs-1 private key in PEM form (for RSA keys).
*/
int MHD_gnutls_certificate_set_x509_key_file (mhd_gtls_cert_credentials_t
int MHD__gnutls_certificate_set_x509_key_file (MHD_gtls_cert_credentials_t
res, const char *CERTFILE,
const char *KEYFILE,
gnutls_x509_crt_fmt_t type);
int MHD_gnutls_certificate_set_x509_key_mem (mhd_gtls_cert_credentials_t
MHD_gnutls_x509_crt_fmt_t type);
int MHD__gnutls_certificate_set_x509_key_mem (MHD_gtls_cert_credentials_t
res,
const gnutls_datum_t * CERT,
const gnutls_datum_t * KEY,
gnutls_x509_crt_fmt_t type);
const MHD_gnutls_datum_t * CERT,
const MHD_gnutls_datum_t * KEY,
MHD_gnutls_x509_crt_fmt_t type);
void MHD_gnutls_certificate_send_x509_rdn_sequence (mhd_gtls_session_t
void MHD__gnutls_certificate_send_x509_rdn_sequence (MHD_gtls_session_t
session, int status);
/*
* New functions to allow setting already parsed X.509 stuff.
*/
struct MHD_gtls_x509_privkey_int;
typedef struct MHD_gtls_x509_privkey_int *gnutls_x509_privkey_t;
typedef struct MHD_gtls_x509_privkey_int *MHD_gnutls_x509_privkey_t;
struct gnutls_x509_crl_int;
typedef struct gnutls_x509_crl_int *gnutls_x509_crl_t;
struct MHD_gnutls_x509_crl_int;
typedef struct MHD_gnutls_x509_crl_int *MHD_gnutls_x509_crl_t;
struct gnutls_x509_crt_int;
typedef struct gnutls_x509_crt_int *gnutls_x509_crt_t;
struct MHD_gnutls_x509_crt_int;
typedef struct MHD_gnutls_x509_crt_int *MHD_gnutls_x509_crt_t;
// int gnutls_certificate_set_x509_key (mhd_gtls_cert_credentials_t res,
// gnutls_x509_crt_t * cert_list,
// int MHD_gnutls_certificate_set_x509_key (MHD_gtls_cert_credentials_t res,
// MHD_gnutls_x509_crt_t * cert_list,
// int cert_list_size,
// gnutls_x509_privkey_t key);
// int gnutls_certificate_set_x509_trust (mhd_gtls_cert_credentials_t res,
// gnutls_x509_crt_t * ca_list,
// MHD_gnutls_x509_privkey_t key);
// int MHD_gnutls_certificate_set_x509_trust (MHD_gtls_cert_credentials_t res,
// MHD_gnutls_x509_crt_t * ca_list,
// int ca_list_size);
// int gnutls_certificate_set_x509_crl (mhd_gtls_cert_credentials_t res,
// gnutls_x509_crl_t * crl_list,
// int MHD_gnutls_certificate_set_x509_crl (MHD_gtls_cert_credentials_t res,
// MHD_gnutls_x509_crl_t * crl_list,
// int crl_list_size);
/* global state functions
*/
typedef void *(*gnutls_alloc_function) (size_t);
typedef void *(*gnutls_calloc_function) (size_t, size_t);
typedef int (*gnutls_is_secure_function) (const void *);
typedef void (*gnutls_free_function) (void *);
typedef void *(*gnutls_realloc_function) (void *, size_t);
typedef void *(*MHD_gnutls_alloc_function) (size_t);
typedef void *(*MHD_gnutls_calloc_function) (size_t, size_t);
typedef int (*MHD_gnutls_is_secure_function) (const void *);
typedef void (*MHD_gnutls_free_function) (void *);
typedef void *(*MHD_gnutls_realloc_function) (void *, size_t);
extern void
MHD_gtls_global_set_mem_functions (gnutls_alloc_function gt_alloc_func,
gnutls_alloc_function
MHD_gtls_global_set_mem_functions (MHD_gnutls_alloc_function gt_alloc_func,
MHD_gnutls_alloc_function
gt_secure_alloc_func,
gnutls_is_secure_function
MHD_gnutls_is_secure_function
gt_is_secure_func,
gnutls_realloc_function
MHD_gnutls_realloc_function
gt_realloc_func,
gnutls_free_function gt_free_func);
MHD_gnutls_free_function gt_free_func);
/* For use in callbacks */
extern gnutls_alloc_function gnutls_malloc;
extern gnutls_alloc_function gnutls_secure_malloc;
extern gnutls_realloc_function gnutls_realloc;
extern gnutls_calloc_function gnutls_calloc;
extern gnutls_free_function gnutls_free;
extern MHD_gnutls_alloc_function MHD_gnutls_malloc;
extern MHD_gnutls_alloc_function MHD_gnutls_secure_malloc;
extern MHD_gnutls_realloc_function MHD_gnutls_realloc;
extern MHD_gnutls_calloc_function MHD_gnutls_calloc;
extern MHD_gnutls_free_function MHD_gnutls_free;
extern char *(*gnutls_strdup) (const char *);
extern char *(*MHD_gnutls_strdup) (const char *);
typedef void (*gnutls_log_func) (int, const char *);
void MHD_gtls_global_set_log_function (gnutls_log_func log_func);
typedef void (*MHD_gnutls_log_func) (int, const char *);
void MHD_gtls_global_set_log_function (MHD_gnutls_log_func log_func);
void MHD_gtls_global_set_log_level (int level);
/*
* Diffie Hellman parameter handling.
*/
int MHD_gnutls_dh_params_init (mhd_gtls_dh_params_t * dh_params);
void MHD_gnutls_dh_params_deinit (mhd_gtls_dh_params_t dh_params);
int MHD_gnutls_dh_params_generate2 (mhd_gtls_dh_params_t params,
int MHD__gnutls_dh_params_init (MHD_gtls_dh_params_t * dh_params);
void MHD__gnutls_dh_params_deinit (MHD_gtls_dh_params_t dh_params);
int MHD__gnutls_dh_params_generate2 (MHD_gtls_dh_params_t params,
unsigned int bits);
/* RSA params */
int MHD_gnutls_rsa_params_init (mhd_gtls_rsa_params_t * rsa_params);
void MHD_gnutls_rsa_params_deinit (mhd_gtls_rsa_params_t rsa_params);
int MHD_gnutls_rsa_params_generate2 (mhd_gtls_rsa_params_t params,
int MHD__gnutls_rsa_params_init (MHD_gtls_rsa_params_t * rsa_params);
void MHD__gnutls_rsa_params_deinit (MHD_gtls_rsa_params_t rsa_params);
int MHD__gnutls_rsa_params_generate2 (MHD_gtls_rsa_params_t params,
unsigned int bits);
/*
* Session stuff
*/
typedef ssize_t (*mhd_gtls_pull_func) (gnutls_transport_ptr_t, void *,
typedef ssize_t (*MHD_gtls_pull_func) (MHD_gnutls_transport_ptr_t, void *,
size_t);
typedef ssize_t (*mhd_gtls_push_func) (gnutls_transport_ptr_t, const void *,
typedef ssize_t (*MHD_gtls_push_func) (MHD_gnutls_transport_ptr_t, const void *,
size_t);
void MHD_gnutls_transport_set_ptr (mhd_gtls_session_t session,
gnutls_transport_ptr_t ptr);
void MHD_gnutls_transport_set_ptr2 (mhd_gtls_session_t session,
gnutls_transport_ptr_t recv_ptr,
gnutls_transport_ptr_t send_ptr);
void MHD__gnutls_transport_set_ptr (MHD_gtls_session_t session,
MHD_gnutls_transport_ptr_t ptr);
void MHD__gnutls_transport_set_ptr2 (MHD_gtls_session_t session,
MHD_gnutls_transport_ptr_t recv_ptr,
MHD_gnutls_transport_ptr_t send_ptr);
void MHD_gnutls_transport_set_lowat (mhd_gtls_session_t session, int num);
void MHD__gnutls_transport_set_lowat (MHD_gtls_session_t session, int num);
void MHD_gnutls_transport_set_push_function (mhd_gtls_session_t session,
mhd_gtls_push_func push_func);
void MHD_gnutls_transport_set_pull_function (mhd_gtls_session_t session,
mhd_gtls_pull_func pull_func);
void MHD__gnutls_transport_set_push_function (MHD_gtls_session_t session,
MHD_gtls_push_func push_func);
void MHD__gnutls_transport_set_pull_function (MHD_gtls_session_t session,
MHD_gtls_pull_func pull_func);
void MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err);
void MHD_gnutls_transport_set_global_errno (int err);
void MHD__gnutls_transport_set_errno (MHD_gtls_session_t session, int err);
void MHD__gnutls_transport_set_global_errno (int err);
/*
* session specific
*/
void MHD_gnutls_session_set_ptr (mhd_gtls_session_t session, void *ptr);
void *MHD_gtls_session_get_ptr (mhd_gtls_session_t session);
void MHD__gnutls_session_set_ptr (MHD_gtls_session_t session, void *ptr);
void *MHD_gtls_session_get_ptr (MHD_gtls_session_t session);
/*
* this function returns the hash of the given data.
*/
int MHD_gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
const gnutls_datum_t * data, void *result,
int MHD__gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
const MHD_gnutls_datum_t * data, void *result,
size_t * result_size);
/*
* SRP
*/
// typedef struct gnutls_srp_server_credentials_st
// *gnutls_srp_server_credentials_t;
// typedef struct gnutls_srp_client_credentials_st
// *gnutls_srp_client_credentials_t;
// typedef struct MHD_gnutls_srp_server_credentials_st
// *MHD_gnutls_srp_server_credentials_t;
// typedef struct MHD_gnutls_srp_client_credentials_st
// *MHD_gnutls_srp_client_credentials_t;
//
// void gnutls_srp_free_client_credentials (gnutls_srp_client_credentials_t
// void MHD_gnutls_srp_free_client_credentials (MHD_gnutls_srp_client_credentials_t
// sc);
// int gnutls_srp_allocate_client_credentials (gnutls_srp_client_credentials_t
// int MHD_gnutls_srp_allocate_client_credentials (MHD_gnutls_srp_client_credentials_t
// * sc);
// int gnutls_srp_set_client_credentials (gnutls_srp_client_credentials_t res,
// int MHD_gnutls_srp_set_client_credentials (MHD_gnutls_srp_client_credentials_t res,
// const char *username,
// const char *password);
//
// void gnutls_srp_free_server_credentials (gnutls_srp_server_credentials_t
// void MHD_gnutls_srp_free_server_credentials (MHD_gnutls_srp_server_credentials_t
// sc);
// int gnutls_srp_allocate_server_credentials (gnutls_srp_server_credentials_t
// int MHD_gnutls_srp_allocate_server_credentials (MHD_gnutls_srp_server_credentials_t
// * sc);
// int gnutls_srp_set_server_credentials_file (gnutls_srp_server_credentials_t
// int MHD_gnutls_srp_set_server_credentials_file (MHD_gnutls_srp_server_credentials_t
// res, const char *password_file,
// const char *password_conf_file);
//
// const char *gnutls_srp_server_get_username (mhd_gtls_session_t session);
// const char *MHD_gnutls_srp_server_get_username (MHD_gtls_session_t session);
//
// extern int gnutls_srp_verifier (const char *username,
// extern int MHD_gnutls_srp_verifier (const char *username,
// const char *password,
// const gnutls_datum_t * salt,
// const gnutls_datum_t * generator,
// const gnutls_datum_t * prime,
// gnutls_datum_t * res);
// const MHD_gnutls_datum_t * salt,
// const MHD_gnutls_datum_t * generator,
// const MHD_gnutls_datum_t * prime,
// MHD_gnutls_datum_t * res);
//
///* The static parameters defined in draft-ietf-tls-srp-05
// * Those should be used as input to gnutls_srp_verifier().
// * Those should be used as input to MHD_gnutls_srp_verifier().
// */
// extern const gnutls_datum_t gnutls_srp_2048_group_prime;
// extern const gnutls_datum_t gnutls_srp_2048_group_generator;
// extern const MHD_gnutls_datum_t MHD_gnutls_srp_2048_group_prime;
// extern const MHD_gnutls_datum_t MHD_gnutls_srp_2048_group_generator;
//
// extern const gnutls_datum_t gnutls_srp_1536_group_prime;
// extern const gnutls_datum_t gnutls_srp_1536_group_generator;
// extern const MHD_gnutls_datum_t MHD_gnutls_srp_1536_group_prime;
// extern const MHD_gnutls_datum_t MHD_gnutls_srp_1536_group_generator;
//
// extern const gnutls_datum_t gnutls_srp_1024_group_prime;
// extern const gnutls_datum_t gnutls_srp_1024_group_generator;
// extern const MHD_gnutls_datum_t MHD_gnutls_srp_1024_group_prime;
// extern const MHD_gnutls_datum_t MHD_gnutls_srp_1024_group_generator;
//
// typedef int gnutls_srp_server_credentials_function (mhd_gtls_session_t,
// typedef int MHD_gnutls_srp_server_credentials_function (MHD_gtls_session_t,
// const char *username,
// gnutls_datum_t * salt,
// gnutls_datum_t *
// MHD_gnutls_datum_t * salt,
// MHD_gnutls_datum_t *
// verifier,
// gnutls_datum_t *
// MHD_gnutls_datum_t *
// generator,
// gnutls_datum_t * prime);
// MHD_gnutls_datum_t * prime);
// void
// gnutls_srp_set_server_credentials_function
// (gnutls_srp_server_credentials_t cred,
// gnutls_srp_server_credentials_function * func);
// MHD_gnutls_srp_set_server_credentials_function
// (MHD_gnutls_srp_server_credentials_t cred,
// MHD_gnutls_srp_server_credentials_function * func);
//
// typedef int gnutls_srp_client_credentials_function (mhd_gtls_session_t,
// typedef int MHD_gnutls_srp_client_credentials_function (MHD_gtls_session_t,
// char **, char **);
// void
// gnutls_srp_set_client_credentials_function
// (gnutls_srp_client_credentials_t cred,
// gnutls_srp_client_credentials_function * func);
// MHD_gnutls_srp_set_client_credentials_function
// (MHD_gnutls_srp_client_credentials_t cred,
// MHD_gnutls_srp_client_credentials_function * func);
//
// int gnutls_srp_base64_encode (const gnutls_datum_t * data, char *result,
// int MHD_gnutls_srp_base64_encode (const MHD_gnutls_datum_t * data, char *result,
// size_t * result_size);
// int gnutls_srp_base64_encode_alloc (const gnutls_datum_t * data,
// gnutls_datum_t * result);
// int MHD_gnutls_srp_base64_encode_alloc (const MHD_gnutls_datum_t * data,
// MHD_gnutls_datum_t * result);
//
// int gnutls_srp_base64_decode (const gnutls_datum_t * b64_data, char *result,
// int MHD_gnutls_srp_base64_decode (const MHD_gnutls_datum_t * b64_data, char *result,
// size_t * result_size);
// int gnutls_srp_base64_decode_alloc (const gnutls_datum_t * b64_data,
// gnutls_datum_t * result);
// int MHD_gnutls_srp_base64_decode_alloc (const MHD_gnutls_datum_t * b64_data,
// MHD_gnutls_datum_t * result);
/*
* PSK stuff
*/
// typedef struct gnutls_psk_server_credentials_st
// *gnutls_psk_server_credentials_t;
// typedef struct gnutls_psk_client_credentials_st
// *gnutls_psk_client_credentials_t;
// typedef struct MHD_gnutls_psk_server_credentials_st
// *MHD_gnutls_psk_server_credentials_t;
// typedef struct MHD_gnutls_psk_client_credentials_st
// *MHD_gnutls_psk_client_credentials_t;
//
// typedef enum gnutls_psk_key_flags
// typedef enum MHD_gnutls_psk_key_flags
// {
// GNUTLS_PSK_KEY_RAW = 0,
// GNUTLS_PSK_KEY_HEX
// } gnutls_psk_key_flags;
// } MHD_gnutls_psk_key_flags;
//
// void gnutls_psk_free_client_credentials (gnutls_psk_client_credentials_t
// void MHD_gnutls_psk_free_client_credentials (MHD_gnutls_psk_client_credentials_t
// sc);
// int gnutls_psk_allocate_client_credentials (gnutls_psk_client_credentials_t
// int MHD_gnutls_psk_allocate_client_credentials (MHD_gnutls_psk_client_credentials_t
// * sc);
// int gnutls_psk_set_client_credentials (gnutls_psk_client_credentials_t res,
// int MHD_gnutls_psk_set_client_credentials (MHD_gnutls_psk_client_credentials_t res,
// const char *username,
// const gnutls_datum_t * key,
// gnutls_psk_key_flags format);
// const MHD_gnutls_datum_t * key,
// MHD_gnutls_psk_key_flags format);
//
// void gnutls_psk_free_server_credentials (gnutls_psk_server_credentials_t
// void MHD_gnutls_psk_free_server_credentials (MHD_gnutls_psk_server_credentials_t
// sc);
// int gnutls_psk_allocate_server_credentials (gnutls_psk_server_credentials_t
// int MHD_gnutls_psk_allocate_server_credentials (MHD_gnutls_psk_server_credentials_t
// * sc);
// int gnutls_psk_set_server_credentials_file (gnutls_psk_server_credentials_t
// int MHD_gnutls_psk_set_server_credentials_file (MHD_gnutls_psk_server_credentials_t
// res, const char *password_file);
//
// const char *gnutls_psk_server_get_username (mhd_gtls_session_t session);
// const char *MHD_gnutls_psk_server_get_username (MHD_gtls_session_t session);
//
// typedef int gnutls_psk_server_credentials_function (mhd_gtls_session_t,
// typedef int MHD_gnutls_psk_server_credentials_function (MHD_gtls_session_t,
// const char *username,
// gnutls_datum_t * key);
// MHD_gnutls_datum_t * key);
// void
// gnutls_psk_set_server_credentials_function
// (gnutls_psk_server_credentials_t cred,
// gnutls_psk_server_credentials_function * func);
// MHD_gnutls_psk_set_server_credentials_function
// (MHD_gnutls_psk_server_credentials_t cred,
// MHD_gnutls_psk_server_credentials_function * func);
//
// typedef int gnutls_psk_client_credentials_function (mhd_gtls_session_t,
// typedef int MHD_gnutls_psk_client_credentials_function (MHD_gtls_session_t,
// char **username,
// gnutls_datum_t * key);
// MHD_gnutls_datum_t * key);
// void
// gnutls_psk_set_client_credentials_function
// (gnutls_psk_client_credentials_t cred,
// gnutls_psk_client_credentials_function * func);
// MHD_gnutls_psk_set_client_credentials_function
// (MHD_gnutls_psk_client_credentials_t cred,
// MHD_gnutls_psk_client_credentials_function * func);
//
// int gnutls_hex_encode (const gnutls_datum_t * data, char *result,
// int MHD_gnutls_hex_encode (const MHD_gnutls_datum_t * data, char *result,
// size_t * result_size);
// int gnutls_hex_decode (const gnutls_datum_t * hex_data, char *result,
// int MHD_gnutls_hex_decode (const MHD_gnutls_datum_t * hex_data, char *result,
// size_t * result_size);
//
// void gnutls_psk_set_server_dh_params (gnutls_psk_server_credentials_t res,
// mhd_gtls_dh_params_t dh_params);
// void MHD_gnutls_psk_set_server_dh_params (MHD_gnutls_psk_server_credentials_t res,
// MHD_gtls_dh_params_t dh_params);
//
// void gnutls_psk_set_server_params_function (gnutls_psk_server_credentials_t
// void MHD_gnutls_psk_set_server_params_function (MHD_gnutls_psk_server_credentials_t
// res,
// gnutls_params_function * func);
// MHD_gnutls_params_function * func);
typedef enum gnutls_x509_subject_alt_name_t
typedef enum MHD_gnutls_x509_subject_alt_name_t
{
GNUTLS_SAN_DNSNAME = 1,
GNUTLS_SAN_RFC822NAME,
@@ -783,30 +783,30 @@ extern "C"
GNUTLS_SAN_DN,
/* The following are "virtual" subject alternative name types, in
that they are represented by an otherName value and an OID.
Used by gnutls_x509_crt_get_subject_alt_othername_oid(). */
Used by MHD_gnutls_x509_crt_get_subject_alt_othername_oid(). */
GNUTLS_SAN_OTHERNAME_XMPP = 1000
} gnutls_x509_subject_alt_name_t;
} MHD_gnutls_x509_subject_alt_name_t;
typedef struct gnutls_retr_st
typedef struct MHD_gnutls_retr_st
{
enum MHD_GNUTLS_CertificateType type;
union cert
{
gnutls_x509_crt_t *x509;
MHD_gnutls_x509_crt_t *x509;
} cert;
unsigned int ncerts;
union key
{
gnutls_x509_privkey_t x509;
MHD_gnutls_x509_privkey_t x509;
} key;
unsigned int deinit_all; /* if non zero all keys will be deinited */
} gnutls_retr_st;
} MHD_gnutls_retr_st;
typedef int gnutls_certificate_client_retrieve_function (mhd_gtls_session_t,
typedef int MHD_gnutls_certificate_client_retrieve_function (MHD_gtls_session_t,
const
gnutls_datum_t *
MHD_gnutls_datum_t *
req_ca_rdn,
int nreqs,
const
@@ -815,115 +815,115 @@ extern "C"
*pk_algos,
int
pk_algos_length,
gnutls_retr_st *);
MHD_gnutls_retr_st *);
typedef int gnutls_certificate_server_retrieve_function (mhd_gtls_session_t,
gnutls_retr_st *);
typedef int MHD_gnutls_certificate_server_retrieve_function (MHD_gtls_session_t,
MHD_gnutls_retr_st *);
/*
* Functions that allow auth_info_t structures handling
*/
enum MHD_GNUTLS_CredentialsType MHD_gtls_auth_get_type (mhd_gtls_session_t
enum MHD_GNUTLS_CredentialsType MHD_gtls_auth_get_type (MHD_gtls_session_t
session);
enum MHD_GNUTLS_CredentialsType
MHD_gtls_auth_server_get_type (mhd_gtls_session_t session);
MHD_gtls_auth_server_get_type (MHD_gtls_session_t session);
enum MHD_GNUTLS_CredentialsType
MHD_gtls_auth_client_get_type (mhd_gtls_session_t session);
MHD_gtls_auth_client_get_type (MHD_gtls_session_t session);
/*
* DH
*/
void MHD_gnutls_dh_set_prime_bits (mhd_gtls_session_t session,
void MHD__gnutls_dh_set_prime_bits (MHD_gtls_session_t session,
unsigned int bits);
int MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session);
int MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session);
int MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session);
int MHD__gnutls_dh_get_secret_bits (MHD_gtls_session_t session);
int MHD__gnutls_dh_get_peers_public_bits (MHD_gtls_session_t session);
int MHD__gnutls_dh_get_prime_bits (MHD_gtls_session_t session);
int MHD_gnutls_dh_get_group (mhd_gtls_session_t session,
gnutls_datum_t * raw_gen,
gnutls_datum_t * raw_prime);
int MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session,
gnutls_datum_t * raw_key);
int MHD__gnutls_dh_get_group (MHD_gtls_session_t session,
MHD_gnutls_datum_t * raw_gen,
MHD_gnutls_datum_t * raw_prime);
int MHD__gnutls_dh_get_pubkey (MHD_gtls_session_t session,
MHD_gnutls_datum_t * raw_key);
/*
* RSA
*/
int MHD_gtls_rsa_export_get_pubkey (mhd_gtls_session_t session,
gnutls_datum_t * exponent,
gnutls_datum_t * modulus);
int MHD_gtls_rsa_export_get_modulus_bits (mhd_gtls_session_t session);
int MHD_gtls_rsa_export_get_pubkey (MHD_gtls_session_t session,
MHD_gnutls_datum_t * exponent,
MHD_gnutls_datum_t * modulus);
int MHD_gtls_rsa_export_get_modulus_bits (MHD_gtls_session_t session);
/* External signing callback. Experimental. */
typedef int (*gnutls_sign_func) (mhd_gtls_session_t session,
typedef int (*MHD_gnutls_sign_func) (MHD_gtls_session_t session,
void *userdata,
enum MHD_GNUTLS_CertificateType cert_type,
const gnutls_datum_t * cert,
const gnutls_datum_t * hash,
gnutls_datum_t * signature);
const MHD_gnutls_datum_t * cert,
const MHD_gnutls_datum_t * hash,
MHD_gnutls_datum_t * signature);
void MHD_gtls_sign_callback_set (mhd_gtls_session_t session,
gnutls_sign_func sign_func,
void MHD_gtls_sign_callback_set (MHD_gtls_session_t session,
MHD_gnutls_sign_func sign_func,
void *userdata);
gnutls_sign_func MHD_gtls_sign_callback_get (mhd_gtls_session_t session,
MHD_gnutls_sign_func MHD_gtls_sign_callback_get (MHD_gtls_session_t session,
void **userdata);
/* These are set on the credentials structure.
*/
void MHD_gtls_certificate_client_set_retrieve_function
(mhd_gtls_cert_credentials_t cred,
gnutls_certificate_client_retrieve_function * func);
(MHD_gtls_cert_credentials_t cred,
MHD_gnutls_certificate_client_retrieve_function * func);
void MHD_gtls_certificate_server_set_retrieve_function
(mhd_gtls_cert_credentials_t cred,
gnutls_certificate_server_retrieve_function * func);
(MHD_gtls_cert_credentials_t cred,
MHD_gnutls_certificate_server_retrieve_function * func);
void MHD_gtls_certificate_server_set_request (mhd_gtls_session_t session,
gnutls_certificate_request_t
void MHD_gtls_certificate_server_set_request (MHD_gtls_session_t session,
MHD_gnutls_certificate_request_t
req);
/* get data from the session */
const gnutls_datum_t *MHD_gtls_certificate_get_peers (mhd_gtls_session_t
const MHD_gnutls_datum_t *MHD_gtls_certificate_get_peers (MHD_gtls_session_t
session,
unsigned int
*list_size);
const gnutls_datum_t *MHD_gtls_certificate_get_ours (mhd_gtls_session_t
const MHD_gnutls_datum_t *MHD_gtls_certificate_get_ours (MHD_gtls_session_t
session);
time_t MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t
time_t MHD_gtls_certificate_activation_time_peers (MHD_gtls_session_t
session);
time_t MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t
time_t MHD_gtls_certificate_expiration_time_peers (MHD_gtls_session_t
session);
int MHD_gtls_certificate_client_get_request_status (mhd_gtls_session_t
int MHD_gtls_certificate_client_get_request_status (MHD_gtls_session_t
session);
int MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
int MHD_gtls_certificate_verify_peers2 (MHD_gtls_session_t session,
unsigned int *status);
/* this is obsolete (?). */
int MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session);
int MHD_gtls_certificate_verify_peers (MHD_gtls_session_t session);
int MHD_gtls_pem_base64_encode (const char *msg,
const gnutls_datum_t * data, char *result,
const MHD_gnutls_datum_t * data, char *result,
size_t * result_size);
int MHD_gtls_pem_base64_decode (const char *header,
const gnutls_datum_t * b64_data,
const MHD_gnutls_datum_t * b64_data,
unsigned char *result,
size_t * result_size);
int MHD_gtls_pem_base64_encode_alloc (const char *msg,
const gnutls_datum_t * data,
gnutls_datum_t * result);
const MHD_gnutls_datum_t * data,
MHD_gnutls_datum_t * result);
int MHD_gtls_pem_base64_decode_alloc (const char *header,
const gnutls_datum_t * b64_data,
gnutls_datum_t * result);
const MHD_gnutls_datum_t * b64_data,
MHD_gnutls_datum_t * result);
// void
// gnutls_certificate_set_params_function (mhd_gtls_cert_credentials_t
// MHD_gnutls_certificate_set_params_function (MHD_gtls_cert_credentials_t
// res,
// gnutls_params_function * func);
// void gnutls_anon_set_params_function (mhd_gtls_anon_server_credentials_t res,
// gnutls_params_function * func);
// void gnutls_psk_set_params_function (gnutls_psk_server_credentials_t res,
// gnutls_params_function * func);
// MHD_gnutls_params_function * func);
// void MHD_gnutls_anon_set_params_function (MHD_gtls_anon_server_credentials_t res,
// MHD_gnutls_params_function * func);
// void MHD_gnutls_psk_set_params_function (MHD_gnutls_psk_server_credentials_t res,
// MHD_gnutls_params_function * func);
/* key_usage will be an OR of the following values: */
@@ -1002,7 +1002,7 @@ extern "C"
/* returned if libextra functionality was requested but
* gnutls_global_init_extra() was not called.
* MHD_gnutls_global_init_extra() was not called.
*/
#define GNUTLS_E_INIT_LIBEXTRA -82
#define GNUTLS_E_LIBRARY_VERSION_MISMATCH -83
src/daemon/https/lgl/Makefile.am
-1
View File
@@ -14,7 +14,6 @@ liblgl_la_LDFLAGS = -lgcrypt
liblgl_la_SOURCES = \
sha1.c sha1.h \
gc-libgcrypt.c \
time_r.c \
rijndael-api-fst.c rijndael-api-fst.h \
gc-pbkdf2-sha1.c gc.h \
rijndael-alg-fst.c rijndael-alg-fst.h \
src/daemon/https/lgl/des.c
+20 -20
View File
@@ -54,13 +54,13 @@
* unsigned char plaintext[8];
* unsigned char ciphertext[8];
* unsigned char recoverd[8];
* gl_des_ctx context;
* MHD_gl_des_ctx context;
*
* // Fill 'key' and 'plaintext' with some data
* ....
*
* // Set up the DES encryption context
* gl_des_setkey(&context, key);
* MHD_gl_des_setkey(&context, key);
*
* // Encrypt the plaintext
* des_ecb_encrypt(&context, plaintext, ciphertext);
@@ -77,20 +77,20 @@
* unsigned char plaintext[8];
* unsigned char ciphertext[8];
* unsigned char recoverd[8];
* gl_3des_ctx context;
* MHD_gl_3des_ctx context;
*
* // If you would like to use two 64bit keys, fill 'key1' and'key2'
* // then setup the encryption context:
* gl_3des_set2keys(&context, key1, key2);
* MHD_gl_3des_set2keys(&context, key1, key2);
*
* // To use three 64bit keys with Triple-DES use:
* gl_3des_set3keys(&context, key1, key2, key3);
* MHD_gl_3des_set3keys(&context, key1, key2, key3);
*
* // Encrypting plaintext with Triple-DES
* gl_3des_ecb_encrypt(&context, plaintext, ciphertext);
* MHD_gl_3des_ecb_encrypt(&context, plaintext, ciphertext);
*
* // Decrypting ciphertext to recover the plaintext with Triple-DES
* gl_3des_ecb_decrypt(&context, ciphertext, recoverd);
* MHD_gl_3des_ecb_decrypt(&context, ciphertext, recoverd);
*/
@@ -320,7 +320,7 @@ static const unsigned char weak_keys[64][8] = {
};
bool
gl_des_is_weak_key (const char *key)
MHD_gl_des_is_weak_key (const char *key)
{
char work[8];
int i, left, right, middle, cmp_result;
@@ -518,7 +518,7 @@ des_key_schedule (const char *_rawkey, uint32_t * subkey)
}
void
gl_des_setkey (gl_des_ctx * ctx, const char *key)
MHD_gl_des_setkey (MHD_gl_des_ctx * ctx, const char *key)
{
int i;
@@ -532,18 +532,18 @@ gl_des_setkey (gl_des_ctx * ctx, const char *key)
}
bool
gl_des_makekey (gl_des_ctx * ctx, const char *key, size_t keylen)
MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key, size_t keylen)
{
if (keylen != 8)
return false;
gl_des_setkey (ctx, key);
MHD_gl_des_setkey (ctx, key);
return !gl_des_is_weak_key (key);
return !MHD_gl_des_is_weak_key (key);
}
void
gl_des_ecb_crypt (gl_des_ctx * ctx, const char *_from, char *_to, int mode)
MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *_from, char *_to, int mode)
{
const unsigned char *from = (const unsigned char *) _from;
unsigned char *to = (unsigned char *) _to;
@@ -565,7 +565,7 @@ READ_64BIT_DATA (from, left, right)
FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left)}
void
gl_3des_set2keys (gl_3des_ctx * ctx, const char *key1, const char *key2)
MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2)
{
int i;
@@ -589,7 +589,7 @@ gl_3des_set2keys (gl_3des_ctx * ctx, const char *key1, const char *key2)
}
void
gl_3des_set3keys (gl_3des_ctx * ctx, const char *key1,
MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx, const char *key1,
const char *key2, const char *key3)
{
int i;
@@ -612,7 +612,7 @@ gl_3des_set3keys (gl_3des_ctx * ctx, const char *key1,
}
void
gl_3des_ecb_crypt (gl_3des_ctx * ctx, const char *_from, char *_to, int mode)
MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *_from, char *_to, int mode)
{
const unsigned char *from = (const unsigned char *) _from;
unsigned char *to = (unsigned char *) _to;
@@ -650,13 +650,13 @@ READ_64BIT_DATA (from, left, right)
FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left)}
bool
gl_3des_makekey (gl_3des_ctx * ctx, const char *key, size_t keylen)
MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen)
{
if (keylen != 24)
return false;
gl_3des_set3keys (ctx, key, key + 8, key + 16);
MHD_gl_3des_set3keys (ctx, key, key + 8, key + 16);
return !(gl_des_is_weak_key (key)
|| gl_des_is_weak_key (key + 8) || gl_des_is_weak_key (key + 16));
return !(MHD_gl_des_is_weak_key (key)
|| MHD_gl_des_is_weak_key (key + 8) || MHD_gl_des_is_weak_key (key + 16));
}
src/daemon/https/lgl/des.h
+14 -14
View File
@@ -34,7 +34,7 @@ typedef struct
{
uint32_t encrypt_subkeys[32];
uint32_t decrypt_subkeys[32];
} gl_des_ctx;
} MHD_gl_des_ctx;
/*
* Encryption/Decryption context of Triple-DES
@@ -43,11 +43,11 @@ typedef struct
{
uint32_t encrypt_subkeys[96];
uint32_t decrypt_subkeys[96];
} gl_3des_ctx;
} MHD_gl_3des_ctx;
/* Check whether the 8 byte key is weak. Does not check the parity
* bits of the key but simple ignore them. */
extern bool gl_des_is_weak_key (const char *key);
extern bool MHD_gl_des_is_weak_key (const char *key);
/*
* DES
@@ -57,20 +57,20 @@ extern bool gl_des_is_weak_key (const char *key);
/* Fill a DES context CTX with subkeys calculated from 64bit KEY.
* Does not check parity bits, but simply ignore them. Does not check
* for weak keys. */
extern void gl_des_setkey (gl_des_ctx * ctx, const char *key);
extern void MHD_gl_des_setkey (MHD_gl_des_ctx * ctx, const char *key);
/* Fill a DES context CTX with subkeys calculated from 64bit KEY, with
* weak key checking. Does not check parity bits, but simply ignore
* them. */
extern bool gl_des_makekey (gl_des_ctx * ctx, const char *key, size_t keylen);
extern bool MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key, size_t keylen);
/* Electronic Codebook Mode DES encryption/decryption of data
* according to 'mode'. */
extern void
gl_des_ecb_crypt (gl_des_ctx * ctx, const char *from, char *to, int mode);
MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to, int mode);
#define gl_des_ecb_encrypt(ctx, from, to) gl_des_ecb_crypt(ctx, from, to, 0)
#define gl_des_ecb_decrypt(ctx, from, to) gl_des_ecb_crypt(ctx, from, to, 1)
#define MHD_gl_des_ecb_encrypt(ctx, from, to) MHD_gl_des_ecb_crypt(ctx, from, to, 0)
#define MHD_gl_des_ecb_decrypt(ctx, from, to) MHD_gl_des_ecb_crypt(ctx, from, to, 1)
/* Triple-DES
* ----------
@@ -80,7 +80,7 @@ gl_des_ecb_crypt (gl_des_ctx * ctx, const char *from, char *to, int mode);
* 64bit keys in KEY1 and KEY2. Does not check the parity bits of the
* keys, but simply ignore them. Does not check for weak keys. */
extern void
gl_3des_set2keys (gl_3des_ctx * ctx, const char *key1, const char *key2);
MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2);
/*
* Fill a Triple-DES context CTX with subkeys calculated from three
@@ -88,22 +88,22 @@ gl_3des_set2keys (gl_3des_ctx * ctx, const char *key1, const char *key2);
* of the keys, but simply ignore them. Does not check for weak
* keys. */
extern void
gl_3des_set3keys (gl_3des_ctx * ctx,
MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx,
const char *key1, const char *key2, const char *key3);
/* Fill a Triple-DES context CTX with subkeys calculated from three
* concatenated 64bit keys in KEY, with weak key checking. Does not
* check the parity bits of the keys, but simply ignore them. */
extern bool
gl_3des_makekey (gl_3des_ctx * ctx, const char *key, size_t keylen);
MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen);
/* Electronic Codebook Mode Triple-DES encryption/decryption of data
* according to 'mode'. Sometimes this mode is named 'EDE' mode
* (Encryption-Decryption-Encryption). */
extern void
gl_3des_ecb_crypt (gl_3des_ctx * ctx, const char *from, char *to, int mode);
MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *from, char *to, int mode);
#define gl_3des_ecb_encrypt(ctx, from, to) gl_3des_ecb_crypt(ctx,from,to,0)
#define gl_3des_ecb_decrypt(ctx, from, to) gl_3des_ecb_crypt(ctx,from,to,1)
#define MHD_gl_3des_ecb_encrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,0)
#define MHD_gl_3des_ecb_decrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,1)
#endif /* DES_H */
src/daemon/https/lgl/gc-gnulib.c
+61 -61
View File
@@ -68,13 +68,13 @@
#undef close
Gc_rc
gc_init (void)
MHD_gc_init (void)
{
return GC_OK;
}
void
gc_done (void)
MHD_gc_done (void)
{
return;
}
@@ -139,19 +139,19 @@ randomize (int level, char *data, size_t datalen)
}
Gc_rc
gc_nonce (char *data, size_t datalen)
MHD_gc_nonce (char *data, size_t datalen)
{
return randomize (0, data, datalen);
}
Gc_rc
gc_pseudo_random (char *data, size_t datalen)
MHD_gc_pseudo_random (char *data, size_t datalen)
{
return randomize (1, data, datalen);
}
Gc_rc
gc_random (char *data, size_t datalen)
MHD_gc_random (char *data, size_t datalen)
{
return randomize (2, data, datalen);
}
@@ -160,17 +160,17 @@ gc_random (char *data, size_t datalen)
/* Memory allocation. */
void
gc_set_allocators (gc_malloc_t func_malloc,
gc_malloc_t secure_malloc,
gc_secure_check_t secure_check,
gc_realloc_t func_realloc, gc_free_t func_free)
MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
MHD_gc_malloc_t secure_malloc,
MHD_gc_secure_check_t secure_check,
MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
{
return;
}
/* Ciphers. */
typedef struct _gc_cipher_ctx
typedef struct _MHD_gc_cipher_ctx
{
Gc_cipher alg;
Gc_cipher_mode mode;
@@ -182,20 +182,20 @@ typedef struct _gc_cipher_ctx
arcfour_context arcfourContext;
#endif
#ifdef GNULIB_GC_DES
gl_des_ctx desContext;
MHD_gl_des_ctx desContext;
#endif
#ifdef GNULIB_GC_RIJNDAEL
rijndaelKeyInstance aesEncKey;
rijndaelKeyInstance aesDecKey;
rijndaelCipherInstance aesContext;
#endif
} _gc_cipher_ctx;
} _MHD_gc_cipher_ctx;
Gc_rc
gc_cipher_open (Gc_cipher alg,
Gc_cipher_mode mode, gc_cipher_handle * outhandle)
MHD_gc_cipher_open (Gc_cipher alg,
Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
{
_gc_cipher_ctx *ctx;
_MHD_gc_cipher_ctx *ctx;
Gc_rc rc = GC_OK;
ctx = calloc (sizeof (*ctx), 1);
@@ -277,9 +277,9 @@ gc_cipher_open (Gc_cipher alg,
}
Gc_rc
gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *key)
{
_gc_cipher_ctx *ctx = handle;
_MHD_gc_cipher_ctx *ctx = handle;
switch (ctx->alg)
{
@@ -300,7 +300,7 @@ gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
case GC_DES:
if (keylen != 8)
return GC_INVALID_CIPHER;
gl_des_setkey (&ctx->desContext, key);
MHD_gl_des_setkey (&ctx->desContext, key);
break;
#endif
@@ -341,9 +341,9 @@ gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
}
Gc_rc
gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
{
_gc_cipher_ctx *ctx = handle;
_MHD_gc_cipher_ctx *ctx = handle;
switch (ctx->alg)
{
@@ -395,9 +395,9 @@ gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
}
Gc_rc
gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
{
_gc_cipher_ctx *ctx = handle;
_MHD_gc_cipher_ctx *ctx = handle;
switch (ctx->alg)
{
@@ -438,7 +438,7 @@ gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
#ifdef GNULIB_GC_DES
case GC_DES:
for (; len >= 8; len -= 8, data += 8)
gl_des_ecb_encrypt (&ctx->desContext, data, data);
MHD_gl_des_ecb_encrypt (&ctx->desContext, data, data);
break;
#endif
@@ -465,9 +465,9 @@ gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
}
Gc_rc
gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
{
_gc_cipher_ctx *ctx = handle;
_MHD_gc_cipher_ctx *ctx = handle;
switch (ctx->alg)
{
@@ -510,7 +510,7 @@ gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
#ifdef GNULIB_GC_DES
case GC_DES:
for (; len >= 8; len -= 8, data += 8)
gl_des_ecb_decrypt (&ctx->desContext, data, data);
MHD_gl_des_ecb_decrypt (&ctx->desContext, data, data);
break;
#endif
@@ -537,9 +537,9 @@ gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
}
Gc_rc
gc_cipher_close (gc_cipher_handle handle)
MHD_gc_cipher_close (MHD_gc_cipher_handle handle)
{
_gc_cipher_ctx *ctx = handle;
_MHD_gc_cipher_ctx *ctx = handle;
if (ctx)
free (ctx);
@@ -551,23 +551,23 @@ gc_cipher_close (gc_cipher_handle handle)
#define MAX_DIGEST_SIZE 20
typedef struct _gc_hash_ctx
typedef struct _MHD_gc_hash_ctx
{
Gc_hash alg;
Gc_hash_mode mode;
char hash[MAX_DIGEST_SIZE];
#ifdef GNULIB_GC_MD5
struct md5_ctx md5Context;
struct MHD_md5_ctx md5Context;
#endif
#ifdef GNULIB_GC_SHA1
struct sha1_ctx sha1Context;
struct MHD_sha1_ctx sha1Context;
#endif
} _gc_hash_ctx;
} _MHD_gc_hash_ctx;
Gc_rc
gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode, MHD_gc_hash_handle * outhandle)
{
_gc_hash_ctx *ctx;
_MHD_gc_hash_ctx *ctx;
Gc_rc rc = GC_OK;
ctx = calloc (sizeof (*ctx), 1);
@@ -581,13 +581,13 @@ gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
md5_init_ctx (&ctx->md5Context);
MHD_md5_init_ctx (&ctx->md5Context);
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
sha1_init_ctx (&ctx->sha1Context);
MHD_sha1_init_ctx (&ctx->sha1Context);
break;
#endif
@@ -615,10 +615,10 @@ gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
}
Gc_rc
gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle)
{
_gc_hash_ctx *in = handle;
_gc_hash_ctx *out;
_MHD_gc_hash_ctx *in = handle;
_MHD_gc_hash_ctx *out;
*outhandle = out = calloc (sizeof (*out), 1);
if (!out)
@@ -630,7 +630,7 @@ gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
}
size_t
gc_hash_digest_length (Gc_hash hash)
MHD_gc_hash_digest_length (Gc_hash hash)
{
size_t len;
@@ -664,21 +664,21 @@ gc_hash_digest_length (Gc_hash hash)
}
void
gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data)
{
_gc_hash_ctx *ctx = handle;
_MHD_gc_hash_ctx *ctx = handle;
switch (ctx->alg)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
md5_process_bytes (data, len, &ctx->md5Context);
MHD_md5_process_bytes (data, len, &ctx->md5Context);
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
sha1_process_bytes (data, len, &ctx->sha1Context);
MHD_sha1_process_bytes (data, len, &ctx->sha1Context);
break;
#endif
@@ -688,23 +688,23 @@ gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
}
const char *
gc_hash_read (gc_hash_handle handle)
MHD_gc_hash_read (MHD_gc_hash_handle handle)
{
_gc_hash_ctx *ctx = handle;
_MHD_gc_hash_ctx *ctx = handle;
const char *ret = NULL;
switch (ctx->alg)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
md5_finish_ctx (&ctx->md5Context, ctx->hash);
MHD_md5_finish_ctx (&ctx->md5Context, ctx->hash);
ret = ctx->hash;
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
sha1_finish_ctx (&ctx->sha1Context, ctx->hash);
MHD_sha1_finish_ctx (&ctx->sha1Context, ctx->hash);
ret = ctx->hash;
break;
#endif
@@ -717,27 +717,27 @@ gc_hash_read (gc_hash_handle handle)
}
void
gc_hash_close (gc_hash_handle handle)
MHD_gc_hash_close (MHD_gc_hash_handle handle)
{
_gc_hash_ctx *ctx = handle;
_MHD_gc_hash_ctx *ctx = handle;
free (ctx);
}
Gc_rc
gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
{
switch (hash)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
md5_buffer (in, inlen, resbuf);
MHD_md5_buffer (in, inlen, resbuf);
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
sha1_buffer (in, inlen, resbuf);
MHD_sha1_buffer (in, inlen, resbuf);
break;
#endif
@@ -750,38 +750,38 @@ gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
#ifdef GNULIB_GC_MD5
Gc_rc
gc_md5 (const void *in, size_t inlen, void *resbuf)
MHD_gc_md5 (const void *in, size_t inlen, void *resbuf)
{
md5_buffer (in, inlen, resbuf);
MHD_md5_buffer (in, inlen, resbuf);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_SHA1
Gc_rc
gc_sha1 (const void *in, size_t inlen, void *resbuf)
MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
{
sha1_buffer (in, inlen, resbuf);
MHD_sha1_buffer (in, inlen, resbuf);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_HMAC_MD5
Gc_rc
gc_hmac_md5 (const void *key, size_t keylen,
MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
const void *in, size_t inlen, char *resbuf)
{
hmac_md5 (key, keylen, in, inlen, resbuf);
MHD_hmac_md5 (key, keylen, in, inlen, resbuf);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_HMAC_SHA1
Gc_rc
gc_hmac_sha1 (const void *key,
MHD_gc_MHD_hmac_sha1 (const void *key,
size_t keylen, const void *in, size_t inlen, char *resbuf)
{
hmac_sha1 (key, keylen, in, inlen, resbuf);
MHD_hmac_sha1 (key, keylen, in, inlen, resbuf);
return GC_OK;
}
#endif
src/daemon/https/lgl/gc-libgcrypt.c
+37 -37
View File
@@ -36,7 +36,7 @@
/* Initialization. */
Gc_rc
gc_init (void)
MHD_gc_init (void)
{
gcry_error_t err;
@@ -54,7 +54,7 @@ gc_init (void)
}
void
gc_done (void)
MHD_gc_done (void)
{
return;
}
@@ -64,21 +64,21 @@ gc_done (void)
/* Randomness. */
Gc_rc
gc_nonce (char *data, size_t datalen)
MHD_gc_nonce (char *data, size_t datalen)
{
gcry_create_nonce ((unsigned char *) data, datalen);
return GC_OK;
}
Gc_rc
gc_pseudo_random (char *data, size_t datalen)
MHD_gc_pseudo_random (char *data, size_t datalen)
{
gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
return GC_OK;
}
Gc_rc
gc_random (char *data, size_t datalen)
MHD_gc_random (char *data, size_t datalen)
{
gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
return GC_OK;
@@ -89,10 +89,10 @@ gc_random (char *data, size_t datalen)
/* Memory allocation. */
void
gc_set_allocators (gc_malloc_t func_malloc,
gc_malloc_t secure_malloc,
gc_secure_check_t secure_check,
gc_realloc_t func_realloc, gc_free_t func_free)
MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
MHD_gc_malloc_t secure_malloc,
MHD_gc_secure_check_t secure_check,
MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
{
gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
func_realloc, func_free);
@@ -101,8 +101,8 @@ gc_set_allocators (gc_malloc_t func_malloc,
/* Ciphers. */
Gc_rc
gc_cipher_open (Gc_cipher alg,
Gc_cipher_mode mode, gc_cipher_handle * outhandle)
MHD_gc_cipher_open (Gc_cipher alg,
Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
{
int gcryalg, gcrymode;
gcry_error_t err;
@@ -179,7 +179,7 @@ gc_cipher_open (Gc_cipher alg,
}
Gc_rc
gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *key)
{
gcry_error_t err;
@@ -191,7 +191,7 @@ gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
}
Gc_rc
gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
{
gcry_error_t err;
@@ -203,7 +203,7 @@ gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
}
Gc_rc
gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
{
if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
0)
@@ -213,7 +213,7 @@ gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
}
Gc_rc
gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
{
if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
0)
@@ -223,7 +223,7 @@ gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
}
Gc_rc
gc_cipher_close (gc_cipher_handle handle)
MHD_gc_cipher_close (MHD_gc_cipher_handle handle)
{
gcry_cipher_close (handle);
@@ -232,17 +232,17 @@ gc_cipher_close (gc_cipher_handle handle)
/* Hashes. */
typedef struct _gc_hash_ctx
typedef struct _MHD_gc_hash_ctx
{
Gc_hash alg;
Gc_hash_mode mode;
gcry_md_hd_t gch;
} _gc_hash_ctx;
} _MHD_gc_hash_ctx;
Gc_rc
gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode, MHD_gc_hash_handle * outhandle)
{
_gc_hash_ctx *ctx;
_MHD_gc_hash_ctx *ctx;
int gcryalg = 0, gcrymode = 0;
gcry_error_t err;
Gc_rc rc = GC_OK;
@@ -322,10 +322,10 @@ gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
}
Gc_rc
gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle)
{
_gc_hash_ctx *in = handle;
_gc_hash_ctx *out;
_MHD_gc_hash_ctx *in = handle;
_MHD_gc_hash_ctx *out;
int err;
*outhandle = out = calloc (sizeof (*out), 1);
@@ -345,7 +345,7 @@ gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
}
size_t
gc_hash_digest_length (Gc_hash hash)
MHD_gc_hash_digest_length (Gc_hash hash)
{
size_t len;
@@ -391,23 +391,23 @@ gc_hash_digest_length (Gc_hash hash)
}
void
gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len, const char *key)
{
_gc_hash_ctx *ctx = handle;
_MHD_gc_hash_ctx *ctx = handle;
gcry_md_setkey (ctx->gch, key, len);
}
void
gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data)
{
_gc_hash_ctx *ctx = handle;
_MHD_gc_hash_ctx *ctx = handle;
gcry_md_write (ctx->gch, data, len);
}
const char *
gc_hash_read (gc_hash_handle handle)
MHD_gc_hash_read (MHD_gc_hash_handle handle)
{
_gc_hash_ctx *ctx = handle;
_MHD_gc_hash_ctx *ctx = handle;
const char *digest;
{
gcry_md_final (ctx->gch);
@@ -418,9 +418,9 @@ gc_hash_read (gc_hash_handle handle)
}
void
gc_hash_close (gc_hash_handle handle)
MHD_gc_hash_close (MHD_gc_hash_handle handle)
{
_gc_hash_ctx *ctx = handle;
_MHD_gc_hash_ctx *ctx = handle;
gcry_md_close (ctx->gch);
@@ -428,7 +428,7 @@ gc_hash_close (gc_hash_handle handle)
}
Gc_rc
gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
{
int gcryalg;
@@ -482,7 +482,7 @@ gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
/* One-call interface. */
#ifdef GNULIB_GC_MD5
Gc_rc
gc_md5 (const void *in, size_t inlen, void *resbuf)
MHD_gc_md5 (const void *in, size_t inlen, void *resbuf)
{
size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
gcry_md_hd_t hd;
@@ -514,7 +514,7 @@ gc_md5 (const void *in, size_t inlen, void *resbuf)
#ifdef GNULIB_GC_SHA1
Gc_rc
gc_sha1 (const void *in, size_t inlen, void *resbuf)
MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
{
size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
gcry_md_hd_t hd;
@@ -546,7 +546,7 @@ gc_sha1 (const void *in, size_t inlen, void *resbuf)
#ifdef GNULIB_GC_HMAC_MD5
Gc_rc
gc_hmac_md5 (const void *key, size_t keylen,
MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
const void *in, size_t inlen, char *resbuf)
{
size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
@@ -586,7 +586,7 @@ gc_hmac_md5 (const void *key, size_t keylen,
#ifdef GNULIB_GC_HMAC_SHA1
Gc_rc
gc_hmac_sha1 (const void *key,
MHD_gc_MHD_hmac_sha1 (const void *key,
size_t keylen, const void *in, size_t inlen, char *resbuf)
{
size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
src/daemon/https/lgl/gc-pbkdf2-sha1.c
+3 -3
View File
@@ -52,7 +52,7 @@
*/
Gc_rc
gc_pbkdf2_sha1 (const char *P, size_t Plen,
MHD_gc_pbkdf2_sha1 (const char *P, size_t Plen,
const char *S, size_t Slen,
unsigned int c, char *DK, size_t dkLen)
{
@@ -161,10 +161,10 @@ gc_pbkdf2_sha1 (const char *P, size_t Plen,
tmp[Slen + 2] = (i & 0x0000ff00) >> 8;
tmp[Slen + 3] = (i & 0x000000ff) >> 0;
rc = gc_hmac_sha1 (P, Plen, tmp, tmplen, U);
rc = MHD_gc_MHD_hmac_sha1 (P, Plen, tmp, tmplen, U);
}
else
rc = gc_hmac_sha1 (P, Plen, U, hLen, U);
rc = MHD_gc_MHD_hmac_sha1 (P, Plen, U, hLen, U);
if (rc != GC_OK)
{
src/daemon/https/lgl/gc.h
+39 -39
View File
@@ -58,7 +58,7 @@ enum Gc_hash_mode
};
typedef enum Gc_hash_mode Gc_hash_mode;
typedef void *gc_hash_handle;
typedef void *MHD_gc_hash_handle;
#define GC_MD2_DIGEST_SIZE 16
#define GC_MD4_DIGEST_SIZE 16
@@ -93,49 +93,49 @@ enum Gc_cipher_mode
};
typedef enum Gc_cipher_mode Gc_cipher_mode;
typedef void *gc_cipher_handle;
typedef void *MHD_gc_cipher_handle;
/* Call before respectively after any other functions. */
Gc_rc gc_init (void);
void gc_done (void);
Gc_rc MHD_gc_init (void);
void MHD_gc_done (void);
/* Memory allocation (avoid). */
typedef void *(*gc_malloc_t) (size_t n);
typedef int (*gc_secure_check_t) (const void *);
typedef void *(*gc_realloc_t) (void *p, size_t n);
typedef void (*gc_free_t) (void *);
void gc_set_allocators (gc_malloc_t func_malloc,
gc_malloc_t secure_malloc,
gc_secure_check_t secure_check,
gc_realloc_t func_realloc, gc_free_t func_free);
typedef void *(*MHD_gc_malloc_t) (size_t n);
typedef int (*MHD_gc_secure_check_t) (const void *);
typedef void *(*MHD_gc_realloc_t) (void *p, size_t n);
typedef void (*MHD_gc_free_t) (void *);
void MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
MHD_gc_malloc_t secure_malloc,
MHD_gc_secure_check_t secure_check,
MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free);
/* Randomness. */
Gc_rc gc_nonce (char *data, size_t datalen);
Gc_rc gc_pseudo_random (char *data, size_t datalen);
Gc_rc gc_random (char *data, size_t datalen);
Gc_rc MHD_gc_nonce (char *data, size_t datalen);
Gc_rc MHD_gc_pseudo_random (char *data, size_t datalen);
Gc_rc MHD_gc_random (char *data, size_t datalen);
/* Ciphers. */
Gc_rc gc_cipher_open (Gc_cipher cipher,
Gc_cipher_mode mode, gc_cipher_handle * outhandle);
Gc_rc gc_cipher_setkey (gc_cipher_handle handle,
Gc_rc MHD_gc_cipher_open (Gc_cipher cipher,
Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle);
Gc_rc MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle,
size_t keylen, const char *key);
Gc_rc gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv);
Gc_rc gc_cipher_encrypt_inline (gc_cipher_handle handle,
Gc_rc MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv);
Gc_rc MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle,
size_t len, char *data);
Gc_rc gc_cipher_decrypt_inline (gc_cipher_handle handle,
Gc_rc MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle,
size_t len, char *data);
Gc_rc gc_cipher_close (gc_cipher_handle handle);
Gc_rc MHD_gc_cipher_close (MHD_gc_cipher_handle handle);
/* Hashes. */
Gc_rc gc_hash_open (Gc_hash hash,
Gc_hash_mode mode, gc_hash_handle * outhandle);
Gc_rc gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle);
size_t gc_hash_digest_length (Gc_hash hash);
void gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key);
void gc_hash_write (gc_hash_handle handle, size_t len, const char *data);
const char *gc_hash_read (gc_hash_handle handle);
void gc_hash_close (gc_hash_handle handle);
Gc_rc MHD_gc_hash_open (Gc_hash hash,
Gc_hash_mode mode, MHD_gc_hash_handle * outhandle);
Gc_rc MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle);
size_t MHD_gc_hash_digest_length (Gc_hash hash);
void MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len, const char *key);
void MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data);
const char *MHD_gc_hash_read (MHD_gc_hash_handle handle);
void MHD_gc_hash_close (MHD_gc_hash_handle handle);
/* Compute a hash value over buffer IN of INLEN bytes size using the
algorithm HASH, placing the result in the pre-allocated buffer OUT.
@@ -143,16 +143,16 @@ void gc_hash_close (gc_hash_handle handle);
GC_<HASH>_DIGEST_SIZE. For example, for GC_MD5 the output buffer
must be 16 bytes. The return value is 0 (GC_OK) on success, or
another Gc_rc error code. */
Gc_rc gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *out);
Gc_rc MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *out);
/* One-call interface. */
Gc_rc gc_md2 (const void *in, size_t inlen, void *resbuf);
Gc_rc gc_md4 (const void *in, size_t inlen, void *resbuf);
Gc_rc gc_md5 (const void *in, size_t inlen, void *resbuf);
Gc_rc gc_sha1 (const void *in, size_t inlen, void *resbuf);
Gc_rc gc_hmac_md5 (const void *key,
Gc_rc MHD_gc_md2 (const void *in, size_t inlen, void *resbuf);
Gc_rc MHD_gc_md4 (const void *in, size_t inlen, void *resbuf);
Gc_rc MHD_gc_md5 (const void *in, size_t inlen, void *resbuf);
Gc_rc MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf);
Gc_rc MHD_gc_MHD_hmac_md5 (const void *key,
size_t keylen, const void *in, size_t inlen, char *resbuf);
Gc_rc gc_hmac_sha1 (const void *key,
Gc_rc MHD_gc_MHD_hmac_sha1 (const void *key,
size_t keylen,
const void *in, size_t inlen, char *resbuf);
@@ -163,7 +163,7 @@ Gc_rc gc_hmac_sha1 (const void *key,
counts are 1000-20000). This function "stretches" the key to be
exactly dkLen bytes long. GC_OK is returned on success, otherwise
an Gc_rc error code is returned. */
Gc_rc gc_pbkdf2_sha1 (const char *P,
Gc_rc MHD_gc_pbkdf2_sha1 (const char *P,
size_t Plen,
const char *S,
size_t Slen, unsigned int c, char *DK, size_t dkLen);
@@ -285,7 +285,7 @@ Gc_rc gc_pbkdf2_sha1 (const char *P,
requirement, what entropy quality it require, and call the proper API.
Meeting the implied semantic properties should be the job for gnulib.
>> Perhaps gc_dev_random and gc_dev_urandom?
>> Perhaps MHD_gc_dev_random and MHD_gc_dev_urandom?
>
> To some extent. I'd rather insulate the user from the details of
> where the random numbers come from. On the other hand we need to
src/daemon/https/lgl/hmac-md5.c
+17 -17
View File
@@ -30,11 +30,11 @@
#define OPAD 0x5c
int
hmac_md5 (const void *key, size_t keylen,
MHD_hmac_md5 (const void *key, size_t keylen,
const void *in, size_t inlen, void *resbuf)
{
struct md5_ctx inner;
struct md5_ctx outer;
struct MHD_md5_ctx inner;
struct MHD_md5_ctx outer;
char optkeybuf[16];
char block[64];
char innerhash[16];
@@ -43,11 +43,11 @@ hmac_md5 (const void *key, size_t keylen,
if (keylen > 64)
{
struct md5_ctx keyhash;
struct MHD_md5_ctx keyhash;
md5_init_ctx (&keyhash);
md5_process_bytes (key, keylen, &keyhash);
md5_finish_ctx (&keyhash, optkeybuf);
MHD_md5_init_ctx (&keyhash);
MHD_md5_process_bytes (key, keylen, &keyhash);
MHD_md5_finish_ctx (&keyhash, optkeybuf);
key = optkeybuf;
keylen = 16;
@@ -55,27 +55,27 @@ hmac_md5 (const void *key, size_t keylen,
/* Compute INNERHASH from KEY and IN. */
md5_init_ctx (&inner);
MHD_md5_init_ctx (&inner);
memset (block, IPAD, sizeof (block));
memxor (block, key, keylen);
MHD_memxor (block, key, keylen);
md5_process_block (block, 64, &inner);
md5_process_bytes (in, inlen, &inner);
MHD_md5_process_block (block, 64, &inner);
MHD_md5_process_bytes (in, inlen, &inner);
md5_finish_ctx (&inner, innerhash);
MHD_md5_finish_ctx (&inner, innerhash);
/* Compute result from KEY and INNERHASH. */
md5_init_ctx (&outer);
MHD_md5_init_ctx (&outer);
memset (block, OPAD, sizeof (block));
memxor (block, key, keylen);
MHD_memxor (block, key, keylen);
md5_process_block (block, 64, &outer);
md5_process_bytes (innerhash, 16, &outer);
MHD_md5_process_block (block, 64, &outer);
MHD_md5_process_bytes (innerhash, 16, &outer);
md5_finish_ctx (&outer, resbuf);
MHD_md5_finish_ctx (&outer, resbuf);
return 0;
}
src/daemon/https/lgl/hmac-sha1.c
+17 -17
View File
@@ -30,11 +30,11 @@
#define OPAD 0x5c
int
hmac_sha1 (const void *key, size_t keylen,
MHD_hmac_sha1 (const void *key, size_t keylen,
const void *in, size_t inlen, void *resbuf)
{
struct sha1_ctx inner;
struct sha1_ctx outer;
struct MHD_sha1_ctx inner;
struct MHD_sha1_ctx outer;
char optkeybuf[20];
char block[64];
char innerhash[20];
@@ -43,11 +43,11 @@ hmac_sha1 (const void *key, size_t keylen,
if (keylen > 64)
{
struct sha1_ctx keyhash;
struct MHD_sha1_ctx keyhash;
sha1_init_ctx (&keyhash);
sha1_process_bytes (key, keylen, &keyhash);
sha1_finish_ctx (&keyhash, optkeybuf);
MHD_sha1_init_ctx (&keyhash);
MHD_sha1_process_bytes (key, keylen, &keyhash);
MHD_sha1_finish_ctx (&keyhash, optkeybuf);
key = optkeybuf;
keylen = 20;
@@ -55,27 +55,27 @@ hmac_sha1 (const void *key, size_t keylen,
/* Compute INNERHASH from KEY and IN. */
sha1_init_ctx (&inner);
MHD_sha1_init_ctx (&inner);
memset (block, IPAD, sizeof (block));
memxor (block, key, keylen);
MHD_memxor (block, key, keylen);
sha1_process_block (block, 64, &inner);
sha1_process_bytes (in, inlen, &inner);
MHD_sha1_process_block (block, 64, &inner);
MHD_sha1_process_bytes (in, inlen, &inner);
sha1_finish_ctx (&inner, innerhash);
MHD_sha1_finish_ctx (&inner, innerhash);
/* Compute result from KEY and INNERHASH. */
sha1_init_ctx (&outer);
MHD_sha1_init_ctx (&outer);
memset (block, OPAD, sizeof (block));
memxor (block, key, keylen);
MHD_memxor (block, key, keylen);
sha1_process_block (block, 64, &outer);
sha1_process_bytes (innerhash, 20, &outer);
MHD_sha1_process_block (block, 64, &outer);
MHD_sha1_process_bytes (innerhash, 20, &outer);
sha1_finish_ctx (&outer, resbuf);
MHD_sha1_finish_ctx (&outer, resbuf);
return 0;
}
src/daemon/https/lgl/hmac.h
+2 -2
View File
@@ -27,7 +27,7 @@
KEYLEN bytes, writing the output to pre-allocated 16 byte minimum
RESBUF buffer. Return 0 on success. */
int
hmac_md5 (const void *key, size_t keylen,
MHD_hmac_md5 (const void *key, size_t keylen,
const void *buffer, size_t buflen, void *resbuf);
/* Compute Hashed Message Authentication Code with SHA-1, over BUFFER
@@ -35,7 +35,7 @@ hmac_md5 (const void *key, size_t keylen,
output to pre-allocated 20 byte minimum RESBUF buffer. Return 0 on
success. */
int
hmac_sha1 (const void *key, size_t keylen,
MHD_hmac_sha1 (const void *key, size_t keylen,
const void *in, size_t inlen, void *resbuf);
#endif /* HMAC_H */
src/daemon/https/lgl/md5.c
+29 -29
View File
@@ -40,13 +40,13 @@
# endif
/* We need to keep the namespace clean so define the MD5 function
protected using leading __ . */
# define md5_init_ctx __md5_init_ctx
# define md5_process_block __md5_process_block
# define md5_process_bytes __md5_process_bytes
# define md5_finish_ctx __md5_finish_ctx
# define md5_read_ctx __md5_read_ctx
# define md5_stream __md5_stream
# define md5_buffer __md5_buffer
# define MHD_md5_init_ctx __MHD_md5_init_ctx
# define MHD_md5_process_block __MHD_md5_process_block
# define MHD_md5_process_bytes __MHD_md5_process_bytes
# define MHD_md5_finish_ctx __MHD_md5_finish_ctx
# define MHD_md5_read_ctx __MHD_md5_read_ctx
# define MHD_md5_stream __MHD_md5_stream
# define MHD_md5_buffer __MHD_md5_buffer
#endif
#ifdef WORDS_BIGENDIAN
@@ -69,7 +69,7 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
/* Initialize structure containing state of computation.
(RFC 1321, 3.3: Step 3) */
void
md5_init_ctx (struct md5_ctx *ctx)
MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
{
ctx->A = 0x67452301;
ctx->B = 0xefcdab89;
@@ -86,7 +86,7 @@ md5_init_ctx (struct md5_ctx *ctx)
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32-bit value. */
void *
md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
MHD_md5_read_ctx (const struct MHD_md5_ctx *ctx, void *resbuf)
{
((uint32_t *) resbuf)[0] = SWAP (ctx->A);
((uint32_t *) resbuf)[1] = SWAP (ctx->B);
@@ -102,7 +102,7 @@ md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32-bit value. */
void *
md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
MHD_md5_finish_ctx (struct MHD_md5_ctx *ctx, void *resbuf)
{
/* Take yet unprocessed bytes into account. */
uint32_t bytes = ctx->buflen;
@@ -120,23 +120,23 @@ md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
/* Process last bytes. */
md5_process_block (ctx->buffer, size * 4, ctx);
MHD_md5_process_block (ctx->buffer, size * 4, ctx);
return md5_read_ctx (ctx, resbuf);
return MHD_md5_read_ctx (ctx, resbuf);
}
/* Compute MD5 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */
int
md5_stream (FILE * stream, void *resblock)
MHD_md5_stream (FILE * stream, void *resblock)
{
struct md5_ctx ctx;
struct MHD_md5_ctx ctx;
char buffer[BLOCKSIZE + 72];
size_t sum;
/* Initialize the computation context. */
md5_init_ctx (&ctx);
MHD_md5_init_ctx (&ctx);
/* Iterate over full file contents. */
while (1)
@@ -177,17 +177,17 @@ md5_stream (FILE * stream, void *resblock)
/* Process buffer with BLOCKSIZE bytes. Note that
BLOCKSIZE % 64 == 0
*/
md5_process_block (buffer, BLOCKSIZE, &ctx);
MHD_md5_process_block (buffer, BLOCKSIZE, &ctx);
}
process_partial_block:
/* Process any remaining bytes. */
if (sum > 0)
md5_process_bytes (buffer, sum, &ctx);
MHD_md5_process_bytes (buffer, sum, &ctx);
/* Construct result in desired memory. */
md5_finish_ctx (&ctx, resblock);
MHD_md5_finish_ctx (&ctx, resblock);
return 0;
}
@@ -196,23 +196,23 @@ process_partial_block:
output yields to the wanted ASCII representation of the message
digest. */
void *
md5_buffer (const char *buffer, size_t len, void *resblock)
MHD_md5_buffer (const char *buffer, size_t len, void *resblock)
{
struct md5_ctx ctx;
struct MHD_md5_ctx ctx;
/* Initialize the computation context. */
md5_init_ctx (&ctx);
MHD_md5_init_ctx (&ctx);
/* Process whole buffer but last len % 64 bytes. */
md5_process_bytes (buffer, len, &ctx);
MHD_md5_process_bytes (buffer, len, &ctx);
/* Put result in desired memory area. */
return md5_finish_ctx (&ctx, resblock);
return MHD_md5_finish_ctx (&ctx, resblock);
}
void
md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
MHD_md5_process_bytes (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
{
/* When we already have some bits in our internal buffer concatenate
both inputs first. */
@@ -226,7 +226,7 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
if (ctx->buflen > 64)
{
md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
MHD_md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
ctx->buflen &= 63;
/* The regions in the following copy operation cannot overlap. */
@@ -248,14 +248,14 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
if (UNALIGNED_P (buffer))
while (len > 64)
{
md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
MHD_md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
buffer = (const char *) buffer + 64;
len -= 64;
}
else
#endif
{
md5_process_block (buffer, len & ~63, ctx);
MHD_md5_process_block (buffer, len & ~63, ctx);
buffer = (const char *) buffer + (len & ~63);
len &= 63;
}
@@ -270,7 +270,7 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
left_over += len;
if (left_over >= 64)
{
md5_process_block (ctx->buffer, 64, ctx);
MHD_md5_process_block (ctx->buffer, 64, ctx);
left_over -= 64;
memcpy (ctx->buffer, &ctx->buffer[16], left_over);
}
@@ -292,7 +292,7 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
It is assumed that LEN % 64 == 0. */
void
md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
MHD_md5_process_block (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
{
uint32_t correct_words[16];
const uint32_t *words = buffer;
src/daemon/https/lgl/md5.h
+18 -18
View File
@@ -45,17 +45,17 @@
#endif
#ifndef _LIBC
# define __md5_buffer md5_buffer
# define __md5_finish_ctx md5_finish_ctx
# define __md5_init_ctx md5_init_ctx
# define __md5_process_block md5_process_block
# define __md5_process_bytes md5_process_bytes
# define __md5_read_ctx md5_read_ctx
# define __md5_stream md5_stream
# define __MHD_md5_buffer MHD_md5_buffer
# define __MHD_md5_finish_ctx MHD_md5_finish_ctx
# define __MHD_md5_init_ctx MHD_md5_init_ctx
# define __MHD_md5_process_block MHD_md5_process_block
# define __MHD_md5_process_bytes MHD_md5_process_bytes
# define __MHD_md5_read_ctx MHD_md5_read_ctx
# define __MHD_md5_stream MHD_md5_stream
#endif
/* Structure to save state of computation between the single steps. */
struct md5_ctx
struct MHD_md5_ctx
{
uint32_t A;
uint32_t B;
@@ -69,28 +69,28 @@ struct md5_ctx
/*
* The following three functions are build up the low level used in
* the functions `md5_stream' and `md5_buffer'.
* the functions `MHD_md5_stream' and `MHD_md5_buffer'.
*/
/* Initialize structure containing state of computation.
(RFC 1321, 3.3: Step 3) */
extern void
__md5_init_ctx (struct md5_ctx *ctx)
__MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
__THROW;
/* Starting with the result of former calls of this function (or the
initialization function update the context for the next LEN bytes
starting at BUFFER.
It is necessary that LEN is a multiple of 64!!! */
extern void __md5_process_block (const void *buffer, size_t len,
struct md5_ctx *ctx) __THROW;
extern void __MHD_md5_process_block (const void *buffer, size_t len,
struct MHD_md5_ctx *ctx) __THROW;
/* Starting with the result of former calls of this function (or the
initialization function update the context for the next LEN bytes
starting at BUFFER.
It is NOT required that LEN is a multiple of 64. */
extern void __md5_process_bytes (const void *buffer, size_t len,
struct md5_ctx *ctx) __THROW;
extern void __MHD_md5_process_bytes (const void *buffer, size_t len,
struct MHD_md5_ctx *ctx) __THROW;
/* Process the remaining bytes in the buffer and put result from CTX
in first 16 bytes following RESBUF. The result is always in little
@@ -99,7 +99,7 @@ __md5_init_ctx (struct md5_ctx *ctx)
IMPORTANT: On some systems, RESBUF must be aligned to a 32-bit
boundary. */
extern void *__md5_finish_ctx (struct md5_ctx *ctx,
extern void *__MHD_md5_finish_ctx (struct MHD_md5_ctx *ctx,
void *resbuf) __THROW;
@@ -109,20 +109,20 @@ __md5_init_ctx (struct md5_ctx *ctx)
IMPORTANT: On some systems, RESBUF must be aligned to a 32-bit
boundary. */
extern void *__md5_read_ctx (const struct md5_ctx *ctx,
extern void *__MHD_md5_read_ctx (const struct MHD_md5_ctx *ctx,
void *resbuf) __THROW;
/* Compute MD5 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */
extern int __md5_stream (FILE * stream, void *resblock) __THROW;
extern int __MHD_md5_stream (FILE * stream, void *resblock) __THROW;
/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
result is always in little endian byte order, so that a byte-wise
output yields to the wanted ASCII representation of the message
digest. */
extern void *__md5_buffer (const char *buffer, size_t len,
extern void *__MHD_md5_buffer (const char *buffer, size_t len,
void *resblock) __THROW;
#endif /* md5.h */
src/daemon/https/lgl/memmem.c
+2 -2
View File
@@ -26,11 +26,11 @@
# define __builtin_expect(expr, val) (expr)
#endif
#undef memmem
#undef MHD_memmem
/* Return the first occurrence of NEEDLE in HAYSTACK. */
void *
memmem (haystack, haystack_len, needle, needle_len)
MHD_memmem (haystack, haystack_len, needle, needle_len)
const void *haystack;
size_t haystack_len;
const void *needle;
src/daemon/https/lgl/memxor.c
+3 -3
View File
@@ -1,4 +1,4 @@
/* memxor.c -- perform binary exclusive OR operation of two memory blocks.
/* MHD_memxor.c -- perform binary exclusive OR operation of two memory blocks.
Copyright (C) 2005, 2006 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/* Written by Simon Josefsson. The interface was inspired by memxor
/* Written by Simon Josefsson. The interface was inspired by MHD_memxor
in Niels Möller's Nettle. */
#include "MHD_config.h"
@@ -23,7 +23,7 @@
#include "memxor.h"
void *
memxor (void *restrict dest, const void *restrict src, size_t n)
MHD_memxor (void *restrict dest, const void *restrict src, size_t n)
{
char const *s = src;
char *d = dest;
src/daemon/https/lgl/memxor.h
+3 -3
View File
@@ -1,4 +1,4 @@
/* memxor.h -- perform binary exclusive OR operation on memory blocks.
/* MHD_memxor.h -- perform binary exclusive OR operation on memory blocks.
Copyright (C) 2005 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/* Written by Simon Josefsson. The interface was inspired by memxor
/* Written by Simon Josefsson. The interface was inspired by MHD_memxor
in Niels Möller's Nettle. */
#ifndef MEMXOR_H
@@ -26,6 +26,6 @@
/* Compute binary exclusive OR of memory areas DEST and SRC, putting
the result in DEST, of length N bytes. Returns a pointer to
DEST. */
void *memxor (void *restrict dest, const void *restrict src, size_t n);
void *MHD_memxor (void *restrict dest, const void *restrict src, size_t n);
#endif /* MEMXOR_H */
src/daemon/https/lgl/sha1.c
+23 -23
View File
@@ -53,9 +53,9 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
/* Take a pointer to a 160 bit block of data (five 32 bit ints) and
initialize it to the start constants of the SHA1 algorithm. This
must be called before using hash in the call to sha1_hash. */
must be called before using hash in the call to MHD_sha1_hash. */
void
sha1_init_ctx (struct sha1_ctx *ctx)
MHD_sha1_init_ctx (struct MHD_sha1_ctx *ctx)
{
ctx->A = 0x67452301;
ctx->B = 0xefcdab89;
@@ -73,7 +73,7 @@ sha1_init_ctx (struct sha1_ctx *ctx)
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32-bit value. */
void *
sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf)
MHD_sha1_read_ctx (const struct MHD_sha1_ctx *ctx, void *resbuf)
{
((uint32_t *) resbuf)[0] = SWAP (ctx->A);
((uint32_t *) resbuf)[1] = SWAP (ctx->B);
@@ -90,7 +90,7 @@ sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf)
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32-bit value. */
void *
sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
MHD_sha1_finish_ctx (struct MHD_sha1_ctx *ctx, void *resbuf)
{
/* Take yet unprocessed bytes into account. */
uint32_t bytes = ctx->buflen;
@@ -108,23 +108,23 @@ sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
/* Process last bytes. */
sha1_process_block (ctx->buffer, size * 4, ctx);
MHD_sha1_process_block (ctx->buffer, size * 4, ctx);
return sha1_read_ctx (ctx, resbuf);
return MHD_sha1_read_ctx (ctx, resbuf);
}
/* Compute SHA1 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */
int
sha1_stream (FILE * stream, void *resblock)
MHD_sha1_stream (FILE * stream, void *resblock)
{
struct sha1_ctx ctx;
struct MHD_sha1_ctx ctx;
char buffer[BLOCKSIZE + 72];
size_t sum;
/* Initialize the computation context. */
sha1_init_ctx (&ctx);
MHD_sha1_init_ctx (&ctx);
/* Iterate over full file contents. */
while (1)
@@ -165,17 +165,17 @@ sha1_stream (FILE * stream, void *resblock)
/* Process buffer with BLOCKSIZE bytes. Note that
BLOCKSIZE % 64 == 0
*/
sha1_process_block (buffer, BLOCKSIZE, &ctx);
MHD_sha1_process_block (buffer, BLOCKSIZE, &ctx);
}
process_partial_block:;
/* Process any remaining bytes. */
if (sum > 0)
sha1_process_bytes (buffer, sum, &ctx);
MHD_sha1_process_bytes (buffer, sum, &ctx);
/* Construct result in desired memory. */
sha1_finish_ctx (&ctx, resblock);
MHD_sha1_finish_ctx (&ctx, resblock);
return 0;
}
@@ -184,22 +184,22 @@ process_partial_block:;
output yields to the wanted ASCII representation of the message
digest. */
void *
sha1_buffer (const char *buffer, size_t len, void *resblock)
MHD_sha1_buffer (const char *buffer, size_t len, void *resblock)
{
struct sha1_ctx ctx;
struct MHD_sha1_ctx ctx;
/* Initialize the computation context. */
sha1_init_ctx (&ctx);
MHD_sha1_init_ctx (&ctx);
/* Process whole buffer but last len % 64 bytes. */
sha1_process_bytes (buffer, len, &ctx);
MHD_sha1_process_bytes (buffer, len, &ctx);
/* Put result in desired memory area. */
return sha1_finish_ctx (&ctx, resblock);
return MHD_sha1_finish_ctx (&ctx, resblock);
}
void
sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
MHD_sha1_process_bytes (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx)
{
/* When we already have some bits in our internal buffer concatenate
both inputs first. */
@@ -213,7 +213,7 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
if (ctx->buflen > 64)
{
sha1_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
MHD_sha1_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
ctx->buflen &= 63;
/* The regions in the following copy operation cannot overlap. */
@@ -235,14 +235,14 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
if (UNALIGNED_P (buffer))
while (len > 64)
{
sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
MHD_sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
buffer = (const char *) buffer + 64;
len -= 64;
}
else
#endif
{
sha1_process_block (buffer, len & ~63, ctx);
MHD_sha1_process_block (buffer, len & ~63, ctx);
buffer = (const char *) buffer + (len & ~63);
len &= 63;
}
@@ -257,7 +257,7 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
left_over += len;
if (left_over >= 64)
{
sha1_process_block (ctx->buffer, 64, ctx);
MHD_sha1_process_block (ctx->buffer, 64, ctx);
left_over -= 64;
memcpy (ctx->buffer, &ctx->buffer[16], left_over);
}
@@ -284,7 +284,7 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
Most of this code comes from GnuPG's cipher/sha1.c. */
void
sha1_process_block (const void *buffer, size_t len, struct sha1_ctx *ctx)
MHD_sha1_process_block (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx)
{
const uint32_t *words = buffer;
size_t nwords = len / sizeof (uint32_t);
src/daemon/https/lgl/sha1.h
+10 -10
View File
@@ -23,7 +23,7 @@
# include <stdint.h>
/* Structure to save state of computation between the single steps. */
struct sha1_ctx
struct MHD_sha1_ctx
{
uint32_t A;
uint32_t B;
@@ -38,21 +38,21 @@ struct sha1_ctx
/* Initialize structure containing state of computation. */
extern void sha1_init_ctx (struct sha1_ctx *ctx);
extern void MHD_sha1_init_ctx (struct MHD_sha1_ctx *ctx);
/* Starting with the result of former calls of this function (or the
initialization function update the context for the next LEN bytes
starting at BUFFER.
It is necessary that LEN is a multiple of 64!!! */
extern void sha1_process_block (const void *buffer, size_t len,
struct sha1_ctx *ctx);
extern void MHD_sha1_process_block (const void *buffer, size_t len,
struct MHD_sha1_ctx *ctx);
/* Starting with the result of former calls of this function (or the
initialization function update the context for the next LEN bytes
starting at BUFFER.
It is NOT required that LEN is a multiple of 64. */
extern void sha1_process_bytes (const void *buffer, size_t len,
struct sha1_ctx *ctx);
extern void MHD_sha1_process_bytes (const void *buffer, size_t len,
struct MHD_sha1_ctx *ctx);
/* Process the remaining bytes in the buffer and put result from CTX
in first 20 bytes following RESBUF. The result is always in little
@@ -61,7 +61,7 @@ extern void sha1_process_bytes (const void *buffer, size_t len,
IMPORTANT: On some systems it is required that RESBUF be correctly
aligned for a 32 bits value. */
extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf);
extern void *MHD_sha1_finish_ctx (struct MHD_sha1_ctx *ctx, void *resbuf);
/* Put result from CTX in first 20 bytes following RESBUF. The result is
@@ -70,18 +70,18 @@ extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf);
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32 bits value. */
extern void *sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf);
extern void *MHD_sha1_read_ctx (const struct MHD_sha1_ctx *ctx, void *resbuf);
/* Compute SHA1 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 20 bytes
beginning at RESBLOCK. */
extern int sha1_stream (FILE * stream, void *resblock);
extern int MHD_sha1_stream (FILE * stream, void *resblock);
/* Compute SHA1 message digest for LEN bytes beginning at BUFFER. The
result is always in little endian byte order, so that a byte-wise
output yields to the wanted ASCII representation of the message
digest. */
extern void *sha1_buffer (const char *buffer, size_t len, void *resblock);
extern void *MHD_sha1_buffer (const char *buffer, size_t len, void *resblock);
#endif
src/daemon/https/lgl/time_r.c
-46
View File
@@ -1,46 +0,0 @@
/* Reentrant time functions like localtime_r.
Copyright (C) 2003, 2006, 2007 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1, or (at your option)
any later version.
This program 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/* Written by Paul Eggert. */
#include "MHD_config.h"
#include <time.h>
#include <string.h>
static struct tm *
copy_tm_result (struct tm *dest, struct tm const *src)
{
if (!src)
return 0;
*dest = *src;
return dest;
}
struct tm *
gmtime_r (time_t const *restrict t, struct tm *restrict tp)
{
return copy_tm_result (tp, gmtime (t));
}
struct tm *
localtime_r (time_t const *restrict t, struct tm *restrict tp)
{
return copy_tm_result (tp, localtime (t));
}
src/daemon/https/minitasn1/coding.c
+103 -103
View File
@@ -37,7 +37,7 @@
#define MAX_TAG_LEN 16
/******************************************************/
/* Function : _asn1_error_description_value_not_found */
/* Function : MHD__asn1_error_description_value_not_found */
/* Description: creates the ErrorDescription string */
/* for the ASN1_VALUE_NOT_FOUND error. */
/* Parameters: */
@@ -46,7 +46,7 @@
/* Return: */
/******************************************************/
void
_asn1_error_description_value_not_found (node_asn * node,
MHD__asn1_error_description_value_not_found (node_asn * node,
char *ErrorDescription)
{
@@ -54,14 +54,14 @@ _asn1_error_description_value_not_found (node_asn * node,
return;
Estrcpy (ErrorDescription, ":: value of element '");
_asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
MHD__asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
MAX_ERROR_DESCRIPTION_SIZE - 40);
Estrcat (ErrorDescription, "' not found");
}
/**
* asn1_length_der:
* MHD__asn1_length_der:
* @len: value to convert.
* @ans: string returned.
* @ans_len: number of meaningful bytes of ANS (ans[0]..ans[ans_len-1]).
@@ -70,7 +70,7 @@ _asn1_error_description_value_not_found (node_asn * node,
* The @ans buffer is pre-allocated and must have room for the output.
**/
void
asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
MHD__asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
{
int k;
unsigned char temp[SIZEOF_UNSIGNED_LONG_INT];
@@ -102,7 +102,7 @@ asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
}
/******************************************************/
/* Function : _asn1_tag_der */
/* Function : MHD__asn1_tag_der */
/* Description: creates the DER coding for the CLASS */
/* and TAG parameters. */
/* Parameters: */
@@ -114,7 +114,7 @@ asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
/* Return: */
/******************************************************/
void
_asn1_tag_der (unsigned char class, unsigned int tag_value,
MHD__asn1_tag_der (unsigned char class, unsigned int tag_value,
unsigned char *ans, int *ans_len)
{
int k;
@@ -144,7 +144,7 @@ _asn1_tag_der (unsigned char class, unsigned int tag_value,
}
/**
* asn1_octet_der:
* MHD__asn1_octet_der:
* @str: OCTET string.
* @str_len: STR length (str[0]..str[str_len-1]).
* @der: string returned.
@@ -153,20 +153,20 @@ _asn1_tag_der (unsigned char class, unsigned int tag_value,
* Creates the DER coding for an OCTET type (length included).
**/
void
asn1_octet_der (const unsigned char *str, int str_len,
MHD__asn1_octet_der (const unsigned char *str, int str_len,
unsigned char *der, int *der_len)
{
int len_len;
if (der == NULL || str_len < 0)
return;
asn1_length_der (str_len, der, &len_len);
MHD__asn1_length_der (str_len, der, &len_len);
memcpy (der + len_len, str, str_len);
*der_len = str_len + len_len;
}
/******************************************************/
/* Function : _asn1_time_der */
/* Function : MHD__asn1_time_der */
/* Description: creates the DER coding for a TIME */
/* type (length included). */
/* Parameters: */
@@ -179,15 +179,15 @@ asn1_octet_der (const unsigned char *str, int str_len,
/* ASN1_MEM_ERROR when DER isn't big enough */
/* ASN1_SUCCESS otherwise */
/******************************************************/
asn1_retCode
_asn1_time_der (unsigned char *str, unsigned char *der, int *der_len)
MHD__asn1_retCode
MHD__asn1_time_der (unsigned char *str, unsigned char *der, int *der_len)
{
int len_len;
int max_len;
max_len = *der_len;
asn1_length_der (strlen (str), (max_len > 0) ? der : NULL, &len_len);
MHD__asn1_length_der (strlen (str), (max_len > 0) ? der : NULL, &len_len);
if ((len_len + (int) strlen (str)) <= max_len)
memcpy (der + len_len, str, strlen (str));
@@ -202,13 +202,13 @@ _asn1_time_der (unsigned char *str, unsigned char *der, int *der_len)
/*
void
_asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
MHD__asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
{
int len_len,str_len;
char temp[20];
if(str==NULL) return;
str_len=asn1_get_length_der(der,*der_len,&len_len);
str_len=MHD__asn1_get_length_der(der,*der_len,&len_len);
if (str_len<0) return;
memcpy(temp,der+len_len,str_len);
*der_len=str_len+len_len;
@@ -237,7 +237,7 @@ _asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
*/
/******************************************************/
/* Function : _asn1_objectid_der */
/* Function : MHD__asn1_objectid_der */
/* Description: creates the DER coding for an */
/* OBJECT IDENTIFIER type (length included). */
/* Parameters: */
@@ -250,8 +250,8 @@ _asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
/* ASN1_MEM_ERROR when DER isn't big enough */
/* ASN1_SUCCESS otherwise */
/******************************************************/
asn1_retCode
_asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
MHD__asn1_retCode
MHD__asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
{
int len_len, counter, k, first, max_len;
char *temp, *n_end, *n_start;
@@ -260,7 +260,7 @@ _asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
max_len = *der_len;
temp = (char *) _asn1_alloca (strlen (str) + 2);
temp = (char *) MHD__asn1_alloca (strlen (str) + 2);
if (temp == NULL)
return ASN1_MEM_ALLOC_ERROR;
@@ -304,15 +304,15 @@ _asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
n_start = n_end + 1;
}
asn1_length_der (*der_len, NULL, &len_len);
MHD__asn1_length_der (*der_len, NULL, &len_len);
if (max_len >= (*der_len + len_len))
{
memmove (der + len_len, der, *der_len);
asn1_length_der (*der_len, der, &len_len);
MHD__asn1_length_der (*der_len, der, &len_len);
}
*der_len += len_len;
_asn1_afree (temp);
MHD__asn1_afree (temp);
if (max_len < (*der_len))
return ASN1_MEM_ERROR;
@@ -324,7 +324,7 @@ _asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
const char bit_mask[] = { 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80 };
/**
* asn1_bit_der:
* MHD__asn1_bit_der:
* @str: BIT string.
* @bit_len: number of meaningful bits in STR.
* @der: string returned.
@@ -335,7 +335,7 @@ const char bit_mask[] = { 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80 };
* included).
**/
void
asn1_bit_der (const unsigned char *str, int bit_len,
MHD__asn1_bit_der (const unsigned char *str, int bit_len,
unsigned char *der, int *der_len)
{
int len_len, len_byte, len_pad;
@@ -348,7 +348,7 @@ asn1_bit_der (const unsigned char *str, int bit_len,
len_pad = 0;
else
len_byte++;
asn1_length_der (len_byte + 1, der, &len_len);
MHD__asn1_length_der (len_byte + 1, der, &len_len);
der[len_len] = len_pad;
memcpy (der + len_len + 1, str, len_byte);
der[len_len + len_byte] &= bit_mask[len_pad];
@@ -357,7 +357,7 @@ asn1_bit_der (const unsigned char *str, int bit_len,
/******************************************************/
/* Function : _asn1_complete_explicit_tag */
/* Function : MHD__asn1_complete_explicit_tag */
/* Description: add the length coding to the EXPLICIT */
/* tags. */
/* Parameters: */
@@ -370,8 +370,8 @@ asn1_bit_der (const unsigned char *str, int bit_len,
/* ASN1_MEM_ERROR if der vector isn't big enough, */
/* otherwise ASN1_SUCCESS. */
/******************************************************/
asn1_retCode
_asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
MHD__asn1_retCode
MHD__asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
int *counter, int *max_len)
{
node_asn *p;
@@ -397,8 +397,8 @@ _asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
if (p->type & CONST_EXPLICIT)
{
len2 = strtol (p->name, NULL, 10);
_asn1_set_name (p, NULL);
asn1_length_der (*counter - len2, temp, &len3);
MHD__asn1_set_name (p, NULL);
MHD__asn1_length_der (*counter - len2, temp, &len3);
if (len3 <= (*max_len))
{
memmove (der + len2 + len3, der + len2,
@@ -429,7 +429,7 @@ _asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
/******************************************************/
/* Function : _asn1_insert_tag_der */
/* Function : MHD__asn1_insert_tag_der */
/* Description: creates the DER coding of tags of one */
/* NODE. */
/* Parameters: */
@@ -443,8 +443,8 @@ _asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
/* ASN1_MEM_ERROR if der vector isn't big enough, */
/* otherwise ASN1_SUCCESS. */
/******************************************************/
asn1_retCode
_asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
MHD__asn1_retCode
MHD__asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
int *max_len)
{
node_asn *p;
@@ -474,10 +474,10 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
if (p->type & CONST_EXPLICIT)
{
if (is_tag_implicit)
_asn1_tag_der (class_implicit, tag_implicit, tag_der,
MHD__asn1_tag_der (class_implicit, tag_implicit, tag_der,
&tag_len);
else
_asn1_tag_der (class | ASN1_CLASS_STRUCTURED,
MHD__asn1_tag_der (class | ASN1_CLASS_STRUCTURED,
strtoul (p->value, NULL, 10), tag_der,
&tag_len);
@@ -486,8 +486,8 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
memcpy (der + *counter, tag_der, tag_len);
*counter += tag_len;
_asn1_ltostr (*counter, temp);
_asn1_set_name (p, temp);
MHD__asn1_ltostr (*counter, temp);
MHD__asn1_set_name (p, temp);
is_tag_implicit = 0;
}
@@ -512,62 +512,62 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
if (is_tag_implicit)
{
_asn1_tag_der (class_implicit, tag_implicit, tag_der, &tag_len);
MHD__asn1_tag_der (class_implicit, tag_implicit, tag_der, &tag_len);
}
else
{
switch (type_field (node->type))
{
case TYPE_NULL:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_NULL, tag_der,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_NULL, tag_der,
&tag_len);
break;
case TYPE_BOOLEAN:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BOOLEAN, tag_der,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BOOLEAN, tag_der,
&tag_len);
break;
case TYPE_INTEGER:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_INTEGER, tag_der,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_INTEGER, tag_der,
&tag_len);
break;
case TYPE_ENUMERATED:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_ENUMERATED, tag_der,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_ENUMERATED, tag_der,
&tag_len);
break;
case TYPE_OBJECT_ID:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OBJECT_ID, tag_der,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OBJECT_ID, tag_der,
&tag_len);
break;
case TYPE_TIME:
if (node->type & CONST_UTC)
{
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_UTCTime, tag_der,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_UTCTime, tag_der,
&tag_len);
}
else
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALIZEDTime,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALIZEDTime,
tag_der, &tag_len);
break;
case TYPE_OCTET_STRING:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OCTET_STRING, tag_der,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OCTET_STRING, tag_der,
&tag_len);
break;
case TYPE_GENERALSTRING:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALSTRING,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALSTRING,
tag_der, &tag_len);
break;
case TYPE_BIT_STRING:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BIT_STRING, tag_der,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BIT_STRING, tag_der,
&tag_len);
break;
case TYPE_SEQUENCE:
case TYPE_SEQUENCE_OF:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
ASN1_TAG_SEQUENCE, tag_der, &tag_len);
break;
case TYPE_SET:
case TYPE_SET_OF:
_asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
ASN1_TAG_SET, tag_der, &tag_len);
break;
case TYPE_TAG:
@@ -596,7 +596,7 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
}
/******************************************************/
/* Function : _asn1_ordering_set */
/* Function : MHD__asn1_ordering_set */
/* Description: puts the elements of a SET type in */
/* the correct order according to DER rules. */
/* Parameters: */
@@ -605,7 +605,7 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
/* Return: */
/******************************************************/
void
_asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
MHD__asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
{
struct vet
{
@@ -637,7 +637,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
first = last = NULL;
while (p)
{
p_vet = (struct vet *) _asn1_alloca (sizeof (struct vet));
p_vet = (struct vet *) MHD__asn1_alloca (sizeof (struct vet));
if (p_vet == NULL)
return;
@@ -650,7 +650,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
last = p_vet;
/* tag value calculation */
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, der_len - counter, &class, &len2,
&tag) != ASN1_SUCCESS)
return;
@@ -658,7 +658,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
counter += len2;
/* extraction and length */
len2 = asn1_get_length_der (der + counter, der_len - counter, &len);
len2 = MHD__asn1_get_length_der (der + counter, der_len - counter, &len);
if (len2 < 0)
return;
counter += len + len2;
@@ -678,7 +678,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
if (p_vet->value > p2_vet->value)
{
/* change position */
temp = (unsigned char *) _asn1_alloca (p_vet->end - counter);
temp = (unsigned char *) MHD__asn1_alloca (p_vet->end - counter);
if (temp == NULL)
return;
@@ -687,7 +687,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
p2_vet->end - p_vet->end);
memcpy (der + counter + p2_vet->end - p_vet->end, temp,
p_vet->end - counter);
_asn1_afree (temp);
MHD__asn1_afree (temp);
tag = p_vet->value;
p_vet->value = p2_vet->value;
@@ -705,13 +705,13 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
p_vet->prev->next = NULL;
else
first = NULL;
_asn1_afree (p_vet);
MHD__asn1_afree (p_vet);
p_vet = first;
}
}
/******************************************************/
/* Function : _asn1_ordering_set_of */
/* Function : MHD__asn1_ordering_set_of */
/* Description: puts the elements of a SET OF type in */
/* the correct order according to DER rules. */
/* Parameters: */
@@ -720,7 +720,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
/* Return: */
/******************************************************/
void
_asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
MHD__asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
{
struct vet
{
@@ -751,7 +751,7 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
first = last = NULL;
while (p)
{
p_vet = (struct vet *) _asn1_alloca (sizeof (struct vet));
p_vet = (struct vet *) MHD__asn1_alloca (sizeof (struct vet));
if (p_vet == NULL)
return;
@@ -767,13 +767,13 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
if (der_len - counter > 0)
{
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, der_len - counter, &class, &len,
NULL) != ASN1_SUCCESS)
return;
counter += len;
len2 = asn1_get_length_der (der + counter, der_len - counter, &len);
len2 = MHD__asn1_get_length_der (der + counter, der_len - counter, &len);
if (len2 < 0)
return;
counter += len + len2;
@@ -816,7 +816,7 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
if (change == 1)
{
/* change position */
temp = (unsigned char *) _asn1_alloca (p_vet->end - counter);
temp = (unsigned char *) MHD__asn1_alloca (p_vet->end - counter);
if (temp == NULL)
return;
@@ -825,7 +825,7 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
(p2_vet->end) - (p_vet->end));
memcpy (der + counter + (p2_vet->end) - (p_vet->end), temp,
(p_vet->end) - counter);
_asn1_afree (temp);
MHD__asn1_afree (temp);
p_vet->end = counter + (p2_vet->end - p_vet->end);
}
@@ -839,13 +839,13 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
p_vet->prev->next = NULL;
else
first = NULL;
_asn1_afree (p_vet);
MHD__asn1_afree (p_vet);
p_vet = first;
}
}
/**
* asn1_der_coding - Creates the DER encoding for the NAME structure
* MHD__asn1_der_coding - Creates the DER encoding for the NAME structure
* @element: pointer to an ASN1 element
* @name: the name of the structure you want to encode (it must be
* inside *POINTER).
@@ -871,17 +871,17 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
* LEN will contain the length needed.
*
**/
asn1_retCode
asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
MHD__asn1_retCode
MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
char *ErrorDescription)
{
node_asn *node, *p, *p2;
char temp[SIZEOF_UNSIGNED_LONG_INT * 3 + 1];
int counter, counter_old, len2, len3, tlen, move, max_len, max_len_old;
asn1_retCode err;
MHD__asn1_retCode err;
unsigned char *der = ider;
node = asn1_find_node (element, name);
node = MHD__asn1_find_node (element, name);
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
@@ -889,7 +889,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
* That is because in some point we modify the
* structure, and I don't know why! --nmav
*/
node = _asn1_copy_structure3 (node);
node = MHD__asn1_copy_structure3 (node);
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
@@ -905,7 +905,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
max_len_old = max_len;
if (move != UP)
{
err = _asn1_insert_tag_der (p, der, &counter, &max_len);
err = MHD__asn1_insert_tag_der (p, der, &counter, &max_len);
if (err != ASN1_SUCCESS && err != ASN1_MEM_ERROR)
goto error;
}
@@ -928,7 +928,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
{
if (p->value == NULL)
{
_asn1_error_description_value_not_found (p,
MHD__asn1_error_description_value_not_found (p,
ErrorDescription);
err = ASN1_VALUE_NOT_FOUND;
goto error;
@@ -958,12 +958,12 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
{
if (p->value == NULL)
{
_asn1_error_description_value_not_found (p,
MHD__asn1_error_description_value_not_found (p,
ErrorDescription);
err = ASN1_VALUE_NOT_FOUND;
goto error;
}
len2 = asn1_get_length_der (p->value, p->value_len, &len3);
len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
if (len2 < 0)
{
err = ASN1_DER_ERROR;
@@ -986,13 +986,13 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
{
if (p->value == NULL)
{
_asn1_error_description_value_not_found (p,
MHD__asn1_error_description_value_not_found (p,
ErrorDescription);
err = ASN1_VALUE_NOT_FOUND;
goto error;
}
len2 = max_len;
err = _asn1_objectid_der (p->value, der + counter, &len2);
err = MHD__asn1_objectid_der (p->value, der + counter, &len2);
if (err != ASN1_SUCCESS && err != ASN1_MEM_ERROR)
goto error;
@@ -1004,12 +1004,12 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
case TYPE_TIME:
if (p->value == NULL)
{
_asn1_error_description_value_not_found (p, ErrorDescription);
MHD__asn1_error_description_value_not_found (p, ErrorDescription);
err = ASN1_VALUE_NOT_FOUND;
goto error;
}
len2 = max_len;
err = _asn1_time_der (p->value, der + counter, &len2);
err = MHD__asn1_time_der (p->value, der + counter, &len2);
if (err != ASN1_SUCCESS && err != ASN1_MEM_ERROR)
goto error;
@@ -1020,11 +1020,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
case TYPE_OCTET_STRING:
if (p->value == NULL)
{
_asn1_error_description_value_not_found (p, ErrorDescription);
MHD__asn1_error_description_value_not_found (p, ErrorDescription);
err = ASN1_VALUE_NOT_FOUND;
goto error;
}
len2 = asn1_get_length_der (p->value, p->value_len, &len3);
len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
if (len2 < 0)
{
err = ASN1_DER_ERROR;
@@ -1039,11 +1039,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
case TYPE_GENERALSTRING:
if (p->value == NULL)
{
_asn1_error_description_value_not_found (p, ErrorDescription);
MHD__asn1_error_description_value_not_found (p, ErrorDescription);
err = ASN1_VALUE_NOT_FOUND;
goto error;
}
len2 = asn1_get_length_der (p->value, p->value_len, &len3);
len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
if (len2 < 0)
{
err = ASN1_DER_ERROR;
@@ -1058,11 +1058,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
case TYPE_BIT_STRING:
if (p->value == NULL)
{
_asn1_error_description_value_not_found (p, ErrorDescription);
MHD__asn1_error_description_value_not_found (p, ErrorDescription);
err = ASN1_VALUE_NOT_FOUND;
goto error;
}
len2 = asn1_get_length_der (p->value, p->value_len, &len3);
len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
if (len2 < 0)
{
err = ASN1_DER_ERROR;
@@ -1078,10 +1078,10 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
case TYPE_SET:
if (move != UP)
{
_asn1_ltostr (counter, temp);
MHD__asn1_ltostr (counter, temp);
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
if (p->down == NULL)
{
move = UP;
@@ -1105,10 +1105,10 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
else
{ /* move==UP */
len2 = strtol (p->value, NULL, 10);
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
if ((type_field (p->type) == TYPE_SET) && (max_len >= 0))
_asn1_ordering_set (der + len2, max_len - len2, p);
asn1_length_der (counter - len2, temp, &len3);
MHD__asn1_ordering_set (der + len2, max_len - len2, p);
MHD__asn1_length_der (counter - len2, temp, &len3);
max_len -= len3;
if (max_len >= 0)
{
@@ -1123,11 +1123,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
case TYPE_SET_OF:
if (move != UP)
{
_asn1_ltostr (counter, temp);
MHD__asn1_ltostr (counter, temp);
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
p = p->down;
while ((type_field (p->type) == TYPE_TAG)
|| (type_field (p->type) == TYPE_SIZE))
@@ -1139,19 +1139,19 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
continue;
}
else
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
move = UP;
}
if (move == UP)
{
len2 = strtol (p->value, NULL, 10);
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
if ((type_field (p->type) == TYPE_SET_OF)
&& (max_len - len2 > 0))
{
_asn1_ordering_set_of (der + len2, max_len - len2, p);
MHD__asn1_ordering_set_of (der + len2, max_len - len2, p);
}
asn1_length_der (counter - len2, temp, &len3);
MHD__asn1_length_der (counter - len2, temp, &len3);
max_len -= len3;
if (max_len >= 0)
{
@@ -1165,11 +1165,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
case TYPE_ANY:
if (p->value == NULL)
{
_asn1_error_description_value_not_found (p, ErrorDescription);
MHD__asn1_error_description_value_not_found (p, ErrorDescription);
err = ASN1_VALUE_NOT_FOUND;
goto error;
}
len2 = asn1_get_length_der (p->value, p->value_len, &len3);
len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
if (len2 < 0)
{
err = ASN1_DER_ERROR;
@@ -1188,7 +1188,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
if ((move != DOWN) && (counter != counter_old))
{
err = _asn1_complete_explicit_tag (p, der, &counter, &max_len);
err = MHD__asn1_complete_explicit_tag (p, der, &counter, &max_len);
if (err != ASN1_SUCCESS && err != ASN1_MEM_ERROR)
goto error;
}
@@ -1211,7 +1211,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
move = UP;
}
if (move == UP)
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
*len = counter;
@@ -1225,6 +1225,6 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
err = ASN1_SUCCESS;
error:
asn1_delete_structure (&node);
MHD__asn1_delete_structure (&node);
return err;
}
src/daemon/https/minitasn1/decoding.c
+268 -268
View File
@@ -35,18 +35,18 @@
void
_asn1_error_description_tag_error (node_asn * node, char *ErrorDescription)
MHD__asn1_error_description_tag_error (node_asn * node, char *ErrorDescription)
{
Estrcpy (ErrorDescription, ":: tag error near element '");
_asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
MHD__asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
MAX_ERROR_DESCRIPTION_SIZE - 40);
Estrcat (ErrorDescription, "'");
}
/**
* asn1_get_length_der:
* MHD__asn1_get_length_der:
* @der: DER data to decode.
* @der_len: Length of DER data to decode.
* @len: Output variable containing the length of the DER length field.
@@ -57,7 +57,7 @@ _asn1_error_description_tag_error (node_asn * node, char *ErrorDescription)
* length, or -2 when the value was too big.
**/
signed long
asn1_get_length_der (const unsigned char *der, int der_len, int *len)
MHD__asn1_get_length_der (const unsigned char *der, int der_len, int *len)
{
unsigned long ans;
int k, punt;
@@ -104,7 +104,7 @@ asn1_get_length_der (const unsigned char *der, int der_len, int *len)
/**
* asn1_get_tag_der:
* MHD__asn1_get_tag_der:
* @der: DER data to decode.
* @der_len: Length of DER data to decode.
* @cls: Output variable containing decoded class.
@@ -116,7 +116,7 @@ asn1_get_length_der (const unsigned char *der, int der_len, int *len)
* Return value: Returns ASN1_SUCCESS on success, or an error.
**/
int
asn1_get_tag_der (const unsigned char *der, int der_len,
MHD__asn1_get_tag_der (const unsigned char *der, int der_len,
unsigned char *cls, int *len, unsigned long *tag)
{
int punt, ris;
@@ -164,7 +164,7 @@ asn1_get_tag_der (const unsigned char *der, int der_len,
/**
* asn1_get_octet_der:
* MHD__asn1_get_octet_der:
* @der: DER data to decode containing the OCTET SEQUENCE.
* @der_len: Length of DER data to decode.
* @ret_len: Output variable containing the length of the DER data.
@@ -177,7 +177,7 @@ asn1_get_tag_der (const unsigned char *der, int der_len,
* Return value: Returns ASN1_SUCCESS on success, or an error.
**/
int
asn1_get_octet_der (const unsigned char *der, int der_len,
MHD__asn1_get_octet_der (const unsigned char *der, int der_len,
int *ret_len, unsigned char *str, int str_size,
int *str_len)
{
@@ -187,7 +187,7 @@ asn1_get_octet_der (const unsigned char *der, int der_len,
return ASN1_GENERIC_ERROR;
/* if(str==NULL) return ASN1_SUCCESS; */
*str_len = asn1_get_length_der (der, der_len, &len_len);
*str_len = MHD__asn1_get_length_der (der, der_len, &len_len);
if (*str_len < 0)
return ASN1_DER_ERROR;
@@ -208,14 +208,14 @@ asn1_get_octet_der (const unsigned char *der, int der_len,
/* Returns ASN1_SUCCESS on success or an error code on error.
*/
int
_asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
MHD__asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
char *str, int str_size)
{
int len_len, str_len;
if (der_len <= 0 || str == NULL)
return ASN1_DER_ERROR;
str_len = asn1_get_length_der (der, der_len, &len_len);
str_len = MHD__asn1_get_length_der (der, der_len, &len_len);
if (str_len < 0 || str_size < str_len)
return ASN1_DER_ERROR;
memcpy (str, der + len_len, str_len);
@@ -228,7 +228,7 @@ _asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
void
_asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
MHD__asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
char *str, int str_size)
{
int len_len, len, k;
@@ -241,7 +241,7 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
if (str == NULL || der_len <= 0)
return;
len = asn1_get_length_der (der, der_len, &len_len);
len = MHD__asn1_get_length_der (der, der_len, &len_len);
if (len < 0 || len > der_len || len_len > der_len)
return;
@@ -249,9 +249,9 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
val1 = der[len_len] / 40;
val = der[len_len] - val1 * 40;
_asn1_str_cpy (str, str_size, _asn1_ltostr (val1, temp));
_asn1_str_cat (str, str_size, ".");
_asn1_str_cat (str, str_size, _asn1_ltostr (val, temp));
MHD__asn1_str_cpy (str, str_size, MHD__asn1_ltostr (val1, temp));
MHD__asn1_str_cat (str, str_size, ".");
MHD__asn1_str_cat (str, str_size, MHD__asn1_ltostr (val, temp));
val = 0;
for (k = 1; k < len; k++)
@@ -260,8 +260,8 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
val |= der[len_len + k] & 0x7F;
if (!(der[len_len + k] & 0x80))
{
_asn1_str_cat (str, str_size, ".");
_asn1_str_cat (str, str_size, _asn1_ltostr (val, temp));
MHD__asn1_str_cat (str, str_size, ".");
MHD__asn1_str_cat (str, str_size, MHD__asn1_ltostr (val, temp));
val = 0;
}
}
@@ -272,7 +272,7 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
/**
* asn1_get_bit_der:
* MHD__asn1_get_bit_der:
* @der: DER data to decode containing the BIT SEQUENCE.
* @der_len: Length of DER data to decode.
* @ret_len: Output variable containing the length of the DER data.
@@ -285,7 +285,7 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
* Return value: Return ASN1_SUCCESS on success, or an error.
**/
int
asn1_get_bit_der (const unsigned char *der, int der_len,
MHD__asn1_get_bit_der (const unsigned char *der, int der_len,
int *ret_len, unsigned char *str, int str_size,
int *bit_len)
{
@@ -293,7 +293,7 @@ asn1_get_bit_der (const unsigned char *der, int der_len,
if (der_len <= 0)
return ASN1_GENERIC_ERROR;
len_byte = asn1_get_length_der (der, der_len, &len_len) - 1;
len_byte = MHD__asn1_get_length_der (der, der_len, &len_len) - 1;
if (len_byte < 0)
return ASN1_DER_ERROR;
@@ -314,7 +314,7 @@ asn1_get_bit_der (const unsigned char *der, int der_len,
int
_asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
MHD__asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
int *ret_len)
{
node_asn *p;
@@ -345,7 +345,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
if (p->type & CONST_EXPLICIT)
{
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, der_len - counter, &class, &len2,
&tag) != ASN1_SUCCESS)
return ASN1_DER_ERROR;
@@ -353,7 +353,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
return ASN1_DER_ERROR;
counter += len2;
len3 =
asn1_get_length_der (der + counter, der_len - counter,
MHD__asn1_get_length_der (der + counter, der_len - counter,
&len2);
if (len3 < 0)
return ASN1_DER_ERROR;
@@ -393,7 +393,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
if (is_tag_implicit)
{
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, der_len - counter, &class, &len2,
&tag) != ASN1_SUCCESS)
return ASN1_DER_ERROR;
@@ -421,7 +421,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
return ASN1_SUCCESS;
}
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, der_len - counter, &class, &len2,
&tag) != ASN1_SUCCESS)
return ASN1_DER_ERROR;
@@ -507,7 +507,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
int
_asn1_delete_not_used (node_asn * node)
MHD__asn1_delete_not_used (node_asn * node)
{
node_asn *p, *p2;
@@ -522,11 +522,11 @@ _asn1_delete_not_used (node_asn * node)
p2 = NULL;
if (p != node)
{
p2 = _asn1_find_left (p);
p2 = MHD__asn1_find_left (p);
if (!p2)
p2 = _asn1_find_up (p);
p2 = MHD__asn1_find_up (p);
}
asn1_delete_structure (&p);
MHD__asn1_delete_structure (&p);
p = p2;
}
@@ -547,7 +547,7 @@ _asn1_delete_not_used (node_asn * node)
{
while (1)
{
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
if (p == node)
{
p = NULL;
@@ -566,8 +566,8 @@ _asn1_delete_not_used (node_asn * node)
}
asn1_retCode
_asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
MHD__asn1_retCode
MHD__asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
{
int len2, len3, counter, counter2, counter_end, tot_len, indefinite;
unsigned char *temp, *temp2;
@@ -577,7 +577,7 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
if (*(der - 1) & ASN1_CLASS_STRUCTURED)
{
tot_len = 0;
indefinite = asn1_get_length_der (der, *len, &len3);
indefinite = MHD__asn1_get_length_der (der, *len, &len3);
if (indefinite < -1)
return ASN1_DER_ERROR;
@@ -606,7 +606,7 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
counter++;
len2 = asn1_get_length_der (der + counter, *len - counter, &len3);
len2 = MHD__asn1_get_length_der (der + counter, *len - counter, &len3);
if (len2 <= 0)
return ASN1_DER_ERROR;
@@ -617,20 +617,20 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
/* copy */
if (node)
{
asn1_length_der (tot_len, NULL, &len2);
temp = _asn1_alloca (len2 + tot_len);
MHD__asn1_length_der (tot_len, NULL, &len2);
temp = MHD__asn1_alloca (len2 + tot_len);
if (temp == NULL)
{
return ASN1_MEM_ALLOC_ERROR;
}
asn1_length_der (tot_len, temp, &len2);
MHD__asn1_length_der (tot_len, temp, &len2);
tot_len += len2;
temp2 = temp + len2;
len2 = asn1_get_length_der (der, *len, &len3);
len2 = MHD__asn1_get_length_der (der, *len, &len3);
if (len2 < -1)
{
_asn1_afree (temp);
MHD__asn1_afree (temp);
return ASN1_DER_ERROR;
}
counter2 = len3 + 1;
@@ -643,10 +643,10 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
while (counter2 < counter_end)
{
len2 =
asn1_get_length_der (der + counter2, *len - counter, &len3);
MHD__asn1_get_length_der (der + counter2, *len - counter, &len3);
if (len2 < -1)
{
_asn1_afree (temp);
MHD__asn1_afree (temp);
return ASN1_DER_ERROR;
}
@@ -658,19 +658,19 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
counter2 += len2 + len3 + 1;
}
_asn1_set_value (node, temp, tot_len);
_asn1_afree (temp);
MHD__asn1_set_value (node, temp, tot_len);
MHD__asn1_afree (temp);
}
}
else
{ /* NOT STRUCTURED */
len2 = asn1_get_length_der (der, *len, &len3);
len2 = MHD__asn1_get_length_der (der, *len, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
if (len3 + len2 > *len)
return ASN1_DER_ERROR;
if (node)
_asn1_set_value (node, der, len3 + len2);
MHD__asn1_set_value (node, der, len3 + len2);
counter = len3 + len2;
}
@@ -680,8 +680,8 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
}
asn1_retCode
_asn1_get_indefinite_length_string (const unsigned char *der, int *len)
MHD__asn1_retCode
MHD__asn1_get_indefinite_length_string (const unsigned char *der, int *len)
{
int len2, len3, counter, indefinite;
unsigned long tag;
@@ -704,14 +704,14 @@ _asn1_get_indefinite_length_string (const unsigned char *der, int *len)
continue;
}
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, *len - counter, &class, &len2,
&tag) != ASN1_SUCCESS)
return ASN1_DER_ERROR;
if (counter + len2 > *len)
return ASN1_DER_ERROR;
counter += len2;
len2 = asn1_get_length_der (der + counter, *len - counter, &len3);
len2 = MHD__asn1_get_length_der (der + counter, *len - counter, &len3);
if (len2 < -1)
return ASN1_DER_ERROR;
if (len2 == -1)
@@ -732,7 +732,7 @@ _asn1_get_indefinite_length_string (const unsigned char *der, int *len)
/**
* asn1_der_decoding - Fill the structure *ELEMENT with values of a DER encoding string.
* MHD__asn1_der_decoding - Fill the structure *ELEMENT with values of a DER encoding string.
* @element: pointer to an ASN1 structure.
* @ider: vector that contains the DER encoding.
* @len: number of bytes of *@ider: @ider[0]..@ider[len-1].
@@ -755,8 +755,8 @@ _asn1_get_indefinite_length_string (const unsigned char *der, int *len)
* the structure NAME. *ELEMENT deleted.
**/
asn1_retCode
asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
MHD__asn1_retCode
MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
char *errorDescription)
{
node_asn *node, *p, *p2, *p3;
@@ -774,7 +774,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
if (node->type & CONST_OPTION)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_GENERIC_ERROR;
}
@@ -788,7 +788,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
{
if (p->type & CONST_SET)
{
p2 = _asn1_find_up (p);
p2 = MHD__asn1_find_up (p);
len2 = strtol (p2->value, NULL, 10);
if (len2 == -1)
{
@@ -808,7 +808,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
}
else if (counter > len2)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
p2 = p2->down;
@@ -818,7 +818,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
{
if (type_field (p2->type) != TYPE_CHOICE)
ris =
_asn1_extract_tag_der (p2, der + counter,
MHD__asn1_extract_tag_der (p2, der + counter,
len - counter, &len2);
else
{
@@ -826,7 +826,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
while (p3)
{
ris =
_asn1_extract_tag_der (p3, der + counter,
MHD__asn1_extract_tag_der (p3, der + counter,
len - counter, &len2);
if (ris == ASN1_SUCCESS)
break;
@@ -844,14 +844,14 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
}
if (p2 == NULL)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
}
if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
{
p2 = _asn1_find_up (p);
p2 = MHD__asn1_find_up (p);
len2 = strtol (p2->value, NULL, 10);
if (counter == len2)
{
@@ -864,7 +864,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
move = UP;
if (p->type & CONST_OPTION)
asn1_delete_structure (&p);
MHD__asn1_delete_structure (&p);
p = p2;
continue;
@@ -877,7 +877,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
{
if (counter < len)
ris =
_asn1_extract_tag_der (p->down, der + counter,
MHD__asn1_extract_tag_der (p->down, der + counter,
len - counter, &len2);
else
ris = ASN1_DER_ERROR;
@@ -886,19 +886,19 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
while (p->down->right)
{
p2 = p->down->right;
asn1_delete_structure (&p2);
MHD__asn1_delete_structure (&p2);
}
break;
}
else if (ris == ASN1_ERROR_TYPE_ANY)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_ERROR_TYPE_ANY;
}
else
{
p2 = p->down;
asn1_delete_structure (&p2);
MHD__asn1_delete_structure (&p2);
}
}
@@ -906,7 +906,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
{
if (!(p->type & CONST_OPTION))
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
}
@@ -916,7 +916,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
{
p2 = _asn1_find_up (p);
p2 = MHD__asn1_find_up (p);
len2 = strtol (p2->value, NULL, 10);
if ((len2 != -1) && (counter > len2))
ris = ASN1_TAG_ERROR;
@@ -924,7 +924,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
if (ris == ASN1_SUCCESS)
ris =
_asn1_extract_tag_der (p, der + counter, len - counter, &len2);
MHD__asn1_extract_tag_der (p, der + counter, len - counter, &len2);
if (ris != ASN1_SUCCESS)
{
if (p->type & CONST_OPTION)
@@ -934,15 +934,15 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
}
else if (p->type & CONST_DEFAULT)
{
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
move = RIGHT;
}
else
{
if (errorDescription != NULL)
_asn1_error_description_tag_error (p, errorDescription);
MHD__asn1_error_description_tag_error (p, errorDescription);
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_TAG_ERROR;
}
}
@@ -957,7 +957,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
case TYPE_NULL:
if (der[counter])
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
counter++;
@@ -966,54 +966,54 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
case TYPE_BOOLEAN:
if (der[counter++] != 1)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
if (der[counter++] == 0)
_asn1_set_value (p, "F", 1);
MHD__asn1_set_value (p, "F", 1);
else
_asn1_set_value (p, "T", 1);
MHD__asn1_set_value (p, "T", 1);
move = RIGHT;
break;
case TYPE_INTEGER:
case TYPE_ENUMERATED:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
if (len2 + len3 > len - counter)
return ASN1_DER_ERROR;
_asn1_set_value (p, der + counter, len3 + len2);
MHD__asn1_set_value (p, der + counter, len3 + len2);
counter += len3 + len2;
move = RIGHT;
break;
case TYPE_OBJECT_ID:
_asn1_get_objectid_der (der + counter, len - counter, &len2,
MHD__asn1_get_objectid_der (der + counter, len - counter, &len2,
temp, sizeof (temp));
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
counter += len2;
move = RIGHT;
break;
case TYPE_TIME:
result =
_asn1_get_time_der (der + counter, len - counter, &len2, temp,
MHD__asn1_get_time_der (der + counter, len - counter, &len2, temp,
sizeof (temp) - 1);
if (result != ASN1_SUCCESS)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return result;
}
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
counter += len2;
move = RIGHT;
break;
case TYPE_OCTET_STRING:
len3 = len - counter;
ris = _asn1_get_octet_string (der + counter, p, &len3);
ris = MHD__asn1_get_octet_string (der + counter, p, &len3);
if (ris != ASN1_SUCCESS)
return ris;
counter += len3;
@@ -1021,23 +1021,23 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
break;
case TYPE_GENERALSTRING:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
if (len3 + len2 > len - counter)
return ASN1_DER_ERROR;
_asn1_set_value (p, der + counter, len3 + len2);
MHD__asn1_set_value (p, der + counter, len3 + len2);
counter += len3 + len2;
move = RIGHT;
break;
case TYPE_BIT_STRING:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
if (len3 + len2 > len - counter)
return ASN1_DER_ERROR;
_asn1_set_value (p, der + counter, len3 + len2);
MHD__asn1_set_value (p, der + counter, len3 + len2);
counter += len3 + len2;
move = RIGHT;
break;
@@ -1046,14 +1046,14 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
if (move == UP)
{
len2 = strtol (p->value, NULL, 10);
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
if (len2 == -1)
{ /* indefinite length method */
if (len - counter + 1 > 0)
{
if ((der[counter]) || der[counter + 1])
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
}
@@ -1065,7 +1065,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
{ /* definite length method */
if (len2 != counter)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
}
@@ -1074,16 +1074,16 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
else
{ /* move==DOWN || move==RIGHT */
len3 =
asn1_get_length_der (der + counter, len - counter, &len2);
MHD__asn1_get_length_der (der + counter, len - counter, &len2);
if (len3 < -1)
return ASN1_DER_ERROR;
counter += len2;
if (len3 > 0)
{
_asn1_ltostr (counter + len3, temp);
MHD__asn1_ltostr (counter + len3, temp);
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
move = DOWN;
}
else if (len3 == 0)
@@ -1094,7 +1094,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
if (type_field (p2->type) != TYPE_TAG)
{
p3 = p2->right;
asn1_delete_structure (&p2);
MHD__asn1_delete_structure (&p2);
p2 = p3;
}
else
@@ -1104,7 +1104,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
}
else
{ /* indefinite length method */
_asn1_set_value (p, "-1", 3);
MHD__asn1_set_value (p, "-1", 3);
move = DOWN;
}
}
@@ -1120,31 +1120,31 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
return ASN1_DER_ERROR;
if ((der[counter]) || der[counter + 1])
{
_asn1_append_sequence_set (p);
MHD__asn1_append_sequence_set (p);
p = p->down;
while (p->right)
p = p->right;
move = RIGHT;
continue;
}
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
counter += 2;
}
else
{ /* definite length method */
if (len2 > counter)
{
_asn1_append_sequence_set (p);
MHD__asn1_append_sequence_set (p);
p = p->down;
while (p->right)
p = p->right;
move = RIGHT;
continue;
}
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
if (len2 != counter)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
}
@@ -1152,7 +1152,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
else
{ /* move==DOWN || move==RIGHT */
len3 =
asn1_get_length_der (der + counter, len - counter, &len2);
MHD__asn1_get_length_der (der + counter, len - counter, &len2);
if (len3 < -1)
return ASN1_DER_ERROR;
counter += len2;
@@ -1160,36 +1160,36 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
{
if (len3 > 0)
{ /* definite length method */
_asn1_ltostr (counter + len3, temp);
MHD__asn1_ltostr (counter + len3, temp);
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
}
else
{ /* indefinite length method */
_asn1_set_value (p, "-1", 3);
MHD__asn1_set_value (p, "-1", 3);
}
p2 = p->down;
while ((type_field (p2->type) == TYPE_TAG)
|| (type_field (p2->type) == TYPE_SIZE))
p2 = p2->right;
if (p2->right == NULL)
_asn1_append_sequence_set (p);
MHD__asn1_append_sequence_set (p);
p = p2;
}
}
move = RIGHT;
break;
case TYPE_ANY:
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, len - counter, &class, &len2,
&tag) != ASN1_SUCCESS)
return ASN1_DER_ERROR;
if (counter + len2 > len)
return ASN1_DER_ERROR;
len4 =
asn1_get_length_der (der + counter + len2,
MHD__asn1_get_length_der (der + counter + len2,
len - counter - len2, &len3);
if (len4 < -1)
return ASN1_DER_ERROR;
@@ -1198,17 +1198,17 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
if (len4 != -1)
{
len2 += len4;
asn1_length_der (len2 + len3, NULL, &len4);
temp2 = (unsigned char *) _asn1_alloca (len2 + len3 + len4);
MHD__asn1_length_der (len2 + len3, NULL, &len4);
temp2 = (unsigned char *) MHD__asn1_alloca (len2 + len3 + len4);
if (temp2 == NULL)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_MEM_ALLOC_ERROR;
}
asn1_octet_der (der + counter, len2 + len3, temp2, &len4);
_asn1_set_value (p, temp2, len4);
_asn1_afree (temp2);
MHD__asn1_octet_der (der + counter, len2 + len3, temp2, &len4);
MHD__asn1_set_value (p, temp2, len4);
MHD__asn1_afree (temp2);
counter += len2 + len3;
}
else
@@ -1221,23 +1221,23 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
len2 = len - counter;
ris =
_asn1_get_indefinite_length_string (der + counter, &len2);
MHD__asn1_get_indefinite_length_string (der + counter, &len2);
if (ris != ASN1_SUCCESS)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ris;
}
asn1_length_der (len2, NULL, &len4);
temp2 = (unsigned char *) _asn1_alloca (len2 + len4);
MHD__asn1_length_der (len2, NULL, &len4);
temp2 = (unsigned char *) MHD__asn1_alloca (len2 + len4);
if (temp2 == NULL)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_MEM_ALLOC_ERROR;
}
asn1_octet_der (der + counter, len2, temp2, &len4);
_asn1_set_value (p, temp2, len4);
_asn1_afree (temp2);
MHD__asn1_octet_der (der + counter, len2, temp2, &len4);
MHD__asn1_set_value (p, temp2, len4);
MHD__asn1_afree (temp2);
counter += len2;
/* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
@@ -1250,7 +1250,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
}
else
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
}
@@ -1281,14 +1281,14 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
move = UP;
}
if (move == UP)
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
_asn1_delete_not_used (*element);
MHD__asn1_delete_not_used (*element);
if (counter != len)
{
asn1_delete_structure (element);
MHD__asn1_delete_structure (element);
return ASN1_DER_ERROR;
}
@@ -1302,7 +1302,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
#define EXIT 4
/**
* asn1_der_decoding_element - Fill the element named ELEMENTNAME of the structure STRUCTURE with values of a DER encoding string.
* MHD__asn1_der_decoding_element - Fill the element named ELEMENTNAME of the structure STRUCTURE with values of a DER encoding string.
* @structure: pointer to an ASN1 structure
* @elementName: name of the element to fill
* @ider: vector that contains the DER encoding of the whole structure.
@@ -1328,8 +1328,8 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
* the structure STRUCTURE. *ELEMENT deleted.
*
**/
asn1_retCode
asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
MHD__asn1_retCode
MHD__asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
const void *ider, int len, char *errorDescription)
{
node_asn *node, *p, *p2, *p3, *nodeFound = ASN1_TYPE_EMPTY;
@@ -1348,13 +1348,13 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if (elementName == NULL)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_ELEMENT_NOT_FOUND;
}
if (node->type & CONST_OPTION)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_GENERIC_ERROR;
}
@@ -1365,7 +1365,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
strcpy (currentName, (*structure)->name);
else
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_MEM_ERROR;
}
if (!(strcmp (currentName, elementName)))
@@ -1404,7 +1404,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
{
if (p->type & CONST_SET)
{
p2 = _asn1_find_up (p);
p2 = MHD__asn1_find_up (p);
len2 = strtol (p2->value, NULL, 10);
if (counter == len2)
{
@@ -1414,7 +1414,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
}
else if (counter > len2)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
p2 = p2->down;
@@ -1424,7 +1424,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
{
if (type_field (p2->type) != TYPE_CHOICE)
ris =
_asn1_extract_tag_der (p2, der + counter,
MHD__asn1_extract_tag_der (p2, der + counter,
len - counter, &len2);
else
{
@@ -1432,7 +1432,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
while (p3)
{
ris =
_asn1_extract_tag_der (p3, der + counter,
MHD__asn1_extract_tag_der (p3, der + counter,
len - counter, &len2);
if (ris == ASN1_SUCCESS)
break;
@@ -1450,14 +1450,14 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
}
if (p2 == NULL)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
}
if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
{
p2 = _asn1_find_up (p);
p2 = MHD__asn1_find_up (p);
len2 = strtol (p2->value, NULL, 10);
if (counter == len2)
{
@@ -1470,7 +1470,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
move = UP;
if (p->type & CONST_OPTION)
asn1_delete_structure (&p);
MHD__asn1_delete_structure (&p);
p = p2;
continue;
@@ -1483,7 +1483,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
{
if (counter < len)
ris =
_asn1_extract_tag_der (p->down, der + counter,
MHD__asn1_extract_tag_der (p->down, der + counter,
len - counter, &len2);
else
ris = ASN1_DER_ERROR;
@@ -1492,19 +1492,19 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
while (p->down->right)
{
p2 = p->down->right;
asn1_delete_structure (&p2);
MHD__asn1_delete_structure (&p2);
}
break;
}
else if (ris == ASN1_ERROR_TYPE_ANY)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_ERROR_TYPE_ANY;
}
else
{
p2 = p->down;
asn1_delete_structure (&p2);
MHD__asn1_delete_structure (&p2);
}
}
@@ -1512,7 +1512,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
{
if (!(p->type & CONST_OPTION))
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
}
@@ -1522,7 +1522,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
{
p2 = _asn1_find_up (p);
p2 = MHD__asn1_find_up (p);
len2 = strtol (p2->value, NULL, 10);
if (counter > len2)
ris = ASN1_TAG_ERROR;
@@ -1530,7 +1530,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if (ris == ASN1_SUCCESS)
ris =
_asn1_extract_tag_der (p, der + counter, len - counter, &len2);
MHD__asn1_extract_tag_der (p, der + counter, len - counter, &len2);
if (ris != ASN1_SUCCESS)
{
if (p->type & CONST_OPTION)
@@ -1540,15 +1540,15 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
}
else if (p->type & CONST_DEFAULT)
{
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
move = RIGHT;
}
else
{
if (errorDescription != NULL)
_asn1_error_description_tag_error (p, errorDescription);
MHD__asn1_error_description_tag_error (p, errorDescription);
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_TAG_ERROR;
}
}
@@ -1563,7 +1563,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
case TYPE_NULL:
if (der[counter])
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
@@ -1576,16 +1576,16 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
case TYPE_BOOLEAN:
if (der[counter++] != 1)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
if (state == FOUND)
{
if (der[counter++] == 0)
_asn1_set_value (p, "F", 1);
MHD__asn1_set_value (p, "F", 1);
else
_asn1_set_value (p, "T", 1);
MHD__asn1_set_value (p, "T", 1);
if (p == nodeFound)
state = EXIT;
@@ -1599,14 +1599,14 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
case TYPE_INTEGER:
case TYPE_ENUMERATED:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
if (state == FOUND)
{
if (len3 + len2 > len - counter)
return ASN1_DER_ERROR;
_asn1_set_value (p, der + counter, len3 + len2);
MHD__asn1_set_value (p, der + counter, len3 + len2);
if (p == nodeFound)
state = EXIT;
@@ -1617,12 +1617,12 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
case TYPE_OBJECT_ID:
if (state == FOUND)
{
_asn1_get_objectid_der (der + counter, len - counter, &len2,
MHD__asn1_get_objectid_der (der + counter, len - counter, &len2,
temp, sizeof (temp));
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
if (p == nodeFound)
state = EXIT;
@@ -1630,7 +1630,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
else
{
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
len2 += len3;
@@ -1643,17 +1643,17 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if (state == FOUND)
{
result =
_asn1_get_time_der (der + counter, len - counter, &len2,
MHD__asn1_get_time_der (der + counter, len - counter, &len2,
temp, sizeof (temp) - 1);
if (result != ASN1_SUCCESS)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return result;
}
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
if (p == nodeFound)
state = EXIT;
@@ -1661,7 +1661,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
else
{
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
len2 += len3;
@@ -1674,12 +1674,12 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
len3 = len - counter;
if (state == FOUND)
{
ris = _asn1_get_octet_string (der + counter, p, &len3);
ris = MHD__asn1_get_octet_string (der + counter, p, &len3);
if (p == nodeFound)
state = EXIT;
}
else
ris = _asn1_get_octet_string (der + counter, NULL, &len3);
ris = MHD__asn1_get_octet_string (der + counter, NULL, &len3);
if (ris != ASN1_SUCCESS)
return ris;
@@ -1688,14 +1688,14 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
break;
case TYPE_GENERALSTRING:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
if (state == FOUND)
{
if (len3 + len2 > len - counter)
return ASN1_DER_ERROR;
_asn1_set_value (p, der + counter, len3 + len2);
MHD__asn1_set_value (p, der + counter, len3 + len2);
if (p == nodeFound)
state = EXIT;
@@ -1705,14 +1705,14 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
break;
case TYPE_BIT_STRING:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
if (state == FOUND)
{
if (len3 + len2 > len - counter)
return ASN1_DER_ERROR;
_asn1_set_value (p, der + counter, len3 + len2);
MHD__asn1_set_value (p, der + counter, len3 + len2);
if (p == nodeFound)
state = EXIT;
@@ -1725,12 +1725,12 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if (move == UP)
{
len2 = strtol (p->value, NULL, 10);
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
if (len2 == -1)
{ /* indefinite length method */
if ((der[counter]) || der[counter + 1])
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
counter += 2;
@@ -1739,7 +1739,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
{ /* definite length method */
if (len2 != counter)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
}
@@ -1752,7 +1752,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if (state == OTHER_BRANCH)
{
len3 =
asn1_get_length_der (der + counter, len - counter,
MHD__asn1_get_length_der (der + counter, len - counter,
&len2);
if (len3 < 0)
return ASN1_DER_ERROR;
@@ -1762,18 +1762,18 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
else
{ /* state==SAME_BRANCH or state==FOUND */
len3 =
asn1_get_length_der (der + counter, len - counter,
MHD__asn1_get_length_der (der + counter, len - counter,
&len2);
if (len3 < 0)
return ASN1_DER_ERROR;
counter += len2;
if (len3 > 0)
{
_asn1_ltostr (counter + len3, temp);
MHD__asn1_ltostr (counter + len3, temp);
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
move = DOWN;
}
else if (len3 == 0)
@@ -1784,7 +1784,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if (type_field (p2->type) != TYPE_TAG)
{
p3 = p2->right;
asn1_delete_structure (&p2);
MHD__asn1_delete_structure (&p2);
p2 = p3;
}
else
@@ -1794,7 +1794,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
}
else
{ /* indefinite length method */
_asn1_set_value (p, "-1", 3);
MHD__asn1_set_value (p, "-1", 3);
move = DOWN;
}
}
@@ -1807,17 +1807,17 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
len2 = strtol (p->value, NULL, 10);
if (len2 > counter)
{
_asn1_append_sequence_set (p);
MHD__asn1_append_sequence_set (p);
p = p->down;
while (p->right)
p = p->right;
move = RIGHT;
continue;
}
_asn1_set_value (p, NULL, 0);
MHD__asn1_set_value (p, NULL, 0);
if (len2 != counter)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
@@ -1829,7 +1829,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if (state == OTHER_BRANCH)
{
len3 =
asn1_get_length_der (der + counter, len - counter,
MHD__asn1_get_length_der (der + counter, len - counter,
&len2);
if (len3 < 0)
return ASN1_DER_ERROR;
@@ -1839,24 +1839,24 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
else
{ /* state==FOUND or state==SAME_BRANCH */
len3 =
asn1_get_length_der (der + counter, len - counter,
MHD__asn1_get_length_der (der + counter, len - counter,
&len2);
if (len3 < 0)
return ASN1_DER_ERROR;
counter += len2;
if (len3)
{
_asn1_ltostr (counter + len3, temp);
MHD__asn1_ltostr (counter + len3, temp);
tlen = strlen (temp);
if (tlen > 0)
_asn1_set_value (p, temp, tlen + 1);
MHD__asn1_set_value (p, temp, tlen + 1);
p2 = p->down;
while ((type_field (p2->type) == TYPE_TAG)
|| (type_field (p2->type) == TYPE_SIZE))
p2 = p2->right;
if (p2->right == NULL)
_asn1_append_sequence_set (p);
MHD__asn1_append_sequence_set (p);
p = p2;
state = FOUND;
}
@@ -1865,7 +1865,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
break;
case TYPE_ANY:
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, len - counter, &class, &len2,
&tag) != ASN1_SUCCESS)
return ASN1_DER_ERROR;
@@ -1873,7 +1873,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
return ASN1_DER_ERROR;
len4 =
asn1_get_length_der (der + counter + len2,
MHD__asn1_get_length_der (der + counter + len2,
len - counter - len2, &len3);
if (len4 < -1)
return ASN1_DER_ERROR;
@@ -1883,19 +1883,19 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
len2 += len4;
if (state == FOUND)
{
asn1_length_der (len2 + len3, NULL, &len4);
MHD__asn1_length_der (len2 + len3, NULL, &len4);
temp2 =
(unsigned char *) _asn1_alloca (len2 + len3 + len4);
(unsigned char *) MHD__asn1_alloca (len2 + len3 + len4);
if (temp2 == NULL)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_MEM_ALLOC_ERROR;
}
asn1_octet_der (der + counter, len2 + len3, temp2,
MHD__asn1_octet_der (der + counter, len2 + len3, temp2,
&len4);
_asn1_set_value (p, temp2, len4);
_asn1_afree (temp2);
MHD__asn1_set_value (p, temp2, len4);
MHD__asn1_afree (temp2);
if (p == nodeFound)
state = EXIT;
@@ -1912,26 +1912,26 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
len2 = len - counter;
ris =
_asn1_get_indefinite_length_string (der + counter, &len2);
MHD__asn1_get_indefinite_length_string (der + counter, &len2);
if (ris != ASN1_SUCCESS)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ris;
}
if (state == FOUND)
{
asn1_length_der (len2, NULL, &len4);
temp2 = (unsigned char *) _asn1_alloca (len2 + len4);
MHD__asn1_length_der (len2, NULL, &len4);
temp2 = (unsigned char *) MHD__asn1_alloca (len2 + len4);
if (temp2 == NULL)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_MEM_ALLOC_ERROR;
}
asn1_octet_der (der + counter, len2, temp2, &len4);
_asn1_set_value (p, temp2, len4);
_asn1_afree (temp2);
MHD__asn1_octet_der (der + counter, len2, temp2, &len4);
MHD__asn1_set_value (p, temp2, len4);
MHD__asn1_afree (temp2);
if (p == nodeFound)
state = EXIT;
@@ -1949,7 +1949,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
}
else
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
}
@@ -1983,7 +1983,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
}
else
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_MEM_ERROR;
}
if (!(strcmp (currentName, elementName)))
@@ -2026,7 +2026,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
strcat (currentName, p->name);
else
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_MEM_ERROR;
}
@@ -2049,7 +2049,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
if (move == UP)
{
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
if (state != FOUND)
{
@@ -2077,11 +2077,11 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
}
}
_asn1_delete_not_used (*structure);
MHD__asn1_delete_not_used (*structure);
if (counter > len)
{
asn1_delete_structure (structure);
MHD__asn1_delete_structure (structure);
return ASN1_DER_ERROR;
}
@@ -2091,7 +2091,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
/**
* asn1_der_decoding_startEnd - Find the start and end point of an element in a DER encoding string.
* MHD__asn1_der_decoding_startEnd - Find the start and end point of an element in a DER encoding string.
* @element: pointer to an ASN1 element
* @ider: vector that contains the DER encoding.
* @len: number of bytes of *@ider: @ider[0]..@ider[len-1]
@@ -2103,7 +2103,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
*
* Find the start and end point of an element in a DER encoding
* string. I mean that if you have a der encoding and you have
* already used the function "asn1_der_decoding" to fill a structure,
* already used the function "MHD__asn1_der_decoding" to fill a structure,
* it may happen that you want to find the piece of string concerning
* an element of the structure.
*
@@ -2120,8 +2120,8 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
* the structure ELEMENT.
*
**/
asn1_retCode
asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
MHD__asn1_retCode
MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
const char *name_element, int *start, int *end)
{
node_asn *node, *node_to_find, *p, *p2, *p3;
@@ -2136,7 +2136,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
if (node == ASN1_TYPE_EMPTY)
return ASN1_ELEMENT_NOT_FOUND;
node_to_find = asn1_find_node (node, name_element);
node_to_find = MHD__asn1_find_node (node, name_element);
if (node_to_find == NULL)
return ASN1_ELEMENT_NOT_FOUND;
@@ -2162,7 +2162,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
{
if (p->type & CONST_SET)
{
p2 = _asn1_find_up (p);
p2 = MHD__asn1_find_up (p);
len2 = strtol (p2->value, NULL, 10);
if (len2 == -1)
{
@@ -2189,13 +2189,13 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
{ /* CONTROLLARE */
if (type_field (p2->type) != TYPE_CHOICE)
ris =
_asn1_extract_tag_der (p2, der + counter,
MHD__asn1_extract_tag_der (p2, der + counter,
len - counter, &len2);
else
{
p3 = p2->down;
ris =
_asn1_extract_tag_der (p3, der + counter,
MHD__asn1_extract_tag_der (p3, der + counter,
len - counter, &len2);
}
if (ris == ASN1_SUCCESS)
@@ -2218,7 +2218,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
{
p = p->down;
ris =
_asn1_extract_tag_der (p, der + counter, len - counter,
MHD__asn1_extract_tag_der (p, der + counter, len - counter,
&len2);
if (p == node_to_find)
*start = counter;
@@ -2226,7 +2226,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
if (ris == ASN1_SUCCESS)
ris =
_asn1_extract_tag_der (p, der + counter, len - counter, &len2);
MHD__asn1_extract_tag_der (p, der + counter, len - counter, &len2);
if (ris != ASN1_SUCCESS)
{
if (p->type & CONST_OPTION)
@@ -2266,7 +2266,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
case TYPE_INTEGER:
case TYPE_ENUMERATED:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
counter += len3 + len2;
@@ -2274,7 +2274,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
break;
case TYPE_OBJECT_ID:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
counter += len2 + len3;
@@ -2282,7 +2282,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
break;
case TYPE_TIME:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
counter += len2 + len3;
@@ -2290,7 +2290,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
break;
case TYPE_OCTET_STRING:
len3 = len - counter;
ris = _asn1_get_octet_string (der + counter, NULL, &len3);
ris = MHD__asn1_get_octet_string (der + counter, NULL, &len3);
if (ris != ASN1_SUCCESS)
return ris;
counter += len3;
@@ -2298,7 +2298,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
break;
case TYPE_GENERALSTRING:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
counter += len3 + len2;
@@ -2306,7 +2306,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
break;
case TYPE_BIT_STRING:
len2 =
asn1_get_length_der (der + counter, len - counter, &len3);
MHD__asn1_get_length_der (der + counter, len - counter, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
counter += len3 + len2;
@@ -2317,7 +2317,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
if (move != UP)
{
len3 =
asn1_get_length_der (der + counter, len - counter, &len2);
MHD__asn1_get_length_der (der + counter, len - counter, &len2);
if (len3 < -1)
return ASN1_DER_ERROR;
counter += len2;
@@ -2338,7 +2338,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
if (move != UP)
{
len3 =
asn1_get_length_der (der + counter, len - counter, &len2);
MHD__asn1_get_length_der (der + counter, len - counter, &len2);
if (len3 < -1)
return ASN1_DER_ERROR;
counter += len2;
@@ -2361,7 +2361,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
move = RIGHT;
break;
case TYPE_ANY:
if (asn1_get_tag_der
if (MHD__asn1_get_tag_der
(der + counter, len - counter, &class, &len2,
&tag) != ASN1_SUCCESS)
return ASN1_DER_ERROR;
@@ -2369,7 +2369,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
return ASN1_DER_ERROR;
len4 =
asn1_get_length_der (der + counter + len2,
MHD__asn1_get_length_der (der + counter + len2,
len - counter - len2, &len3);
if (len4 < -1)
return ASN1_DER_ERROR;
@@ -2388,7 +2388,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
len2 = len - counter;
ris =
_asn1_get_indefinite_length_string (der + counter, &len2);
MHD__asn1_get_indefinite_length_string (der + counter, &len2);
if (ris != ASN1_SUCCESS)
return ris;
counter += len2;
@@ -2435,7 +2435,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
move = UP;
}
if (move == UP)
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
return ASN1_ELEMENT_NOT_FOUND;
@@ -2443,12 +2443,12 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
/**
* asn1_expand_any_defined_by - Expand "ANY DEFINED BY" fields in structure.
* MHD__asn1_expand_any_defined_by - Expand "ANY DEFINED BY" fields in structure.
* @definitions: ASN1 definitions
* @element: pointer to an ASN1 structure
*
* Expands every "ANY DEFINED BY" element of a structure created from
* a DER decoding process (asn1_der_decoding function). The element ANY
* a DER decoding process (MHD__asn1_der_decoding function). The element ANY
* must be defined by an OBJECT IDENTIFIER. The type used to expand
* the element ANY is the first one following the definition of
* the actual value of the OBJECT IDENTIFIER.
@@ -2464,12 +2464,12 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
* other errors: Result of der decoding process.
**/
asn1_retCode
asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
MHD__asn1_retCode
MHD__asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
{
char definitionsName[MAX_NAME_SIZE], name[2 * MAX_NAME_SIZE + 1],
value[MAX_NAME_SIZE];
asn1_retCode retCode = ASN1_SUCCESS, result;
MHD__asn1_retCode retCode = ASN1_SUCCESS, result;
int len, len2, len3;
ASN1_TYPE p, p2, p3, aux = ASN1_TYPE_EMPTY;
char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
@@ -2500,7 +2500,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
break;
}
p3 = _asn1_find_up (p);
p3 = MHD__asn1_find_up (p);
if (!p3)
{
@@ -2520,8 +2520,8 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
(p3->value == NULL))
{
p3 = _asn1_find_up (p);
p3 = _asn1_find_up (p3);
p3 = MHD__asn1_find_up (p);
p3 = MHD__asn1_find_up (p3);
if (!p3)
{
@@ -2558,7 +2558,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
len = MAX_NAME_SIZE;
result =
asn1_read_value (definitions, name, value, &len);
MHD__asn1_read_value (definitions, name, value, &len);
if ((result == ASN1_SUCCESS)
&& (!strcmp (p3->value, value)))
@@ -2574,27 +2574,27 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
strcat (name, p2->name);
result =
asn1_create_element (definitions, name, &aux);
MHD__asn1_create_element (definitions, name, &aux);
if (result == ASN1_SUCCESS)
{
_asn1_set_name (aux, p->name);
MHD__asn1_set_name (aux, p->name);
len2 =
asn1_get_length_der (p->value,
MHD__asn1_get_length_der (p->value,
p->value_len, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
result =
asn1_der_decoding (&aux, p->value + len3,
MHD__asn1_der_decoding (&aux, p->value + len3,
len2,
errorDescription);
if (result == ASN1_SUCCESS)
{
_asn1_set_right (aux, p->right);
_asn1_set_right (p, aux);
MHD__asn1_set_right (aux, p->right);
MHD__asn1_set_right (p, aux);
result = asn1_delete_structure (&p);
result = MHD__asn1_delete_structure (&p);
if (result == ASN1_SUCCESS)
{
p = aux;
@@ -2602,20 +2602,20 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
break;
}
else
{ /* error with asn1_delete_structure */
asn1_delete_structure (&aux);
{ /* error with MHD__asn1_delete_structure */
MHD__asn1_delete_structure (&aux);
retCode = result;
break;
}
}
else
{ /* error with asn1_der_decoding */
{ /* error with MHD__asn1_der_decoding */
retCode = result;
break;
}
}
else
{ /* error with asn1_create_element */
{ /* error with MHD__asn1_create_element */
retCode = result;
break;
}
@@ -2658,7 +2658,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
{
while (1)
{
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
if (p == *element)
{
p = NULL;
@@ -2679,7 +2679,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
/**
* asn1_expand_octet_string - Expand "OCTET STRING" fields in structure.
* MHD__asn1_expand_octet_string - Expand "OCTET STRING" fields in structure.
* @definitions: ASN1 definitions
* @element: pointer to an ASN1 structure
* @octetName: name of the OCTECT STRING field to expand.
@@ -2687,7 +2687,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
* the type for expansion.
*
* Expands an "OCTET STRING" element of a structure created from a
* DER decoding process (asn1_der_decoding function). The type used
* DER decoding process (MHD__asn1_der_decoding function). The type used
* for expansion is the first one following the definition of the
* actual value of the OBJECT IDENTIFIER indicated by OBJECTNAME.
*
@@ -2702,12 +2702,12 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
*
* other errors: result of der decoding process.
**/
asn1_retCode
asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
MHD__asn1_retCode
MHD__asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
const char *octetName, const char *objectName)
{
char name[2 * MAX_NAME_SIZE + 1], value[MAX_NAME_SIZE];
asn1_retCode retCode = ASN1_SUCCESS, result;
MHD__asn1_retCode retCode = ASN1_SUCCESS, result;
int len, len2, len3;
ASN1_TYPE p2, aux = ASN1_TYPE_EMPTY;
ASN1_TYPE octetNode = ASN1_TYPE_EMPTY, objectNode = ASN1_TYPE_EMPTY;
@@ -2716,7 +2716,7 @@ asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
if ((definitions == ASN1_TYPE_EMPTY) || (*element == ASN1_TYPE_EMPTY))
return ASN1_ELEMENT_NOT_FOUND;
octetNode = asn1_find_node (*element, octetName);
octetNode = MHD__asn1_find_node (*element, octetName);
if (octetNode == ASN1_TYPE_EMPTY)
return ASN1_ELEMENT_NOT_FOUND;
if (type_field (octetNode->type) != TYPE_OCTET_STRING)
@@ -2724,7 +2724,7 @@ asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
if (octetNode->value == NULL)
return ASN1_VALUE_NOT_FOUND;
objectNode = asn1_find_node (*element, objectName);
objectNode = MHD__asn1_find_node (*element, objectName);
if (objectNode == ASN1_TYPE_EMPTY)
return ASN1_ELEMENT_NOT_FOUND;
@@ -2747,7 +2747,7 @@ asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
strcat (name, p2->name);
len = sizeof (value);
result = asn1_read_value (definitions, name, value, &len);
result = MHD__asn1_read_value (definitions, name, value, &len);
if ((result == ASN1_SUCCESS)
&& (!strcmp (objectNode->value, value)))
@@ -2764,46 +2764,46 @@ asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
strcat (name, ".");
strcat (name, p2->name);
result = asn1_create_element (definitions, name, &aux);
result = MHD__asn1_create_element (definitions, name, &aux);
if (result == ASN1_SUCCESS)
{
_asn1_set_name (aux, octetNode->name);
MHD__asn1_set_name (aux, octetNode->name);
len2 =
asn1_get_length_der (octetNode->value,
MHD__asn1_get_length_der (octetNode->value,
octetNode->value_len, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
result =
asn1_der_decoding (&aux, octetNode->value + len3,
MHD__asn1_der_decoding (&aux, octetNode->value + len3,
len2, errorDescription);
if (result == ASN1_SUCCESS)
{
_asn1_set_right (aux, octetNode->right);
_asn1_set_right (octetNode, aux);
MHD__asn1_set_right (aux, octetNode->right);
MHD__asn1_set_right (octetNode, aux);
result = asn1_delete_structure (&octetNode);
result = MHD__asn1_delete_structure (&octetNode);
if (result == ASN1_SUCCESS)
{
aux = ASN1_TYPE_EMPTY;
break;
}
else
{ /* error with asn1_delete_structure */
asn1_delete_structure (&aux);
{ /* error with MHD__asn1_delete_structure */
MHD__asn1_delete_structure (&aux);
retCode = result;
break;
}
}
else
{ /* error with asn1_der_decoding */
{ /* error with MHD__asn1_der_decoding */
retCode = result;
break;
}
}
else
{ /* error with asn1_create_element */
{ /* error with MHD__asn1_create_element */
retCode = result;
break;
}
src/daemon/https/minitasn1/element.c
+99 -99
View File
@@ -34,7 +34,7 @@
#include "structure.h"
void
_asn1_hierarchical_name (node_asn * node, char *name, int name_size)
MHD__asn1_hierarchical_name (node_asn * node, char *name, int name_size)
{
node_asn *p;
char tmp_name[64];
@@ -47,21 +47,21 @@ _asn1_hierarchical_name (node_asn * node, char *name, int name_size)
{
if (p->name != NULL)
{
_asn1_str_cpy (tmp_name, sizeof (tmp_name), name),
_asn1_str_cpy (name, name_size, p->name);
_asn1_str_cat (name, name_size, ".");
_asn1_str_cat (name, name_size, tmp_name);
MHD__asn1_str_cpy (tmp_name, sizeof (tmp_name), name),
MHD__asn1_str_cpy (name, name_size, p->name);
MHD__asn1_str_cat (name, name_size, ".");
MHD__asn1_str_cat (name, name_size, tmp_name);
}
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
if (name[0] == 0)
_asn1_str_cpy (name, name_size, "ROOT");
MHD__asn1_str_cpy (name, name_size, "ROOT");
}
/******************************************************************/
/* Function : _asn1_convert_integer */
/* Function : MHD__asn1_convert_integer */
/* Description: converts an integer from a null terminated string */
/* to der decoding. The convertion from a null */
/* terminated string to an integer is made with */
@@ -74,8 +74,8 @@ _asn1_hierarchical_name (node_asn * node, char *name, int name_size)
/* len: number of significant byte of value_out. */
/* Return: ASN1_MEM_ERROR or ASN1_SUCCESS */
/******************************************************************/
asn1_retCode
_asn1_convert_integer (const char *value, unsigned char *value_out,
MHD__asn1_retCode
MHD__asn1_convert_integer (const char *value, unsigned char *value_out,
int value_out_size, int *len)
{
char negative;
@@ -117,10 +117,10 @@ _asn1_convert_integer (const char *value, unsigned char *value_out,
#ifdef LIBTASN1_DEBUG_INTEGER
_libtasn1_log ("_asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
MHD__libtasn1_log ("MHD__asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
_libtasn1_log (", vOut[%d]=%d", k, value_out[k]);
_libtasn1_log ("\n");
MHD__libtasn1_log (", vOut[%d]=%d", k, value_out[k]);
MHD__libtasn1_log ("\n");
#endif
@@ -129,7 +129,7 @@ _asn1_convert_integer (const char *value, unsigned char *value_out,
int
_asn1_append_sequence_set (node_asn * node)
MHD__asn1_append_sequence_set (node_asn * node)
{
node_asn *p, *p2;
char temp[10];
@@ -142,21 +142,21 @@ _asn1_append_sequence_set (node_asn * node)
while ((type_field (p->type) == TYPE_TAG)
|| (type_field (p->type) == TYPE_SIZE))
p = p->right;
p2 = _asn1_copy_structure3 (p);
p2 = MHD__asn1_copy_structure3 (p);
while (p->right)
p = p->right;
_asn1_set_right (p, p2);
MHD__asn1_set_right (p, p2);
if (p->name == NULL)
_asn1_str_cpy (temp, sizeof (temp), "?1");
MHD__asn1_str_cpy (temp, sizeof (temp), "?1");
else
{
n = strtol (p->name + 1, NULL, 0);
n++;
temp[0] = '?';
_asn1_ltostr (n, temp + 1);
MHD__asn1_ltostr (n, temp + 1);
}
_asn1_set_name (p2, temp);
MHD__asn1_set_name (p2, temp);
/* p2->type |= CONST_OPTION; */
return ASN1_SUCCESS;
@@ -164,7 +164,7 @@ _asn1_append_sequence_set (node_asn * node)
/**
* asn1_write_value - Set the value of one element inside a structure.
* MHD__asn1_write_value - Set the value of one element inside a structure.
* @node_root: pointer to a structure
* @name: the name of the element inside the structure that you want to set.
* @ivalue: vector used to specify the value to set. If len is >0,
@@ -178,7 +178,7 @@ _asn1_append_sequence_set (node_asn * node)
* If an element is OPTIONAL and you want to delete it, you must use
* the value=NULL and len=0. Using "pkix.asn":
*
* result=asn1_write_value(cert, "tbsCertificate.issuerUniqueID",
* result=MHD__asn1_write_value(cert, "tbsCertificate.issuerUniqueID",
* NULL, 0);
*
* Description for each type:
@@ -244,7 +244,7 @@ _asn1_append_sequence_set (node_asn * node)
* the alternatives with a null terminated string. LEN != 0. Using
* "pkix.asn"\:
*
* result=asn1_write_value(cert,
* result=MHD__asn1_write_value(cert,
* "certificate1.tbsCertificate.subject", "rdnSequence",
* 1);
*
@@ -257,12 +257,12 @@ _asn1_append_sequence_set (node_asn * node)
*
* Using "pkix.asn"\:
*
* result=asn1_write_value(cert,
* result=MHD__asn1_write_value(cert,
* "certificate1.tbsCertificate.subject.rdnSequence", "NEW", 1);
*
* SET OF: the same as SEQUENCE OF. Using "pkix.asn":
*
* result=asn1_write_value(cert,
* result=MHD__asn1_write_value(cert,
* "tbsCertificate.subject.rdnSequence.?LAST", "NEW", 1);
*
* Returns:
@@ -274,8 +274,8 @@ _asn1_append_sequence_set (node_asn * node)
* ASN1_VALUE_NOT_VALID: VALUE has a wrong format.
*
**/
asn1_retCode
asn1_write_value (ASN1_TYPE node_root, const char *name,
MHD__asn1_retCode
MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
const void *ivalue, int len)
{
node_asn *node, *p, *p2;
@@ -283,13 +283,13 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
int len2, k, k2, negative;
const unsigned char *value = ivalue;
node = asn1_find_node (node_root, name);
node = MHD__asn1_find_node (node_root, name);
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
if ((node->type & CONST_OPTION) && (value == NULL) && (len == 0))
{
asn1_delete_structure (&node);
MHD__asn1_delete_structure (&node);
return ASN1_SUCCESS;
}
@@ -302,7 +302,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
p = p->right;
while (p->right)
asn1_delete_structure (&p->right);
MHD__asn1_delete_structure (&p->right);
return ASN1_SUCCESS;
}
@@ -318,12 +318,12 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
while (type_field (p->type) != TYPE_DEFAULT)
p = p->right;
if (p->type & CONST_TRUE)
_asn1_set_value (node, NULL, 0);
MHD__asn1_set_value (node, NULL, 0);
else
_asn1_set_value (node, "T", 1);
MHD__asn1_set_value (node, "T", 1);
}
else
_asn1_set_value (node, "T", 1);
MHD__asn1_set_value (node, "T", 1);
}
else if (!strcmp (value, "FALSE"))
{
@@ -333,12 +333,12 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
while (type_field (p->type) != TYPE_DEFAULT)
p = p->right;
if (p->type & CONST_FALSE)
_asn1_set_value (node, NULL, 0);
MHD__asn1_set_value (node, NULL, 0);
else
_asn1_set_value (node, "F", 1);
MHD__asn1_set_value (node, "F", 1);
}
else
_asn1_set_value (node, "F", 1);
MHD__asn1_set_value (node, "F", 1);
}
else
return ASN1_VALUE_NOT_VALID;
@@ -350,11 +350,11 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
if ((isdigit (value[0])) || (value[0] == '-'))
{
value_temp =
(unsigned char *) _asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
(unsigned char *) MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
if (value_temp == NULL)
return ASN1_MEM_ALLOC_ERROR;
_asn1_convert_integer (value, value_temp,
MHD__asn1_convert_integer (value, value_temp,
SIZEOF_UNSIGNED_LONG_INT, &len);
}
else
@@ -370,11 +370,11 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
{
value_temp =
(unsigned char *)
_asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
if (value_temp == NULL)
return ASN1_MEM_ALLOC_ERROR;
_asn1_convert_integer (p->value,
MHD__asn1_convert_integer (p->value,
value_temp,
SIZEOF_UNSIGNED_LONG_INT,
&len);
@@ -389,7 +389,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
}
else
{ /* len != 0 */
value_temp = (unsigned char *) _asn1_alloca (len);
value_temp = (unsigned char *) MHD__asn1_alloca (len);
if (value_temp == NULL)
return ASN1_MEM_ALLOC_ERROR;
memcpy (value_temp, value, len);
@@ -403,7 +403,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
if (negative && (type_field (node->type) == TYPE_ENUMERATED))
{
_asn1_afree (value_temp);
MHD__asn1_afree (value_temp);
return ASN1_VALUE_NOT_VALID;
}
@@ -417,18 +417,18 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
(!negative && (value_temp[k] & 0x80)))
k--;
asn1_length_der (len - k, NULL, &len2);
temp = (unsigned char *) _asn1_alloca (len - k + len2);
MHD__asn1_length_der (len - k, NULL, &len2);
temp = (unsigned char *) MHD__asn1_alloca (len - k + len2);
if (temp == NULL)
{
_asn1_afree (value_temp);
MHD__asn1_afree (value_temp);
return ASN1_MEM_ALLOC_ERROR;
}
asn1_octet_der (value_temp + k, len - k, temp, &len2);
_asn1_set_value (node, temp, len2);
MHD__asn1_octet_der (value_temp + k, len - k, temp, &len2);
MHD__asn1_set_value (node, temp, len2);
_asn1_afree (temp);
MHD__asn1_afree (temp);
if (node->type & CONST_DEFAULT)
@@ -439,21 +439,21 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
if ((isdigit (p->value[0])) || (p->value[0] == '-'))
{
default_temp =
(unsigned char *) _asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
(unsigned char *) MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
if (default_temp == NULL)
{
_asn1_afree (value_temp);
MHD__asn1_afree (value_temp);
return ASN1_MEM_ALLOC_ERROR;
}
_asn1_convert_integer (p->value, default_temp,
MHD__asn1_convert_integer (p->value, default_temp,
SIZEOF_UNSIGNED_LONG_INT, &len2);
}
else
{ /* is an identifier like v1 */
if (!(node->type & CONST_LIST))
{
_asn1_afree (value_temp);
MHD__asn1_afree (value_temp);
return ASN1_VALUE_NOT_VALID;
}
p2 = node->down;
@@ -465,14 +465,14 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
{
default_temp =
(unsigned char *)
_asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
if (default_temp == NULL)
{
_asn1_afree (value_temp);
MHD__asn1_afree (value_temp);
return ASN1_MEM_ALLOC_ERROR;
}
_asn1_convert_integer (p2->value,
MHD__asn1_convert_integer (p2->value,
default_temp,
SIZEOF_UNSIGNED_LONG_INT,
&len2);
@@ -483,7 +483,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
}
if (p2 == NULL)
{
_asn1_afree (value_temp);
MHD__asn1_afree (value_temp);
return ASN1_VALUE_NOT_VALID;
}
}
@@ -497,11 +497,11 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
break;
}
if (k2 == len2)
_asn1_set_value (node, NULL, 0);
MHD__asn1_set_value (node, NULL, 0);
}
_asn1_afree (default_temp);
MHD__asn1_afree (default_temp);
}
_asn1_afree (value_temp);
MHD__asn1_afree (value_temp);
break;
case TYPE_OBJECT_ID:
for (k = 0; k < strlen (value); k++)
@@ -514,11 +514,11 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
p = p->right;
if (!strcmp (value, p->value))
{
_asn1_set_value (node, NULL, 0);
MHD__asn1_set_value (node, NULL, 0);
break;
}
}
_asn1_set_value (node, value, strlen (value) + 1);
MHD__asn1_set_value (node, value, strlen (value) + 1);
break;
case TYPE_TIME:
if (node->type & CONST_UTC)
@@ -558,49 +558,49 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
default:
return ASN1_VALUE_NOT_FOUND;
}
_asn1_set_value (node, value, strlen (value) + 1);
MHD__asn1_set_value (node, value, strlen (value) + 1);
}
else
{ /* GENERALIZED TIME */
if (value)
_asn1_set_value (node, value, strlen (value) + 1);
MHD__asn1_set_value (node, value, strlen (value) + 1);
}
break;
case TYPE_OCTET_STRING:
if (len == 0)
len = strlen (value);
asn1_length_der (len, NULL, &len2);
temp = (unsigned char *) _asn1_alloca (len + len2);
MHD__asn1_length_der (len, NULL, &len2);
temp = (unsigned char *) MHD__asn1_alloca (len + len2);
if (temp == NULL)
return ASN1_MEM_ALLOC_ERROR;
asn1_octet_der (value, len, temp, &len2);
_asn1_set_value (node, temp, len2);
_asn1_afree (temp);
MHD__asn1_octet_der (value, len, temp, &len2);
MHD__asn1_set_value (node, temp, len2);
MHD__asn1_afree (temp);
break;
case TYPE_GENERALSTRING:
if (len == 0)
len = strlen (value);
asn1_length_der (len, NULL, &len2);
temp = (unsigned char *) _asn1_alloca (len + len2);
MHD__asn1_length_der (len, NULL, &len2);
temp = (unsigned char *) MHD__asn1_alloca (len + len2);
if (temp == NULL)
return ASN1_MEM_ALLOC_ERROR;
asn1_octet_der (value, len, temp, &len2);
_asn1_set_value (node, temp, len2);
_asn1_afree (temp);
MHD__asn1_octet_der (value, len, temp, &len2);
MHD__asn1_set_value (node, temp, len2);
MHD__asn1_afree (temp);
break;
case TYPE_BIT_STRING:
if (len == 0)
len = strlen (value);
asn1_length_der ((len >> 3) + 2, NULL, &len2);
temp = (unsigned char *) _asn1_alloca ((len >> 3) + 2 + len2);
MHD__asn1_length_der ((len >> 3) + 2, NULL, &len2);
temp = (unsigned char *) MHD__asn1_alloca ((len >> 3) + 2 + len2);
if (temp == NULL)
return ASN1_MEM_ALLOC_ERROR;
asn1_bit_der (value, len, temp, &len2);
_asn1_set_value (node, temp, len2);
_asn1_afree (temp);
MHD__asn1_bit_der (value, len, temp, &len2);
MHD__asn1_set_value (node, temp, len2);
MHD__asn1_afree (temp);
break;
case TYPE_CHOICE:
p = node->down;
@@ -613,7 +613,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
{
if (p2 != p)
{
asn1_delete_structure (&p2);
MHD__asn1_delete_structure (&p2);
p2 = node->down;
}
else
@@ -627,20 +627,20 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
return ASN1_ELEMENT_NOT_FOUND;
break;
case TYPE_ANY:
asn1_length_der (len, NULL, &len2);
temp = (unsigned char *) _asn1_alloca (len + len2);
MHD__asn1_length_der (len, NULL, &len2);
temp = (unsigned char *) MHD__asn1_alloca (len + len2);
if (temp == NULL)
return ASN1_MEM_ALLOC_ERROR;
asn1_octet_der (value, len, temp, &len2);
_asn1_set_value (node, temp, len2);
_asn1_afree (temp);
MHD__asn1_octet_der (value, len, temp, &len2);
MHD__asn1_set_value (node, temp, len2);
MHD__asn1_afree (temp);
break;
case TYPE_SEQUENCE_OF:
case TYPE_SET_OF:
if (strcmp (value, "NEW"))
return ASN1_VALUE_NOT_VALID;
_asn1_append_sequence_set (node);
MHD__asn1_append_sequence_set (node);
break;
default:
return ASN1_ELEMENT_NOT_FOUND;
@@ -678,7 +678,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
}
/**
* asn1_read_value - Returns the value of one element inside a structure
* MHD__asn1_read_value - Returns the value of one element inside a structure
* @root: pointer to a structure.
* @name: the name of the element inside a structure that you want to read.
* @ivalue: vector that will contain the element's content, must be a
@@ -743,15 +743,15 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
* In this case LEN will contain the number of bytes needed.
*
**/
asn1_retCode
asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
MHD__asn1_retCode
MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
{
node_asn *node, *p, *p2;
int len2, len3;
int value_size = *len;
unsigned char *value = ivalue;
node = asn1_find_node (root, name);
node = MHD__asn1_find_node (root, name);
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
@@ -800,7 +800,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
if ((isdigit (p->value[0])) || (p->value[0] == '-')
|| (p->value[0] == '+'))
{
if (_asn1_convert_integer
if (MHD__asn1_convert_integer
(p->value, value, value_size, len) != ASN1_SUCCESS)
return ASN1_MEM_ERROR;
}
@@ -813,7 +813,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
{
if ((p2->name) && (!strcmp (p2->name, p->value)))
{
if (_asn1_convert_integer
if (MHD__asn1_convert_integer
(p2->value, value, value_size,
len) != ASN1_SUCCESS)
return ASN1_MEM_ERROR;
@@ -827,7 +827,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
else
{
len2 = -1;
if (asn1_get_octet_der
if (MHD__asn1_get_octet_der
(node->value, node->value_len, &len2, value, value_size,
len) != ASN1_SUCCESS)
return ASN1_MEM_ERROR;
@@ -869,21 +869,21 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
break;
case TYPE_OCTET_STRING:
len2 = -1;
if (asn1_get_octet_der
if (MHD__asn1_get_octet_der
(node->value, node->value_len, &len2, value, value_size,
len) != ASN1_SUCCESS)
return ASN1_MEM_ERROR;
break;
case TYPE_GENERALSTRING:
len2 = -1;
if (asn1_get_octet_der
if (MHD__asn1_get_octet_der
(node->value, node->value_len, &len2, value, value_size,
len) != ASN1_SUCCESS)
return ASN1_MEM_ERROR;
break;
case TYPE_BIT_STRING:
len2 = -1;
if (asn1_get_bit_der
if (MHD__asn1_get_bit_der
(node->value, node->value_len, &len2, value, value_size,
len) != ASN1_SUCCESS)
return ASN1_MEM_ERROR;
@@ -893,7 +893,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
break;
case TYPE_ANY:
len3 = -1;
len2 = asn1_get_length_der (node->value, node->value_len, &len3);
len2 = MHD__asn1_get_length_der (node->value, node->value_len, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
PUT_VALUE (value, value_size, node->value + len3, len2);
@@ -907,7 +907,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
/**
* asn1_read_tag - Returns the TAG of one element inside a structure
* MHD__asn1_read_tag - Returns the TAG of one element inside a structure
* @root: pointer to a structure
* @name: the name of the element inside a structure.
* @tagValue: variable that will contain the TAG value.
@@ -925,13 +925,13 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
* ASN1_ELEMENT_NOT_FOUND: NAME is not a valid element.
*
**/
asn1_retCode
asn1_read_tag (node_asn * root, const char *name, int *tagValue,
MHD__asn1_retCode
MHD__asn1_read_tag (node_asn * root, const char *name, int *tagValue,
int *classValue)
{
node_asn *node, *p, *pTag;
node = asn1_find_node (root, name);
node = MHD__asn1_find_node (root, name);
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
src/daemon/https/minitasn1/element.h
+3 -3
View File
@@ -3,12 +3,12 @@
#define _ELEMENT_H
asn1_retCode _asn1_append_sequence_set (node_asn * node);
MHD__asn1_retCode MHD__asn1_append_sequence_set (node_asn * node);
asn1_retCode _asn1_convert_integer (const char *value,
MHD__asn1_retCode MHD__asn1_convert_integer (const char *value,
unsigned char *value_out,
int value_out_size, int *len);
void _asn1_hierarchical_name (node_asn * node, char *name, int name_size);
void MHD__asn1_hierarchical_name (node_asn * node, char *name, int name_size);
#endif
src/daemon/https/minitasn1/errors.c
+10 -10
View File
@@ -30,14 +30,14 @@
#define LIBTASN1_ERROR_ENTRY(name) \
{ #name, name }
struct libtasn1_error_entry
struct MHD__libtasn1_error_entry
{
const char *name;
int number;
};
typedef struct libtasn1_error_entry libtasn1_error_entry;
typedef struct MHD__libtasn1_error_entry MHD__libtasn1_error_entry;
static const libtasn1_error_entry error_algorithms[] = {
static const MHD__libtasn1_error_entry error_algorithms[] = {
LIBTASN1_ERROR_ENTRY (ASN1_SUCCESS),
LIBTASN1_ERROR_ENTRY (ASN1_FILE_NOT_FOUND),
LIBTASN1_ERROR_ENTRY (ASN1_ELEMENT_NOT_FOUND),
@@ -60,7 +60,7 @@ static const libtasn1_error_entry error_algorithms[] = {
};
#define LIBTASN1_ERROR_LOOP(b) \
const libtasn1_error_entry *p; \
const MHD__libtasn1_error_entry *p; \
for(p = error_algorithms; p->name != NULL; p++) { b ; }
#define LIBTASN1_ERROR_ALG_LOOP(a) \
@@ -69,14 +69,14 @@ static const libtasn1_error_entry error_algorithms[] = {
/**
* libtasn1_perror - prints a string to stderr with a description of an error
* MHD__libtasn1_perror - prints a string to stderr with a description of an error
* @error: is an error returned by a libtasn1 function.
*
* This function is like perror(). The only difference is that it
* accepts an error returned by a libtasn1 function.
**/
void
libtasn1_perror (asn1_retCode error)
MHD__libtasn1_perror (MHD__asn1_retCode error)
{
const char *ret = NULL;
@@ -89,7 +89,7 @@ libtasn1_perror (asn1_retCode error)
/**
* libtasn1_strerror - Returns a string with a description of an error
* MHD__libtasn1_strerror - Returns a string with a description of an error
* @error: is an error returned by a libtasn1 function.
*
* This function is similar to strerror(). The only difference is
@@ -99,7 +99,7 @@ libtasn1_perror (asn1_retCode error)
* code.
**/
const char *
libtasn1_strerror (asn1_retCode error)
MHD__libtasn1_strerror (MHD__asn1_retCode error)
{
const char *ret = NULL;
@@ -113,7 +113,7 @@ libtasn1_strerror (asn1_retCode error)
*/
#ifdef LIBTASN1_DEBUG
void
_libtasn1_log (const char *fmt, ...)
MHD__libtasn1_log (const char *fmt, ...)
{
va_list args;
char str[MAX_LOG_SIZE];
@@ -128,7 +128,7 @@ _libtasn1_log (const char *fmt, ...)
}
#else /* not DEBUG */
void
_libtasn1_log (const char *fmt, ...)
MHD__libtasn1_log (const char *fmt, ...)
{
return;
}
src/daemon/https/minitasn1/errors.h
+1 -1
View File
@@ -25,6 +25,6 @@
#include "int.h"
void _libtasn1_log (const char *fmt, ...);
void MHD__libtasn1_log (const char *fmt, ...);
#endif /* ERRORS_H */
src/daemon/https/minitasn1/gstr.c
+2 -2
View File
@@ -29,7 +29,7 @@
* They should be used only with null terminated strings.
*/
void
_asn1_str_cat (char *dest, size_t dest_tot_size, const char *src)
MHD__asn1_str_cat (char *dest, size_t dest_tot_size, const char *src)
{
size_t str_size = strlen (src);
size_t dest_size = strlen (dest);
@@ -49,7 +49,7 @@ _asn1_str_cat (char *dest, size_t dest_tot_size, const char *src)
}
void
_asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src)
MHD__asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src)
{
size_t str_size = strlen (src);
src/daemon/https/minitasn1/gstr.h
+4 -4
View File
@@ -1,5 +1,5 @@
void _asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src);
void _asn1_str_cat (char *dest, size_t dest_tot_size, const char *src);
void MHD__asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src);
void MHD__asn1_str_cat (char *dest, size_t dest_tot_size, const char *src);
#define Estrcpy(x,y) _asn1_str_cpy(x,MAX_ERROR_DESCRIPTION_SIZE,y)
#define Estrcat(x,y) _asn1_str_cat(x,MAX_ERROR_DESCRIPTION_SIZE,y)
#define Estrcpy(x,y) MHD__asn1_str_cpy(x,MAX_ERROR_DESCRIPTION_SIZE,y)
#define Estrcat(x,y) MHD__asn1_str_cat(x,MAX_ERROR_DESCRIPTION_SIZE,y)
src/daemon/https/minitasn1/libtasn1.h
+34 -34
View File
@@ -43,7 +43,7 @@ extern "C"
/* (null character included) */
typedef int asn1_retCode; /* type returned by libtasn1 functions */
typedef int MHD__asn1_retCode; /* type returned by libtasn1 functions */
/*****************************************/
/* Errors returned by libtasn1 functions */
@@ -68,7 +68,7 @@ extern "C"
#define ASN1_ELEMENT_NOT_EMPTY 17
/*************************************/
/* Constants used in asn1_visit_tree */
/* Constants used in MHD__asn1_visit_tree */
/*************************************/
#define ASN1_PRINT_NAME 1
#define ASN1_PRINT_NAME_TYPE 2
@@ -76,7 +76,7 @@ extern "C"
#define ASN1_PRINT_ALL 4
/*****************************************/
/* Constants returned by asn1_read_tag */
/* Constants returned by MHD__asn1_read_tag */
/*****************************************/
#define ASN1_CLASS_UNIVERSAL 0x00 /* old: 1 */
#define ASN1_CLASS_APPLICATION 0x40 /* old: 2 */
@@ -85,7 +85,7 @@ extern "C"
#define ASN1_CLASS_STRUCTURED 0x20
/*****************************************/
/* Constants returned by asn1_read_tag */
/* Constants returned by MHD__asn1_read_tag */
/*****************************************/
#define ASN1_TAG_BOOLEAN 0x01
#define ASN1_TAG_INTEGER 0x02
@@ -137,106 +137,106 @@ extern "C"
/* Functions definitions */
/***********************************/
asn1_retCode asn1_parser2tree (const char *file_name,
MHD__asn1_retCode MHD__asn1_parser2tree (const char *file_name,
ASN1_TYPE * definitions,
char *errorDescription);
asn1_retCode asn1_parser2array (const char *inputFileName,
MHD__asn1_retCode MHD__asn1_parser2array (const char *inputFileName,
const char *outputFileName,
const char *vectorName,
char *errorDescription);
asn1_retCode asn1_array2tree (const ASN1_ARRAY_TYPE * array,
MHD__asn1_retCode MHD__asn1_array2tree (const ASN1_ARRAY_TYPE * array,
ASN1_TYPE * definitions,
char *errorDescription);
void asn1_print_structure (FILE * out, ASN1_TYPE structure,
void MHD__asn1_print_structure (FILE * out, ASN1_TYPE structure,
const char *name, int mode);
asn1_retCode asn1_create_element (ASN1_TYPE definitions,
MHD__asn1_retCode MHD__asn1_create_element (ASN1_TYPE definitions,
const char *source_name,
ASN1_TYPE * element);
asn1_retCode asn1_delete_structure (ASN1_TYPE * structure);
MHD__asn1_retCode MHD__asn1_delete_structure (ASN1_TYPE * structure);
asn1_retCode asn1_delete_element (ASN1_TYPE structure,
MHD__asn1_retCode MHD__asn1_delete_element (ASN1_TYPE structure,
const char *element_name);
asn1_retCode asn1_write_value (ASN1_TYPE node_root, const char *name,
MHD__asn1_retCode MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
const void *ivalue, int len);
asn1_retCode asn1_read_value (ASN1_TYPE root, const char *name,
MHD__asn1_retCode MHD__asn1_read_value (ASN1_TYPE root, const char *name,
void *ivalue, int *len);
asn1_retCode asn1_number_of_elements (ASN1_TYPE element, const char *name,
MHD__asn1_retCode MHD__asn1_number_of_elements (ASN1_TYPE element, const char *name,
int *num);
asn1_retCode asn1_der_coding (ASN1_TYPE element, const char *name,
MHD__asn1_retCode MHD__asn1_der_coding (ASN1_TYPE element, const char *name,
void *ider, int *len, char *ErrorDescription);
asn1_retCode asn1_der_decoding (ASN1_TYPE * element, const void *ider,
MHD__asn1_retCode MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider,
int len, char *errorDescription);
asn1_retCode asn1_der_decoding_element (ASN1_TYPE * structure,
MHD__asn1_retCode MHD__asn1_der_decoding_element (ASN1_TYPE * structure,
const char *elementName,
const void *ider, int len,
char *errorDescription);
asn1_retCode asn1_der_decoding_startEnd (ASN1_TYPE element,
MHD__asn1_retCode MHD__asn1_der_decoding_startEnd (ASN1_TYPE element,
const void *ider, int len,
const char *name_element,
int *start, int *end);
asn1_retCode asn1_expand_any_defined_by (ASN1_TYPE definitions,
MHD__asn1_retCode MHD__asn1_expand_any_defined_by (ASN1_TYPE definitions,
ASN1_TYPE * element);
asn1_retCode asn1_expand_octet_string (ASN1_TYPE definitions,
MHD__asn1_retCode MHD__asn1_expand_octet_string (ASN1_TYPE definitions,
ASN1_TYPE * element,
const char *octetName,
const char *objectName);
asn1_retCode asn1_read_tag (node_asn * root, const char *name,
MHD__asn1_retCode MHD__asn1_read_tag (node_asn * root, const char *name,
int *tagValue, int *classValue);
const char *asn1_find_structure_from_oid (ASN1_TYPE definitions,
const char *MHD__asn1_find_structure_from_oid (ASN1_TYPE definitions,
const char *oidValue);
const char *asn1_check_version (const char *req_version);
const char *MHD__asn1_check_version (const char *req_version);
const char *libtasn1_strerror (asn1_retCode error);
const char *MHD__libtasn1_strerror (MHD__asn1_retCode error);
void libtasn1_perror (asn1_retCode error);
void MHD__libtasn1_perror (MHD__asn1_retCode error);
/* DER utility functions. */
int asn1_get_tag_der (const unsigned char *der, int der_len,
int MHD__asn1_get_tag_der (const unsigned char *der, int der_len,
unsigned char *cls, int *len, unsigned long *tag);
void asn1_octet_der (const unsigned char *str, int str_len,
void MHD__asn1_octet_der (const unsigned char *str, int str_len,
unsigned char *der, int *der_len);
asn1_retCode asn1_get_octet_der (const unsigned char *der, int der_len,
MHD__asn1_retCode MHD__asn1_get_octet_der (const unsigned char *der, int der_len,
int *ret_len, unsigned char *str,
int str_size, int *str_len);
void asn1_bit_der (const unsigned char *str, int bit_len,
void MHD__asn1_bit_der (const unsigned char *str, int bit_len,
unsigned char *der, int *der_len);
asn1_retCode asn1_get_bit_der (const unsigned char *der, int der_len,
MHD__asn1_retCode MHD__asn1_get_bit_der (const unsigned char *der, int der_len,
int *ret_len, unsigned char *str,
int str_size, int *bit_len);
signed long asn1_get_length_der (const unsigned char *der, int der_len,
signed long MHD__asn1_get_length_der (const unsigned char *der, int der_len,
int *len);
void asn1_length_der (unsigned long int len, unsigned char *ans,
void MHD__asn1_length_der (unsigned long int len, unsigned char *ans,
int *ans_len);
/* Other utility functions. */
ASN1_TYPE asn1_find_node (ASN1_TYPE pointer, const char *name);
ASN1_TYPE MHD__asn1_find_node (ASN1_TYPE pointer, const char *name);
asn1_retCode asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
MHD__asn1_retCode MHD__asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
ASN1_TYPE src, const char *src_name);
#ifdef __cplusplus
src/daemon/https/minitasn1/mem.h
+10 -10
View File
@@ -1,7 +1,7 @@
#ifndef MEM_H
# define MEM_H
/* Use _asn1_afree() when calling alloca, or
/* Use MHD__asn1_afree() when calling alloca, or
* memory leaks may occur in systems which do not
* support alloca.
*/
@@ -9,17 +9,17 @@
# ifdef HAVE_ALLOCA_H
# include <alloca.h>
# endif
# define _asn1_alloca alloca
# define _asn1_afree(x)
# define MHD__asn1_alloca alloca
# define MHD__asn1_afree(x)
#else
# define _asn1_alloca _asn1_malloc
# define _asn1_afree _asn1_free
# define MHD__asn1_alloca MHD__asn1_malloc
# define MHD__asn1_afree MHD__asn1_free
#endif /* HAVE_ALLOCA */
#define _asn1_malloc malloc
#define _asn1_free free
#define _asn1_calloc calloc
#define _asn1_realloc realloc
#define _asn1_strdup strdup
#define MHD__asn1_malloc malloc
#define MHD__asn1_free free
#define MHD__asn1_calloc calloc
#define MHD__asn1_realloc realloc
#define MHD__asn1_strdup strdup
#endif /* MEM_H */
src/daemon/https/minitasn1/parser_aux.c
+112 -112
View File
@@ -27,7 +27,7 @@
#include "structure.h"
#include "element.h"
char _asn1_identifierMissing[MAX_NAME_SIZE + 1]; /* identifier name not found */
char MHD__asn1_identifierMissing[MAX_NAME_SIZE + 1]; /* identifier name not found */
/***********************************************/
/* Type: list_type */
@@ -45,7 +45,7 @@ typedef struct list_struct
list_type *firstElement = NULL;
/******************************************************/
/* Function : _asn1_add_node */
/* Function : MHD__asn1_add_node */
/* Description: creates a new NODE_ASN element and */
/* puts it in the list pointed by firstElement. */
/* Parameters: */
@@ -54,19 +54,19 @@ list_type *firstElement = NULL;
/* Return: pointer to the new element. */
/******************************************************/
node_asn *
_asn1_add_node (unsigned int type)
MHD__asn1_add_node (unsigned int type)
{
list_type *listElement;
node_asn *punt;
punt = (node_asn *) _asn1_calloc (1, sizeof (node_asn));
punt = (node_asn *) MHD__asn1_calloc (1, sizeof (node_asn));
if (punt == NULL)
return NULL;
listElement = (list_type *) _asn1_malloc (sizeof (list_type));
listElement = (list_type *) MHD__asn1_malloc (sizeof (list_type));
if (listElement == NULL)
{
_asn1_free (punt);
MHD__asn1_free (punt);
return NULL;
}
@@ -80,7 +80,7 @@ _asn1_add_node (unsigned int type)
}
/**
* asn1_find_node:
* MHD__asn1_find_node:
* @pointer: NODE_ASN element pointer.
* @name: null terminated string with the element's name to find.
*
@@ -92,7 +92,7 @@ _asn1_add_node (unsigned int type)
* Return value: the searching result. NULL if not found.
**/
ASN1_TYPE
asn1_find_node (ASN1_TYPE pointer, const char *name)
MHD__asn1_find_node (ASN1_TYPE pointer, const char *name)
{
node_asn *p;
char *n_end, n[MAX_NAME_SIZE + 1];
@@ -119,7 +119,7 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
}
else
{
_asn1_str_cpy (n, sizeof (n), n_start);
MHD__asn1_str_cpy (n, sizeof (n), n_start);
n_start = NULL;
}
@@ -152,7 +152,7 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
}
else
{
_asn1_str_cpy (n, sizeof (n), n_start);
MHD__asn1_str_cpy (n, sizeof (n), n_start);
n_start = NULL;
}
@@ -189,7 +189,7 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
/******************************************************************/
/* Function : _asn1_set_value */
/* Function : MHD__asn1_set_value */
/* Description: sets the field VALUE in a NODE_ASN element. The */
/* previous value (if exist) will be lost */
/* Parameters: */
@@ -199,7 +199,7 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
node_asn *
_asn1_set_value (node_asn * node, const void *_value, unsigned int len)
MHD__asn1_set_value (node_asn * node, const void *_value, unsigned int len)
{
const unsigned char *value = _value;
@@ -207,13 +207,13 @@ _asn1_set_value (node_asn * node, const void *_value, unsigned int len)
return node;
if (node->value)
{
_asn1_free (node->value);
MHD__asn1_free (node->value);
node->value = NULL;
node->value_len = 0;
}
if (!len)
return node;
node->value = (unsigned char *) _asn1_malloc (len);
node->value = (unsigned char *) MHD__asn1_malloc (len);
if (node->value == NULL)
return NULL;
node->value_len = len;
@@ -223,7 +223,7 @@ _asn1_set_value (node_asn * node, const void *_value, unsigned int len)
}
/******************************************************************/
/* Function : _asn1_set_name */
/* Function : MHD__asn1_set_name */
/* Description: sets the field NAME in a NODE_ASN element. The */
/* previous value (if exist) will be lost */
/* Parameters: */
@@ -233,14 +233,14 @@ _asn1_set_value (node_asn * node, const void *_value, unsigned int len)
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
node_asn *
_asn1_set_name (node_asn * node, const char *name)
MHD__asn1_set_name (node_asn * node, const char *name)
{
if (node == NULL)
return node;
if (node->name)
{
_asn1_free (node->name);
MHD__asn1_free (node->name);
node->name = NULL;
}
@@ -249,7 +249,7 @@ _asn1_set_name (node_asn * node, const char *name)
if (strlen (name))
{
node->name = (char *) _asn1_strdup (name);
node->name = (char *) MHD__asn1_strdup (name);
if (node->name == NULL)
return NULL;
}
@@ -259,7 +259,7 @@ _asn1_set_name (node_asn * node, const char *name)
}
/******************************************************************/
/* Function : _asn1_set_right */
/* Function : MHD__asn1_set_right */
/* Description: sets the field RIGHT in a NODE_ASN element. */
/* Parameters: */
/* node: element pointer. */
@@ -268,7 +268,7 @@ _asn1_set_name (node_asn * node, const char *name)
/* Return: pointer to *NODE. */
/******************************************************************/
node_asn *
_asn1_set_right (node_asn * node, node_asn * right)
MHD__asn1_set_right (node_asn * node, node_asn * right)
{
if (node == NULL)
return node;
@@ -279,7 +279,7 @@ _asn1_set_right (node_asn * node, node_asn * right)
}
/******************************************************************/
/* Function : _asn1_get_right */
/* Function : MHD__asn1_get_right */
/* Description: returns the element pointed by the RIGHT field of */
/* a NODE_ASN element. */
/* Parameters: */
@@ -287,7 +287,7 @@ _asn1_set_right (node_asn * node, node_asn * right)
/* Return: field RIGHT of NODE. */
/******************************************************************/
node_asn *
_asn1_get_right (node_asn * node)
MHD__asn1_get_right (node_asn * node)
{
if (node == NULL)
return NULL;
@@ -295,14 +295,14 @@ _asn1_get_right (node_asn * node)
}
/******************************************************************/
/* Function : _asn1_get_last_right */
/* Function : MHD__asn1_get_last_right */
/* Description: return the last element along the right chain. */
/* Parameters: */
/* node: starting element pointer. */
/* Return: pointer to the last element along the right chain. */
/******************************************************************/
node_asn *
_asn1_get_last_right (node_asn * node)
MHD__asn1_get_last_right (node_asn * node)
{
node_asn *p;
@@ -315,7 +315,7 @@ _asn1_get_last_right (node_asn * node)
}
/******************************************************************/
/* Function : _asn1_set_down */
/* Function : MHD__asn1_set_down */
/* Description: sets the field DOWN in a NODE_ASN element. */
/* Parameters: */
/* node: element pointer. */
@@ -324,7 +324,7 @@ _asn1_get_last_right (node_asn * node)
/* Return: pointer to *NODE. */
/******************************************************************/
node_asn *
_asn1_set_down (node_asn * node, node_asn * down)
MHD__asn1_set_down (node_asn * node, node_asn * down)
{
if (node == NULL)
return node;
@@ -335,7 +335,7 @@ _asn1_set_down (node_asn * node, node_asn * down)
}
/******************************************************************/
/* Function : _asn1_get_down */
/* Function : MHD__asn1_get_down */
/* Description: returns the element pointed by the DOWN field of */
/* a NODE_ASN element. */
/* Parameters: */
@@ -343,7 +343,7 @@ _asn1_set_down (node_asn * node, node_asn * down)
/* Return: field DOWN of NODE. */
/******************************************************************/
node_asn *
_asn1_get_down (node_asn * node)
MHD__asn1_get_down (node_asn * node)
{
if (node == NULL)
return NULL;
@@ -351,14 +351,14 @@ _asn1_get_down (node_asn * node)
}
/******************************************************************/
/* Function : _asn1_get_name */
/* Function : MHD__asn1_get_name */
/* Description: returns the name of a NODE_ASN element. */
/* Parameters: */
/* node: NODE_ASN element pointer. */
/* Return: a null terminated string. */
/******************************************************************/
char *
_asn1_get_name (node_asn * node)
MHD__asn1_get_name (node_asn * node)
{
if (node == NULL)
return NULL;
@@ -366,7 +366,7 @@ _asn1_get_name (node_asn * node)
}
/******************************************************************/
/* Function : _asn1_mod_type */
/* Function : MHD__asn1_mod_type */
/* Description: change the field TYPE of an NODE_ASN element. */
/* The new value is the old one | (bitwise or) the */
/* paramener VALUE. */
@@ -377,7 +377,7 @@ _asn1_get_name (node_asn * node)
/* Return: NODE pointer. */
/******************************************************************/
node_asn *
_asn1_mod_type (node_asn * node, unsigned int value)
MHD__asn1_mod_type (node_asn * node, unsigned int value)
{
if (node == NULL)
return node;
@@ -387,34 +387,34 @@ _asn1_mod_type (node_asn * node, unsigned int value)
/******************************************************************/
/* Function : _asn1_remove_node */
/* Function : MHD__asn1_remove_node */
/* Description: gets free the memory allocated for an NODE_ASN */
/* element (not the elements pointed by it). */
/* Parameters: */
/* node: NODE_ASN element pointer. */
/******************************************************************/
void
_asn1_remove_node (node_asn * node)
MHD__asn1_remove_node (node_asn * node)
{
if (node == NULL)
return;
if (node->name != NULL)
_asn1_free (node->name);
MHD__asn1_free (node->name);
if (node->value != NULL)
_asn1_free (node->value);
_asn1_free (node);
MHD__asn1_free (node->value);
MHD__asn1_free (node);
}
/******************************************************************/
/* Function : _asn1_find_up */
/* Function : MHD__asn1_find_up */
/* Description: return the father of the NODE_ASN element. */
/* Parameters: */
/* node: NODE_ASN element pointer. */
/* Return: Null if not found. */
/******************************************************************/
node_asn *
_asn1_find_up (node_asn * node)
MHD__asn1_find_up (node_asn * node)
{
node_asn *p;
@@ -430,12 +430,12 @@ _asn1_find_up (node_asn * node)
}
/******************************************************************/
/* Function : _asn1_delete_list */
/* Function : MHD__asn1_delete_list */
/* Description: deletes the list elements (not the elements */
/* pointed by them). */
/******************************************************************/
void
_asn1_delete_list (void)
MHD__asn1_delete_list (void)
{
list_type *listElement;
@@ -443,17 +443,17 @@ _asn1_delete_list (void)
{
listElement = firstElement;
firstElement = firstElement->next;
_asn1_free (listElement);
MHD__asn1_free (listElement);
}
}
/******************************************************************/
/* Function : _asn1_delete_list_and nodes */
/* Function : MHD__asn1_delete_list_and nodes */
/* Description: deletes the list elements and the elements */
/* pointed by them. */
/******************************************************************/
void
_asn1_delete_list_and_nodes (void)
MHD__asn1_delete_list_and_nodes (void)
{
list_type *listElement;
@@ -461,14 +461,14 @@ _asn1_delete_list_and_nodes (void)
{
listElement = firstElement;
firstElement = firstElement->next;
_asn1_remove_node (listElement->node);
_asn1_free (listElement);
MHD__asn1_remove_node (listElement->node);
MHD__asn1_free (listElement);
}
}
char *
_asn1_ltostr (long v, char *str)
MHD__asn1_ltostr (long v, char *str)
{
long d, r;
char temp[20];
@@ -502,7 +502,7 @@ _asn1_ltostr (long v, char *str)
/******************************************************************/
/* Function : _asn1_change_integer_value */
/* Function : MHD__asn1_change_integer_value */
/* Description: converts into DER coding the value assign to an */
/* INTEGER constant. */
/* Parameters: */
@@ -511,8 +511,8 @@ _asn1_ltostr (long v, char *str)
/* ASN1_ELEMENT_NOT_FOUND if NODE is NULL, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
asn1_retCode
_asn1_change_integer_value (ASN1_TYPE node)
MHD__asn1_retCode
MHD__asn1_change_integer_value (ASN1_TYPE node)
{
node_asn *p;
unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
@@ -529,9 +529,9 @@ _asn1_change_integer_value (ASN1_TYPE node)
{
if (p->value)
{
_asn1_convert_integer (p->value, val, sizeof (val), &len);
asn1_octet_der (val, len, val2, &len);
_asn1_set_value (p, val2, len);
MHD__asn1_convert_integer (p->value, val, sizeof (val), &len);
MHD__asn1_octet_der (val, len, val2, &len);
MHD__asn1_set_value (p, val2, len);
}
}
@@ -549,7 +549,7 @@ _asn1_change_integer_value (ASN1_TYPE node)
{
while (1)
{
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
if (p == node)
{
p = NULL;
@@ -570,7 +570,7 @@ _asn1_change_integer_value (ASN1_TYPE node)
/******************************************************************/
/* Function : _asn1_expand_object_id */
/* Function : MHD__asn1_expand_object_id */
/* Description: expand the IDs of an OBJECT IDENTIFIER constant. */
/* Parameters: */
/* node: root of an ASN1 element. */
@@ -578,8 +578,8 @@ _asn1_change_integer_value (ASN1_TYPE node)
/* ASN1_ELEMENT_NOT_FOUND if NODE is NULL, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
asn1_retCode
_asn1_expand_object_id (ASN1_TYPE node)
MHD__asn1_retCode
MHD__asn1_expand_object_id (ASN1_TYPE node)
{
node_asn *p, *p2, *p3, *p4, *p5;
char name_root[MAX_NAME_SIZE], name2[2 * MAX_NAME_SIZE + 1];
@@ -588,7 +588,7 @@ _asn1_expand_object_id (ASN1_TYPE node)
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
_asn1_str_cpy (name_root, sizeof (name_root), node->name);
MHD__asn1_str_cpy (name_root, sizeof (name_root), node->name);
p = node;
move = DOWN;
@@ -605,35 +605,35 @@ _asn1_expand_object_id (ASN1_TYPE node)
{
if (p2->value && !isdigit (p2->value[0]))
{
_asn1_str_cpy (name2, sizeof (name2), name_root);
_asn1_str_cat (name2, sizeof (name2), ".");
_asn1_str_cat (name2, sizeof (name2), p2->value);
p3 = asn1_find_node (node, name2);
MHD__asn1_str_cpy (name2, sizeof (name2), name_root);
MHD__asn1_str_cat (name2, sizeof (name2), ".");
MHD__asn1_str_cat (name2, sizeof (name2), p2->value);
p3 = MHD__asn1_find_node (node, name2);
if (!p3 || (type_field (p3->type) != TYPE_OBJECT_ID) ||
!(p3->type & CONST_ASSIGN))
return ASN1_ELEMENT_NOT_FOUND;
_asn1_set_down (p, p2->right);
_asn1_remove_node (p2);
MHD__asn1_set_down (p, p2->right);
MHD__asn1_remove_node (p2);
p2 = p;
p4 = p3->down;
while (p4)
{
if (type_field (p4->type) == TYPE_CONSTANT)
{
p5 = _asn1_add_node_only (TYPE_CONSTANT);
_asn1_set_name (p5, p4->name);
p5 = MHD__asn1_add_node_only (TYPE_CONSTANT);
MHD__asn1_set_name (p5, p4->name);
tlen = strlen (p4->value);
if (tlen > 0)
_asn1_set_value (p5, p4->value, tlen + 1);
MHD__asn1_set_value (p5, p4->value, tlen + 1);
if (p2 == p)
{
_asn1_set_right (p5, p->down);
_asn1_set_down (p, p5);
MHD__asn1_set_right (p5, p->down);
MHD__asn1_set_down (p, p5);
}
else
{
_asn1_set_right (p5, p2->right);
_asn1_set_right (p2, p5);
MHD__asn1_set_right (p5, p2->right);
MHD__asn1_set_right (p2, p5);
}
p2 = p5;
}
@@ -671,7 +671,7 @@ _asn1_expand_object_id (ASN1_TYPE node)
move = UP;
}
if (move == UP)
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
@@ -691,10 +691,10 @@ _asn1_expand_object_id (ASN1_TYPE node)
p2 = p->down;
if (p2 && (type_field (p2->type) == TYPE_DEFAULT))
{
_asn1_str_cpy (name2, sizeof (name2), name_root);
_asn1_str_cat (name2, sizeof (name2), ".");
_asn1_str_cat (name2, sizeof (name2), p2->value);
p3 = asn1_find_node (node, name2);
MHD__asn1_str_cpy (name2, sizeof (name2), name_root);
MHD__asn1_str_cat (name2, sizeof (name2), ".");
MHD__asn1_str_cat (name2, sizeof (name2), p2->value);
p3 = MHD__asn1_find_node (node, name2);
if (!p3 || (type_field (p3->type) != TYPE_OBJECT_ID) ||
!(p3->type & CONST_ASSIGN))
return ASN1_ELEMENT_NOT_FOUND;
@@ -705,14 +705,14 @@ _asn1_expand_object_id (ASN1_TYPE node)
if (type_field (p4->type) == TYPE_CONSTANT)
{
if (name2[0])
_asn1_str_cat (name2, sizeof (name2), ".");
_asn1_str_cat (name2, sizeof (name2), p4->value);
MHD__asn1_str_cat (name2, sizeof (name2), ".");
MHD__asn1_str_cat (name2, sizeof (name2), p4->value);
}
p4 = p4->right;
}
tlen = strlen (name2);
if (tlen > 0)
_asn1_set_value (p2, name2, tlen + 1);
MHD__asn1_set_value (p2, name2, tlen + 1);
}
}
move = DOWN;
@@ -742,7 +742,7 @@ _asn1_expand_object_id (ASN1_TYPE node)
move = UP;
}
if (move == UP)
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
return ASN1_SUCCESS;
@@ -750,7 +750,7 @@ _asn1_expand_object_id (ASN1_TYPE node)
/******************************************************************/
/* Function : _asn1_type_set_config */
/* Function : MHD__asn1_type_set_config */
/* Description: sets the CONST_SET and CONST_NOT_USED properties */
/* in the fields of the SET elements. */
/* Parameters: */
@@ -759,8 +759,8 @@ _asn1_expand_object_id (ASN1_TYPE node)
/* ASN1_ELEMENT_NOT_FOUND if NODE is NULL, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
asn1_retCode
_asn1_type_set_config (ASN1_TYPE node)
MHD__asn1_retCode
MHD__asn1_type_set_config (ASN1_TYPE node)
{
node_asn *p, *p2;
int move;
@@ -812,7 +812,7 @@ _asn1_type_set_config (ASN1_TYPE node)
move = UP;
}
if (move == UP)
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
return ASN1_SUCCESS;
@@ -820,10 +820,10 @@ _asn1_type_set_config (ASN1_TYPE node)
/******************************************************************/
/* Function : _asn1_check_identifier */
/* Function : MHD__asn1_check_identifier */
/* Description: checks the definitions of all the identifiers */
/* and the first element of an OBJECT_ID (e.g. {pkix 0 4}). */
/* The _asn1_identifierMissing global variable is filled if */
/* The MHD__asn1_identifierMissing global variable is filled if */
/* necessary. */
/* Parameters: */
/* node: root of an ASN1 element. */
@@ -832,8 +832,8 @@ _asn1_type_set_config (ASN1_TYPE node)
/* ASN1_IDENTIFIER_NOT_FOUND if an identifier is not defined, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
asn1_retCode
_asn1_check_identifier (ASN1_TYPE node)
MHD__asn1_retCode
MHD__asn1_check_identifier (ASN1_TYPE node)
{
node_asn *p, *p2;
char name2[MAX_NAME_SIZE * 2 + 2];
@@ -846,13 +846,13 @@ _asn1_check_identifier (ASN1_TYPE node)
{
if (type_field (p->type) == TYPE_IDENTIFIER)
{
_asn1_str_cpy (name2, sizeof (name2), node->name);
_asn1_str_cat (name2, sizeof (name2), ".");
_asn1_str_cat (name2, sizeof (name2), p->value);
p2 = asn1_find_node (node, name2);
MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
MHD__asn1_str_cat (name2, sizeof (name2), ".");
MHD__asn1_str_cat (name2, sizeof (name2), p->value);
p2 = MHD__asn1_find_node (node, name2);
if (p2 == NULL)
{
strcpy (_asn1_identifierMissing, p->value);
strcpy (MHD__asn1_identifierMissing, p->value);
return ASN1_IDENTIFIER_NOT_FOUND;
}
}
@@ -862,16 +862,16 @@ _asn1_check_identifier (ASN1_TYPE node)
p2 = p->down;
if (p2 && (type_field (p2->type) == TYPE_DEFAULT))
{
_asn1_str_cpy (name2, sizeof (name2), node->name);
_asn1_str_cat (name2, sizeof (name2), ".");
_asn1_str_cat (name2, sizeof (name2), p2->value);
strcpy (_asn1_identifierMissing, p2->value);
p2 = asn1_find_node (node, name2);
MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
MHD__asn1_str_cat (name2, sizeof (name2), ".");
MHD__asn1_str_cat (name2, sizeof (name2), p2->value);
strcpy (MHD__asn1_identifierMissing, p2->value);
p2 = MHD__asn1_find_node (node, name2);
if (!p2 || (type_field (p2->type) != TYPE_OBJECT_ID) ||
!(p2->type & CONST_ASSIGN))
return ASN1_IDENTIFIER_NOT_FOUND;
else
_asn1_identifierMissing[0] = 0;
MHD__asn1_identifierMissing[0] = 0;
}
}
else if ((type_field (p->type) == TYPE_OBJECT_ID) &&
@@ -882,16 +882,16 @@ _asn1_check_identifier (ASN1_TYPE node)
{
if (p2->value && !isdigit (p2->value[0]))
{
_asn1_str_cpy (name2, sizeof (name2), node->name);
_asn1_str_cat (name2, sizeof (name2), ".");
_asn1_str_cat (name2, sizeof (name2), p2->value);
strcpy (_asn1_identifierMissing, p2->value);
p2 = asn1_find_node (node, name2);
MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
MHD__asn1_str_cat (name2, sizeof (name2), ".");
MHD__asn1_str_cat (name2, sizeof (name2), p2->value);
strcpy (MHD__asn1_identifierMissing, p2->value);
p2 = MHD__asn1_find_node (node, name2);
if (!p2 || (type_field (p2->type) != TYPE_OBJECT_ID) ||
!(p2->type & CONST_ASSIGN))
return ASN1_IDENTIFIER_NOT_FOUND;
else
_asn1_identifierMissing[0] = 0;
MHD__asn1_identifierMissing[0] = 0;
}
}
}
@@ -906,7 +906,7 @@ _asn1_check_identifier (ASN1_TYPE node)
{
while (1)
{
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
if (p == node)
{
p = NULL;
@@ -926,7 +926,7 @@ _asn1_check_identifier (ASN1_TYPE node)
/******************************************************************/
/* Function : _asn1_set_default_tag */
/* Function : MHD__asn1_set_default_tag */
/* Description: sets the default IMPLICIT or EXPLICIT property in */
/* the tagged elements that don't have this declaration. */
/* Parameters: */
@@ -936,8 +936,8 @@ _asn1_check_identifier (ASN1_TYPE node)
/* a DEFINITIONS element, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
asn1_retCode
_asn1_set_default_tag (ASN1_TYPE node)
MHD__asn1_retCode
MHD__asn1_set_default_tag (ASN1_TYPE node)
{
node_asn *p;
@@ -966,7 +966,7 @@ _asn1_set_default_tag (ASN1_TYPE node)
{
while (1)
{
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
if (p == node)
{
p = NULL;
@@ -1027,7 +1027,7 @@ parse_version_string (const char *s, int *major, int *minor, int *micro)
}
/**
* asn1_check_version - check for library version
* MHD__asn1_check_version - check for library version
* @req_version: Required version number, or NULL.
*
* Check that the the version of the library is at minimum the
@@ -1041,7 +1041,7 @@ parse_version_string (const char *s, int *major, int *minor, int *micro)
* run-time library does not meet the required version number.
*/
const char *
asn1_check_version (const char *req_version)
MHD__asn1_check_version (const char *req_version)
{
const char *ver = LIBTASN1_VERSION;
int my_major, my_minor, my_micro;
src/daemon/https/minitasn1/parser_aux.h
+20 -20
View File
@@ -6,45 +6,45 @@
/***************************************/
/* Functions used by ASN.1 parser */
/***************************************/
node_asn *_asn1_add_node (unsigned int type);
node_asn *MHD__asn1_add_node (unsigned int type);
node_asn *_asn1_set_value (node_asn * node, const void *value,
node_asn *MHD__asn1_set_value (node_asn * node, const void *value,
unsigned int len);
node_asn *_asn1_set_name (node_asn * node, const char *name);
node_asn *MHD__asn1_set_name (node_asn * node, const char *name);
node_asn *_asn1_set_right (node_asn * node, node_asn * right);
node_asn *MHD__asn1_set_right (node_asn * node, node_asn * right);
node_asn *_asn1_get_right (node_asn * node);
node_asn *MHD__asn1_get_right (node_asn * node);
node_asn *_asn1_get_last_right (node_asn * node);
node_asn *MHD__asn1_get_last_right (node_asn * node);
node_asn *_asn1_set_down (node_asn * node, node_asn * down);
node_asn *MHD__asn1_set_down (node_asn * node, node_asn * down);
char *_asn1_get_name (node_asn * node);
char *MHD__asn1_get_name (node_asn * node);
node_asn *_asn1_get_down (node_asn * node);
node_asn *MHD__asn1_get_down (node_asn * node);
node_asn *_asn1_mod_type (node_asn * node, unsigned int value);
node_asn *MHD__asn1_mod_type (node_asn * node, unsigned int value);
void _asn1_remove_node (node_asn * node);
void MHD__asn1_remove_node (node_asn * node);
void _asn1_delete_list (void);
void MHD__asn1_delete_list (void);
void _asn1_delete_list_and_nodes (void);
void MHD__asn1_delete_list_and_nodes (void);
char *_asn1_ltostr (long v, char *str);
char *MHD__asn1_ltostr (long v, char *str);
node_asn *_asn1_find_up (node_asn * node);
node_asn *MHD__asn1_find_up (node_asn * node);
asn1_retCode _asn1_change_integer_value (ASN1_TYPE node);
MHD__asn1_retCode MHD__asn1_change_integer_value (ASN1_TYPE node);
asn1_retCode _asn1_expand_object_id (ASN1_TYPE node);
MHD__asn1_retCode MHD__asn1_expand_object_id (ASN1_TYPE node);
asn1_retCode _asn1_type_set_config (ASN1_TYPE node);
MHD__asn1_retCode MHD__asn1_type_set_config (ASN1_TYPE node);
asn1_retCode _asn1_check_identifier (ASN1_TYPE node);
MHD__asn1_retCode MHD__asn1_check_identifier (ASN1_TYPE node);
asn1_retCode _asn1_set_default_tag (ASN1_TYPE node);
MHD__asn1_retCode MHD__asn1_set_default_tag (ASN1_TYPE node);
#endif
src/daemon/https/minitasn1/structure.c
+121 -121
View File
@@ -35,11 +35,11 @@
#include <gstr.h>
extern char _asn1_identifierMissing[];
extern char MHD__asn1_identifierMissing[];
/******************************************************/
/* Function : _asn1_add_node_only */
/* Function : MHD__asn1_add_node_only */
/* Description: creates a new NODE_ASN element. */
/* Parameters: */
/* type: type of the new element (see TYPE_ */
@@ -47,11 +47,11 @@ extern char _asn1_identifierMissing[];
/* Return: pointer to the new element. */
/******************************************************/
node_asn *
_asn1_add_node_only (unsigned int type)
MHD__asn1_add_node_only (unsigned int type)
{
node_asn *punt;
punt = (node_asn *) _asn1_calloc (1, sizeof (node_asn));
punt = (node_asn *) MHD__asn1_calloc (1, sizeof (node_asn));
if (punt == NULL)
return NULL;
@@ -62,7 +62,7 @@ _asn1_add_node_only (unsigned int type)
/******************************************************************/
/* Function : _asn1_find_left */
/* Function : MHD__asn1_find_left */
/* Description: returns the NODE_ASN element with RIGHT field that*/
/* points the element NODE. */
/* Parameters: */
@@ -70,7 +70,7 @@ _asn1_add_node_only (unsigned int type)
/* Return: NULL if not found. */
/******************************************************************/
node_asn *
_asn1_find_left (node_asn * node)
MHD__asn1_find_left (node_asn * node)
{
if ((node == NULL) || (node->left == NULL) || (node->left->down == node))
return NULL;
@@ -79,8 +79,8 @@ _asn1_find_left (node_asn * node)
}
asn1_retCode
_asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
MHD__asn1_retCode
MHD__asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
char *vector_name)
{
FILE *file;
@@ -136,7 +136,7 @@ _asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
{
while (1)
{
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
if (p == pointer)
{
p = NULL;
@@ -160,14 +160,14 @@ _asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
/**
* asn1_array2tree - Creates the structures needed to manage the ASN1 definitions.
* MHD__asn1_array2tree - Creates the structures needed to manage the ASN1 definitions.
* @array: specify the array that contains ASN.1 declarations
* @definitions: return the pointer to the structure created by
* *ARRAY ASN.1 declarations
* @errorDescription: return the error description.
*
* Creates the structures needed to manage the ASN.1 definitions.
* @array is a vector created by asn1_parser2array().
* @array is a vector created by MHD__asn1_parser2array().
*
* Returns:
*
@@ -180,14 +180,14 @@ _asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
*
* ASN1_ARRAY_ERROR: The array pointed by @array is wrong.
**/
asn1_retCode
asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
MHD__asn1_retCode
MHD__asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
char *errorDescription)
{
node_asn *p, *p_last = NULL;
unsigned long k;
int move;
asn1_retCode result;
MHD__asn1_retCode result;
if (*definitions != ASN1_TYPE_EMPTY)
@@ -198,19 +198,19 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
k = 0;
while (array[k].value || array[k].type || array[k].name)
{
p = _asn1_add_node (array[k].type & (~CONST_DOWN));
p = MHD__asn1_add_node (array[k].type & (~CONST_DOWN));
if (array[k].name)
_asn1_set_name (p, array[k].name);
MHD__asn1_set_name (p, array[k].name);
if (array[k].value)
_asn1_set_value (p, array[k].value, strlen (array[k].value) + 1);
MHD__asn1_set_value (p, array[k].value, strlen (array[k].value) + 1);
if (*definitions == NULL)
*definitions = p;
if (move == DOWN)
_asn1_set_down (p_last, p);
MHD__asn1_set_down (p_last, p);
else if (move == RIGHT)
_asn1_set_right (p_last, p);
MHD__asn1_set_right (p_last, p);
p_last = p;
@@ -225,7 +225,7 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
if (p_last == *definitions)
break;
p_last = _asn1_find_up (p_last);
p_last = MHD__asn1_find_up (p_last);
if (p_last == NULL)
break;
@@ -243,11 +243,11 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
if (p_last == *definitions)
{
result = _asn1_check_identifier (*definitions);
result = MHD__asn1_check_identifier (*definitions);
if (result == ASN1_SUCCESS)
{
_asn1_change_integer_value (*definitions);
_asn1_expand_object_id (*definitions);
MHD__asn1_change_integer_value (*definitions);
MHD__asn1_expand_object_id (*definitions);
}
}
else
@@ -260,7 +260,7 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
if (result == ASN1_IDENTIFIER_NOT_FOUND)
{
Estrcpy (errorDescription, ":: identifier '");
Estrcat (errorDescription, _asn1_identifierMissing);
Estrcat (errorDescription, MHD__asn1_identifierMissing);
Estrcat (errorDescription, "' not found");
}
else
@@ -269,17 +269,17 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
if (result != ASN1_SUCCESS)
{
_asn1_delete_list_and_nodes ();
MHD__asn1_delete_list_and_nodes ();
*definitions = ASN1_TYPE_EMPTY;
}
else
_asn1_delete_list ();
MHD__asn1_delete_list ();
return result;
}
/**
* asn1_delete_structure - Deletes the structure pointed by *ROOT.
* MHD__asn1_delete_structure - Deletes the structure pointed by *ROOT.
* @structure: pointer to the structure that you want to delete.
*
* Deletes the structure *@structure. At the end, *@structure is set
@@ -292,8 +292,8 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
* ASN1_ELEMENT_NOT_FOUND: *@structure was ASN1_TYPE_EMPTY.
*
**/
asn1_retCode
asn1_delete_structure (ASN1_TYPE * structure)
MHD__asn1_retCode
MHD__asn1_delete_structure (ASN1_TYPE * structure)
{
node_asn *p, *p2, *p3;
@@ -312,19 +312,19 @@ asn1_delete_structure (ASN1_TYPE * structure)
p2 = p->right;
if (p != *structure)
{
p3 = _asn1_find_up (p);
_asn1_set_down (p3, p2);
_asn1_remove_node (p);
p3 = MHD__asn1_find_up (p);
MHD__asn1_set_down (p3, p2);
MHD__asn1_remove_node (p);
p = p3;
}
else
{ /* p==root */
p3 = _asn1_find_left (p);
p3 = MHD__asn1_find_left (p);
if (!p3)
{
p3 = _asn1_find_up (p);
p3 = MHD__asn1_find_up (p);
if (p3)
_asn1_set_down (p3, p2);
MHD__asn1_set_down (p3, p2);
else
{
if (p->right)
@@ -332,8 +332,8 @@ asn1_delete_structure (ASN1_TYPE * structure)
}
}
else
_asn1_set_right (p3, p2);
_asn1_remove_node (p);
MHD__asn1_set_right (p3, p2);
MHD__asn1_remove_node (p);
p = NULL;
}
}
@@ -346,7 +346,7 @@ asn1_delete_structure (ASN1_TYPE * structure)
/**
* asn1_delete_element - Deletes the element of a structure.
* MHD__asn1_delete_element - Deletes the element of a structure.
* @structure: pointer to the structure that contains the element you
* want to delete.
* @element_name: element's name you want to delete.
@@ -360,34 +360,34 @@ asn1_delete_structure (ASN1_TYPE * structure)
* ASN1_ELEMENT_NOT_FOUND: The name element was not found.
*
**/
asn1_retCode
asn1_delete_element (ASN1_TYPE structure, const char *element_name)
MHD__asn1_retCode
MHD__asn1_delete_element (ASN1_TYPE structure, const char *element_name)
{
node_asn *p2, *p3, *source_node;
source_node = asn1_find_node (structure, element_name);
source_node = MHD__asn1_find_node (structure, element_name);
if (source_node == ASN1_TYPE_EMPTY)
return ASN1_ELEMENT_NOT_FOUND;
p2 = source_node->right;
p3 = _asn1_find_left (source_node);
p3 = MHD__asn1_find_left (source_node);
if (!p3)
{
p3 = _asn1_find_up (source_node);
p3 = MHD__asn1_find_up (source_node);
if (p3)
_asn1_set_down (p3, p2);
MHD__asn1_set_down (p3, p2);
else if (source_node->right)
source_node->right->left = NULL;
}
else
_asn1_set_right (p3, p2);
MHD__asn1_set_right (p3, p2);
return asn1_delete_structure (&source_node);
return MHD__asn1_delete_structure (&source_node);
}
node_asn *
_asn1_copy_structure3 (node_asn * source_node)
MHD__asn1_copy_structure3 (node_asn * source_node)
{
node_asn *dest_node, *p_s, *p_d, *p_d_prev;
int move;
@@ -395,7 +395,7 @@ _asn1_copy_structure3 (node_asn * source_node)
if (source_node == NULL)
return NULL;
dest_node = _asn1_add_node_only (source_node->type);
dest_node = MHD__asn1_add_node_only (source_node->type);
p_s = source_node;
p_d = dest_node;
@@ -407,9 +407,9 @@ _asn1_copy_structure3 (node_asn * source_node)
if (move != UP)
{
if (p_s->name)
_asn1_set_name (p_d, p_s->name);
MHD__asn1_set_name (p_d, p_s->name);
if (p_s->value)
_asn1_set_value (p_d, p_s->value, p_s->value_len);
MHD__asn1_set_value (p_d, p_s->value, p_s->value_len);
move = DOWN;
}
else
@@ -421,8 +421,8 @@ _asn1_copy_structure3 (node_asn * source_node)
{
p_s = p_s->down;
p_d_prev = p_d;
p_d = _asn1_add_node_only (p_s->type);
_asn1_set_down (p_d_prev, p_d);
p_d = MHD__asn1_add_node_only (p_s->type);
MHD__asn1_set_down (p_d_prev, p_d);
}
else
move = RIGHT;
@@ -437,16 +437,16 @@ _asn1_copy_structure3 (node_asn * source_node)
{
p_s = p_s->right;
p_d_prev = p_d;
p_d = _asn1_add_node_only (p_s->type);
_asn1_set_right (p_d_prev, p_d);
p_d = MHD__asn1_add_node_only (p_s->type);
MHD__asn1_set_right (p_d_prev, p_d);
}
else
move = UP;
}
if (move == UP)
{
p_s = _asn1_find_up (p_s);
p_d = _asn1_find_up (p_d);
p_s = MHD__asn1_find_up (p_s);
p_d = MHD__asn1_find_up (p_d);
}
}
while (p_s != source_node);
@@ -456,19 +456,19 @@ _asn1_copy_structure3 (node_asn * source_node)
node_asn *
_asn1_copy_structure2 (node_asn * root, const char *source_name)
MHD__asn1_copy_structure2 (node_asn * root, const char *source_name)
{
node_asn *source_node;
source_node = asn1_find_node (root, source_name);
source_node = MHD__asn1_find_node (root, source_name);
return _asn1_copy_structure3 (source_node);
return MHD__asn1_copy_structure3 (source_node);
}
asn1_retCode
_asn1_type_choice_config (node_asn * node)
MHD__asn1_retCode
MHD__asn1_type_choice_config (node_asn * node)
{
node_asn *p, *p2, *p3, *p4;
int move, tlen;
@@ -491,19 +491,19 @@ _asn1_type_choice_config (node_asn * node)
if (type_field (p2->type) != TYPE_TAG)
{
p2->type |= CONST_TAG;
p3 = _asn1_find_left (p2);
p3 = MHD__asn1_find_left (p2);
while (p3)
{
if (type_field (p3->type) == TYPE_TAG)
{
p4 = _asn1_add_node_only (p3->type);
p4 = MHD__asn1_add_node_only (p3->type);
tlen = strlen (p3->value);
if (tlen > 0)
_asn1_set_value (p4, p3->value, tlen + 1);
_asn1_set_right (p4, p2->down);
_asn1_set_down (p2, p4);
MHD__asn1_set_value (p4, p3->value, tlen + 1);
MHD__asn1_set_right (p4, p2->down);
MHD__asn1_set_down (p2, p4);
}
p3 = _asn1_find_left (p3);
p3 = MHD__asn1_find_left (p3);
}
}
p2 = p2->right;
@@ -514,7 +514,7 @@ _asn1_type_choice_config (node_asn * node)
{
p3 = p2->right;
if (type_field (p2->type) == TYPE_TAG)
asn1_delete_structure (&p2);
MHD__asn1_delete_structure (&p2);
p2 = p3;
}
}
@@ -545,15 +545,15 @@ _asn1_type_choice_config (node_asn * node)
move = UP;
}
if (move == UP)
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
return ASN1_SUCCESS;
}
asn1_retCode
_asn1_expand_identifier (node_asn ** node, node_asn * root)
MHD__asn1_retCode
MHD__asn1_expand_identifier (node_asn ** node, node_asn * root)
{
node_asn *p, *p2, *p3;
char name2[MAX_NAME_SIZE + 2];
@@ -571,15 +571,15 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
{
if (type_field (p->type) == TYPE_IDENTIFIER)
{
_asn1_str_cpy (name2, sizeof (name2), root->name);
_asn1_str_cat (name2, sizeof (name2), ".");
_asn1_str_cat (name2, sizeof (name2), p->value);
p2 = _asn1_copy_structure2 (root, name2);
MHD__asn1_str_cpy (name2, sizeof (name2), root->name);
MHD__asn1_str_cat (name2, sizeof (name2), ".");
MHD__asn1_str_cat (name2, sizeof (name2), p->value);
p2 = MHD__asn1_copy_structure2 (root, name2);
if (p2 == NULL)
{
return ASN1_IDENTIFIER_NOT_FOUND;
}
_asn1_set_name (p2, p->name);
MHD__asn1_set_name (p2, p->name);
p2->right = p->right;
p2->left = p->left;
if (p->right)
@@ -589,18 +589,18 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
{
while (p3->right)
p3 = p3->right;
_asn1_set_right (p3, p2->down);
_asn1_set_down (p2, p->down);
MHD__asn1_set_right (p3, p2->down);
MHD__asn1_set_down (p2, p->down);
}
p3 = _asn1_find_left (p);
p3 = MHD__asn1_find_left (p);
if (p3)
_asn1_set_right (p3, p2);
MHD__asn1_set_right (p3, p2);
else
{
p3 = _asn1_find_up (p);
p3 = MHD__asn1_find_up (p);
if (p3)
_asn1_set_down (p3, p2);
MHD__asn1_set_down (p3, p2);
else
{
p2->left = NULL;
@@ -622,7 +622,7 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
if (p == *node)
*node = p2;
_asn1_remove_node (p);
MHD__asn1_remove_node (p);
p = p2;
move = DOWN;
continue;
@@ -654,7 +654,7 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
move = UP;
}
if (move == UP)
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
}
return ASN1_SUCCESS;
@@ -662,7 +662,7 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
/**
* asn1_create_element - Creates a structure of type SOURCE_NAME.
* MHD__asn1_create_element - Creates a structure of type SOURCE_NAME.
* @definitions: pointer to the structure returned by "parser_asn1" function
* @source_name: the name of the type of the new structure (must be
* inside p_structure).
@@ -671,7 +671,7 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
* Creates a structure of type @source_name. Example using
* "pkix.asn":
*
* rc = asn1_create_structure(cert_def, "PKIX1.Certificate",
* rc = MHD__asn1_create_structure(cert_def, "PKIX1.Certificate",
* certptr);
*
* Returns:
@@ -680,22 +680,22 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
*
* ASN1_ELEMENT_NOT_FOUND: SOURCE_NAME isn't known
**/
asn1_retCode
asn1_create_element (ASN1_TYPE definitions, const char *source_name,
MHD__asn1_retCode
MHD__asn1_create_element (ASN1_TYPE definitions, const char *source_name,
ASN1_TYPE * element)
{
node_asn *dest_node;
int res;
dest_node = _asn1_copy_structure2 (definitions, source_name);
dest_node = MHD__asn1_copy_structure2 (definitions, source_name);
if (dest_node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
_asn1_set_name (dest_node, "");
MHD__asn1_set_name (dest_node, "");
res = _asn1_expand_identifier (&dest_node, definitions);
_asn1_type_choice_config (dest_node);
res = MHD__asn1_expand_identifier (&dest_node, definitions);
MHD__asn1_type_choice_config (dest_node);
*element = dest_node;
@@ -704,7 +704,7 @@ asn1_create_element (ASN1_TYPE definitions, const char *source_name,
/**
* asn1_print_structure - Prints on the standard output the structure's tree
* MHD__asn1_print_structure - Prints on the standard output the structure's tree
* @out: pointer to the output file (e.g. stdout).
* @structure: pointer to the structure that you want to visit.
* @name: an element of the structure
@@ -716,7 +716,7 @@ asn1_create_element (ASN1_TYPE definitions, const char *source_name,
* from the @name element inside the structure @structure.
**/
void
asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
MHD__asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
int mode)
{
node_asn *p, *root;
@@ -725,7 +725,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
if (out == NULL)
return;
root = asn1_find_node (structure, name);
root = MHD__asn1_find_node (structure, name);
if (root == NULL)
return;
@@ -872,7 +872,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
if (p->value)
{
len2 = -1;
len = asn1_get_length_der (p->value, p->value_len, &len2);
len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
fprintf (out, " value:0x");
if (len > 0)
for (k = 0; k < len; k++)
@@ -883,7 +883,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
if (p->value)
{
len2 = -1;
len = asn1_get_length_der (p->value, p->value_len, &len2);
len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
fprintf (out, " value:0x");
if (len > 0)
for (k = 0; k < len; k++)
@@ -907,7 +907,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
if (p->value)
{
len2 = -1;
len = asn1_get_length_der (p->value, p->value_len, &len2);
len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
if (len > 0)
{
fprintf (out, " value(%i):",
@@ -921,7 +921,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
if (p->value)
{
len2 = -1;
len = asn1_get_length_der (p->value, p->value_len, &len2);
len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
fprintf (out, " value:");
if (len > 0)
for (k = 0; k < len; k++)
@@ -932,7 +932,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
if (p->value)
{
len2 = -1;
len = asn1_get_length_der (p->value, p->value_len, &len2);
len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
fprintf (out, " value:");
if (len > 0)
for (k = 0; k < len; k++)
@@ -947,7 +947,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
if (p->value)
{
len3 = -1;
len2 = asn1_get_length_der (p->value, p->value_len, &len3);
len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
fprintf (out, " value:");
if (len2 > 0)
for (k = 0; k < len2; k++)
@@ -1048,7 +1048,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
{
while (1)
{
p = _asn1_find_up (p);
p = MHD__asn1_find_up (p);
if (p == root)
{
p = NULL;
@@ -1068,7 +1068,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
/**
* asn1_number_of_elements - Counts the number of elements of a structure.
* MHD__asn1_number_of_elements - Counts the number of elements of a structure.
* @element: pointer to the root of an ASN1 structure.
* @name: the name of a sub-structure of ROOT.
* @num: pointer to an integer where the result will be stored
@@ -1085,8 +1085,8 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
* ASN1_GENERIC_ERROR: Pointer num equal to NULL.
*
**/
asn1_retCode
asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
MHD__asn1_retCode
MHD__asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
{
node_asn *node, *p;
@@ -1095,7 +1095,7 @@ asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
*num = 0;
node = asn1_find_node (element, name);
node = MHD__asn1_find_node (element, name);
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
@@ -1113,7 +1113,7 @@ asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
/**
* asn1_find_structure_from_oid - Locate structure defined by a specific OID.
* MHD__asn1_find_structure_from_oid - Locate structure defined by a specific OID.
* @definitions: ASN1 definitions
* @oidValue: value of the OID to search (e.g. "1.2.3.4").
*
@@ -1125,13 +1125,13 @@ asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
*
**/
const char *
asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
MHD__asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
{
char definitionsName[MAX_NAME_SIZE], name[2 * MAX_NAME_SIZE + 1];
char value[MAX_NAME_SIZE];
ASN1_TYPE p;
int len;
asn1_retCode result;
MHD__asn1_retCode result;
if ((definitions == ASN1_TYPE_EMPTY) || (oidValue == NULL))
return NULL; /* ASN1_ELEMENT_NOT_FOUND; */
@@ -1151,7 +1151,7 @@ asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
strcat (name, p->name);
len = MAX_NAME_SIZE;
result = asn1_read_value (definitions, name, value, &len);
result = MHD__asn1_read_value (definitions, name, value, &len);
if ((result == ASN1_SUCCESS) && (!strcmp (oidValue, value)))
{
@@ -1169,7 +1169,7 @@ asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
}
/**
* asn1_copy_node:
* MHD__asn1_copy_node:
* @dst: Destination ASN1_TYPE node.
* @dst_name: Field name in destination node.
* @src: Source ASN1_TYPE node.
@@ -1179,8 +1179,8 @@ asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
*
* Return value: Return ASN1_SUCCESS on success.
**/
asn1_retCode
asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
MHD__asn1_retCode
MHD__asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
ASN1_TYPE src, const char *src_name)
{
/* FIXME: rewrite using copy_structure().
@@ -1191,31 +1191,31 @@ asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
void *data = NULL;
int size = 0;
result = asn1_der_coding (src, src_name, NULL, &size, NULL);
result = MHD__asn1_der_coding (src, src_name, NULL, &size, NULL);
if (result != ASN1_MEM_ERROR)
return result;
data = _asn1_malloc (size);
data = MHD__asn1_malloc (size);
if (data == NULL)
return ASN1_MEM_ERROR;
result = asn1_der_coding (src, src_name, data, &size, NULL);
result = MHD__asn1_der_coding (src, src_name, data, &size, NULL);
if (result != ASN1_SUCCESS)
{
_asn1_free (data);
MHD__asn1_free (data);
return result;
}
dst_node = asn1_find_node (dst, dst_name);
dst_node = MHD__asn1_find_node (dst, dst_name);
if (dst_node == NULL)
{
_asn1_free (data);
MHD__asn1_free (data);
return ASN1_ELEMENT_NOT_FOUND;
}
result = asn1_der_decoding (&dst_node, data, size, NULL);
result = MHD__asn1_der_decoding (&dst_node, data, size, NULL);
_asn1_free (data);
MHD__asn1_free (data);
return result;
}
src/daemon/https/minitasn1/structure.h
+5 -5
View File
@@ -8,16 +8,16 @@
#ifndef _STRUCTURE_H
#define _STRUCTURE_H
asn1_retCode _asn1_create_static_structure (node_asn * pointer,
MHD__asn1_retCode MHD__asn1_create_static_structure (node_asn * pointer,
char *output_file_name,
char *vector_name);
node_asn *_asn1_copy_structure3 (node_asn * source_node);
node_asn *MHD__asn1_copy_structure3 (node_asn * source_node);
node_asn *_asn1_copy_structure2 (node_asn * root, const char *source_name);
node_asn *MHD__asn1_copy_structure2 (node_asn * root, const char *source_name);
node_asn *_asn1_add_node_only (unsigned int type);
node_asn *MHD__asn1_add_node_only (unsigned int type);
node_asn *_asn1_find_left (node_asn * node);
node_asn *MHD__asn1_find_left (node_asn * node);
#endif
src/daemon/https/tls/auth_anon.c
+38 -38
View File
@@ -40,52 +40,52 @@
#include <gnutls_state.h>
#include <auth_dh_common.h>
static int mhd_gtls_gen_anon_server_kx (mhd_gtls_session_t, opaque **);
static int mhd_gtls_proc_anon_client_kx (mhd_gtls_session_t, opaque *,
static int MHD_gtls_gen_anon_server_kx (MHD_gtls_session_t, opaque **);
static int MHD_gtls_proc_anon_client_kx (MHD_gtls_session_t, opaque *,
size_t);
static int mhd_gtls_proc_anon_server_kx (mhd_gtls_session_t, opaque *,
static int MHD_gtls_proc_anon_server_kx (MHD_gtls_session_t, opaque *,
size_t);
const mhd_gtls_mod_auth_st mhd_gtls_anon_auth_struct = {
const MHD_gtls_mod_auth_st MHD_gtls_anon_auth_struct = {
"ANON",
NULL,
NULL,
mhd_gtls_gen_anon_server_kx,
mhd_gtls_gen_dh_common_client_kx, /* this can be shared */
MHD_gtls_gen_anon_server_kx,
MHD_gtls_gen_dh_common_client_kx, /* this can be shared */
NULL,
NULL,
NULL,
NULL, /* certificate */
mhd_gtls_proc_anon_server_kx,
mhd_gtls_proc_anon_client_kx,
MHD_gtls_proc_anon_server_kx,
MHD_gtls_proc_anon_client_kx,
NULL,
NULL
};
static int
mhd_gtls_gen_anon_server_kx (mhd_gtls_session_t session, opaque ** data)
MHD_gtls_gen_anon_server_kx (MHD_gtls_session_t session, opaque ** data)
{
mpi_t g, p;
const mpi_t *mpis;
int ret;
mhd_gtls_dh_params_t dh_params;
mhd_gtls_anon_server_credentials_t cred;
MHD_gtls_dh_params_t dh_params;
MHD_gtls_anon_server_credentials_t cred;
cred = (mhd_gtls_anon_server_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
cred = (MHD_gtls_anon_server_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
dh_params =
mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = mhd_gtls_dh_params_to_mpi (dh_params);
MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = MHD_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
}
@@ -93,19 +93,19 @@ mhd_gtls_gen_anon_server_kx (mhd_gtls_session_t session, opaque ** data)
g = mpis[1];
if ((ret =
mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
sizeof (anon_auth_info_st), 1)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
mhd_gtls_dh_set_group (session, g, p);
MHD_gtls_dh_set_group (session, g, p);
ret = mhd_gtls_dh_common_print_server_kx (session, g, p, data, 0);
ret = MHD_gtls_dh_common_print_server_kx (session, g, p, data, 0);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
}
return ret;
@@ -113,46 +113,46 @@ mhd_gtls_gen_anon_server_kx (mhd_gtls_session_t session, opaque ** data)
static int
mhd_gtls_proc_anon_client_kx (mhd_gtls_session_t session, opaque * data,
MHD_gtls_proc_anon_client_kx (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
mhd_gtls_anon_server_credentials_t cred;
MHD_gtls_anon_server_credentials_t cred;
int bits;
int ret;
mpi_t p, g;
mhd_gtls_dh_params_t dh_params;
MHD_gtls_dh_params_t dh_params;
const mpi_t *mpis;
bits = mhd_gtls_dh_get_allowed_prime_bits (session);
bits = MHD_gtls_dh_get_allowed_prime_bits (session);
cred = (mhd_gtls_anon_server_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
cred = (MHD_gtls_anon_server_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
dh_params =
mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = mhd_gtls_dh_params_to_mpi (dh_params);
MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = MHD_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
}
p = mpis[0];
g = mpis[1];
ret = mhd_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
ret = MHD_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
return ret;
}
int
mhd_gtls_proc_anon_server_kx (mhd_gtls_session_t session, opaque * data,
MHD_gtls_proc_anon_server_kx (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
@@ -160,17 +160,17 @@ mhd_gtls_proc_anon_server_kx (mhd_gtls_session_t session, opaque * data,
/* set auth_info */
if ((ret =
mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
sizeof (anon_auth_info_st), 1)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret = mhd_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
ret = MHD_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
src/daemon/https/tls/auth_anon.h
+8 -8
View File
@@ -22,27 +22,27 @@
*
*/
/* this is not to be included by gnutls_anon.c */
/* this is not to be included by MHD_gnutls_anon.c */
#include <gnutls_auth.h>
#include <auth_dh_common.h>
typedef struct mhd_gtls_anon_server_credentials_st
typedef struct MHD_gtls_anon_server_credentials_st
{
mhd_gtls_dh_params_t dh_params;
MHD_gtls_dh_params_t dh_params;
/* this callback is used to retrieve the DH or RSA
* parameters.
*/
gnutls_params_function *params_func;
MHD_gnutls_params_function *params_func;
} mhd_anon_server_credentials_st;
typedef struct mhd_gtls_anon_client_credentials_st
typedef struct MHD_gtls_anon_client_credentials_st
{
int dummy;
} mhd_anon_client_credentials_st;
typedef struct mhd_gtls_anon_auth_info_st
typedef struct MHD_gtls_anon_auth_info_st
{
mhd_gtls_dh_info_st dh;
MHD_gtls_dh_info_st dh;
} *mhd_anon_auth_info_t;
typedef struct mhd_gtls_anon_auth_info_st anon_auth_info_st;
typedef struct MHD_gtls_anon_auth_info_st anon_auth_info_st;
src/daemon/https/tls/auth_cert.c
+204 -204
View File
@@ -45,17 +45,17 @@
#include <gnutls_x509.h>
#include "debug.h"
static gnutls_cert *alloc_and_load_x509_certs (gnutls_x509_crt_t * certs,
static MHD_gnutls_cert *alloc_and_load_x509_certs (MHD_gnutls_x509_crt_t * certs,
unsigned);
static gnutls_privkey *alloc_and_load_x509_key (gnutls_x509_privkey_t key);
static MHD_gnutls_privkey *alloc_and_load_x509_key (MHD_gnutls_x509_privkey_t key);
/* Copies data from a internal certificate struct (gnutls_cert) to
/* Copies data from a internal certificate struct (MHD_gnutls_cert) to
* exported certificate struct (cert_auth_info_t)
*/
static int
_gnutls_copy_certificate_auth_info (cert_auth_info_t info,
gnutls_cert * cert, int ncerts)
MHD__gnutls_copy_certificate_auth_info (cert_auth_info_t info,
MHD_gnutls_cert * cert, int ncerts)
{
/* Copy peer's information to auth_info_t
*/
@@ -69,10 +69,10 @@ _gnutls_copy_certificate_auth_info (cert_auth_info_t info,
}
info->raw_certificate_list =
gnutls_calloc (1, sizeof (gnutls_datum_t) * ncerts);
MHD_gnutls_calloc (1, sizeof (MHD_gnutls_datum_t) * ncerts);
if (info->raw_certificate_list == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -81,11 +81,11 @@ _gnutls_copy_certificate_auth_info (cert_auth_info_t info,
if (cert->raw.size > 0)
{
ret =
_gnutls_set_datum (&info->raw_certificate_list[i],
MHD__gnutls_set_datum (&info->raw_certificate_list[i],
cert[i].raw.data, cert[i].raw.size);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
goto clear;
}
}
@@ -97,9 +97,9 @@ _gnutls_copy_certificate_auth_info (cert_auth_info_t info,
clear:
for (j = 0; j < i; j++)
_gnutls_free_datum (&info->raw_certificate_list[j]);
MHD__gnutls_free_datum (&info->raw_certificate_list[j]);
gnutls_free (info->raw_certificate_list);
MHD_gnutls_free (info->raw_certificate_list);
info->raw_certificate_list = NULL;
return ret;
@@ -112,7 +112,7 @@ clear:
* -1 otherwise.
*/
inline static int
_gnutls_check_pk_algo_in_list (const enum MHD_GNUTLS_PublicKeyAlgorithm
MHD__gnutls_check_pk_algo_in_list (const enum MHD_GNUTLS_PublicKeyAlgorithm
*pk_algos, int pk_algos_length,
enum MHD_GNUTLS_PublicKeyAlgorithm
algo_to_check)
@@ -133,39 +133,39 @@ _gnutls_check_pk_algo_in_list (const enum MHD_GNUTLS_PublicKeyAlgorithm
* specified in cert.
*/
static int
_gnutls_cert_get_issuer_dn (gnutls_cert * cert, gnutls_datum_t * odn)
MHD__gnutls_cert_get_issuer_dn (MHD_gnutls_cert * cert, MHD_gnutls_datum_t * odn)
{
ASN1_TYPE dn;
int len, result;
int start, end;
if ((result = asn1_create_element
(_gnutls_get_pkix (), "PKIX1.Certificate", &dn)) != ASN1_SUCCESS)
if ((result = MHD__asn1_create_element
(MHD__gnutls_get_pkix (), "PKIX1.Certificate", &dn)) != ASN1_SUCCESS)
{
gnutls_assert ();
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
return MHD_gtls_asn2err (result);
}
result = asn1_der_decoding (&dn, cert->raw.data, cert->raw.size, NULL);
result = MHD__asn1_der_decoding (&dn, cert->raw.data, cert->raw.size, NULL);
if (result != ASN1_SUCCESS)
{
/* couldn't decode DER */
gnutls_assert ();
asn1_delete_structure (&dn);
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
MHD__asn1_delete_structure (&dn);
return MHD_gtls_asn2err (result);
}
result = asn1_der_decoding_startEnd (dn, cert->raw.data, cert->raw.size,
result = MHD__asn1_der_decoding_startEnd (dn, cert->raw.data, cert->raw.size,
"tbsCertificate.issuer", &start, &end);
if (result != ASN1_SUCCESS)
{
/* couldn't decode DER */
gnutls_assert ();
asn1_delete_structure (&dn);
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
MHD__asn1_delete_structure (&dn);
return MHD_gtls_asn2err (result);
}
asn1_delete_structure (&dn);
MHD__asn1_delete_structure (&dn);
len = end - start + 1;
@@ -183,13 +183,13 @@ _gnutls_cert_get_issuer_dn (gnutls_cert * cert, gnutls_datum_t * odn)
* CAs and sign algorithms supported by the peer server.
*/
static int
_find_x509_cert (const mhd_gtls_cert_credentials_t cred,
_find_x509_cert (const MHD_gtls_cert_credentials_t cred,
opaque * _data, size_t _data_size,
const enum MHD_GNUTLS_PublicKeyAlgorithm *pk_algos,
int pk_algos_length, int *indx)
{
unsigned size;
gnutls_datum_t odn;
MHD_gnutls_datum_t odn;
opaque *data = _data;
ssize_t data_size = _data_size;
unsigned i, j;
@@ -201,7 +201,7 @@ _find_x509_cert (const mhd_gtls_cert_credentials_t cred,
{
DECR_LENGTH_RET (data_size, 2, 0);
size = mhd_gtls_read_uint16 (data);
size = MHD_gtls_read_uint16 (data);
DECR_LENGTH_RET (data_size, size, 0);
data += 2;
@@ -210,10 +210,10 @@ _find_x509_cert (const mhd_gtls_cert_credentials_t cred,
for (j = 0; j < cred->cert_list_length[i]; j++)
{
if ((result =
_gnutls_cert_get_issuer_dn (&cred->cert_list[i][j],
MHD__gnutls_cert_get_issuer_dn (&cred->cert_list[i][j],
&odn)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return result;
}
@@ -227,7 +227,7 @@ _find_x509_cert (const mhd_gtls_cert_credentials_t cred,
cert_pk = cred->cert_list[i][0].subject_pk_algorithm;
if ((memcmp (odn.data, data, size) == 0) &&
(_gnutls_check_pk_algo_in_list
(MHD__gnutls_check_pk_algo_in_list
(pk_algos, pk_algos_length, cert_pk) == 0))
{
*indx = i;
@@ -255,7 +255,7 @@ _find_x509_cert (const mhd_gtls_cert_credentials_t cred,
* certificate request packet.
*/
static int
get_issuers_num (mhd_gtls_session_t session, opaque * data, ssize_t data_size)
get_issuers_num (MHD_gtls_session_t session, opaque * data, ssize_t data_size)
{
int issuers_dn_len = 0, result;
unsigned size;
@@ -275,7 +275,7 @@ get_issuers_num (mhd_gtls_session_t session, opaque * data, ssize_t data_size)
*/
result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
DECR_LENGTH_COM (data_size, 2, goto error);
size = mhd_gtls_read_uint16 (data);
size = MHD_gtls_read_uint16 (data);
result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
DECR_LENGTH_COM (data_size, size, goto error);
@@ -304,14 +304,14 @@ error:
* packet.
*/
static int
get_issuers (mhd_gtls_session_t session,
gnutls_datum_t * issuers_dn, int issuers_len,
get_issuers (MHD_gtls_session_t session,
MHD_gnutls_datum_t * issuers_dn, int issuers_len,
opaque * data, size_t data_size)
{
int i;
unsigned size;
if (gnutls_certificate_type_get (session) != MHD_GNUTLS_CRT_X509)
if (MHD_gnutls_certificate_type_get (session) != MHD_GNUTLS_CRT_X509)
return 0;
/* put the requested DNs to req_dn, only in case
@@ -328,7 +328,7 @@ get_issuers (mhd_gtls_session_t session,
*/
data_size -= 2;
size = mhd_gtls_read_uint16 (data);
size = MHD_gtls_read_uint16 (data);
data += 2;
@@ -345,26 +345,26 @@ get_issuers (mhd_gtls_session_t session,
/* Calls the client get callback.
*/
static int
call_get_cert_callback (mhd_gtls_session_t session,
gnutls_datum_t * issuers_dn,
call_get_cert_callback (MHD_gtls_session_t session,
MHD_gnutls_datum_t * issuers_dn,
int issuers_dn_length,
enum MHD_GNUTLS_PublicKeyAlgorithm *pk_algos,
int pk_algos_length)
{
unsigned i;
gnutls_cert *local_certs = NULL;
gnutls_privkey *local_key = NULL;
gnutls_retr_st st;
MHD_gnutls_cert *local_certs = NULL;
MHD_gnutls_privkey *local_key = NULL;
MHD_gnutls_retr_st st;
int ret;
enum MHD_GNUTLS_CertificateType type =
gnutls_certificate_type_get (session);
mhd_gtls_cert_credentials_t cred;
MHD_gnutls_certificate_type_get (session);
MHD_gtls_cert_credentials_t cred;
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
@@ -384,7 +384,7 @@ call_get_cert_callback (mhd_gtls_session_t session,
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -393,7 +393,7 @@ call_get_cert_callback (mhd_gtls_session_t session,
if (type != st.type)
{
gnutls_assert ();
MHD_gnutls_assert ();
ret = GNUTLS_E_INVALID_REQUEST;
goto cleanup;
}
@@ -407,12 +407,12 @@ call_get_cert_callback (mhd_gtls_session_t session,
}
else
{ /* PGP */
gnutls_assert ();
MHD_gnutls_assert ();
ret = GNUTLS_E_INVALID_REQUEST;
goto cleanup;
}
mhd_gtls_selected_certs_set (session, local_certs,
MHD_gtls_selected_certs_set (session, local_certs,
(local_certs != NULL) ? st.ncerts : 0,
local_key, 1);
@@ -426,10 +426,10 @@ cleanup:
{
for (i = 0; i < st.ncerts; i++)
{
gnutls_x509_crt_deinit (st.cert.x509[i]);
MHD_gnutls_x509_crt_deinit (st.cert.x509[i]);
}
gnutls_free (st.cert.x509);
gnutls_x509_privkey_deinit (st.key.x509);
MHD_gnutls_free (st.cert.x509);
MHD_gnutls_x509_privkey_deinit (st.key.x509);
}
}
return ret;
@@ -443,24 +443,24 @@ cleanup:
* algorithm (only in automatic mode).
*/
static int
_select_client_cert (mhd_gtls_session_t session,
_select_client_cert (MHD_gtls_session_t session,
opaque * _data, size_t _data_size,
enum MHD_GNUTLS_PublicKeyAlgorithm *pk_algos,
int pk_algos_length)
{
int result;
int indx = -1;
mhd_gtls_cert_credentials_t cred;
MHD_gtls_cert_credentials_t cred;
opaque *data = _data;
ssize_t data_size = _data_size;
int issuers_dn_length;
gnutls_datum_t *issuers_dn = NULL;
MHD_gnutls_datum_t *issuers_dn = NULL;
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
@@ -476,17 +476,17 @@ _select_client_cert (mhd_gtls_session_t session,
issuers_dn_length = get_issuers_num (session, data, data_size);
if (issuers_dn_length < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return issuers_dn_length;
}
if (issuers_dn_length > 0)
{
issuers_dn =
gnutls_malloc (sizeof (gnutls_datum_t) * issuers_dn_length);
MHD_gnutls_malloc (sizeof (MHD_gnutls_datum_t) * issuers_dn_length);
if (issuers_dn == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -495,7 +495,7 @@ _select_client_cert (mhd_gtls_session_t session,
data, data_size);
if (result < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
goto cleanup;
}
}
@@ -519,27 +519,27 @@ _select_client_cert (mhd_gtls_session_t session,
pk_algos, pk_algos_length, &indx);
if (result < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return result;
}
if (indx >= 0)
{
mhd_gtls_selected_certs_set (session,
MHD_gtls_selected_certs_set (session,
&cred->cert_list[indx][0],
cred->cert_list_length[indx],
&cred->pkey[indx], 0);
}
else
{
mhd_gtls_selected_certs_set (session, NULL, 0, NULL, 0);
MHD_gtls_selected_certs_set (session, NULL, 0, NULL, 0);
}
result = 0;
}
cleanup:
gnutls_free (issuers_dn);
MHD_gnutls_free (issuers_dn);
return result;
}
@@ -548,21 +548,21 @@ cleanup:
*/
int
mhd_gtls_gen_x509_crt (mhd_gtls_session_t session, opaque ** data)
MHD_gtls_gen_x509_crt (MHD_gtls_session_t session, opaque ** data)
{
int ret, i;
opaque *pdata;
gnutls_cert *apr_cert_list;
gnutls_privkey *apr_pkey;
MHD_gnutls_cert *apr_cert_list;
MHD_gnutls_privkey *apr_pkey;
int apr_cert_list_length;
/* find the appropriate certificate
*/
if ((ret =
mhd_gtls_get_selected_cert (session, &apr_cert_list,
MHD_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -583,19 +583,19 @@ mhd_gtls_gen_x509_crt (mhd_gtls_session_t session, opaque ** data)
* the one produced here )
*/
(*data) = gnutls_malloc (ret);
(*data) = MHD_gnutls_malloc (ret);
pdata = (*data);
if (pdata == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
mhd_gtls_write_uint24 (ret - 3, pdata);
MHD_gtls_write_uint24 (ret - 3, pdata);
pdata += 3;
for (i = 0; i < apr_cert_list_length; i++)
{
mhd_gtls_write_datum24 (pdata, apr_cert_list[i].raw);
MHD_gtls_write_datum24 (pdata, apr_cert_list[i].raw);
pdata += (3 + apr_cert_list[i].raw.size);
}
@@ -603,30 +603,30 @@ mhd_gtls_gen_x509_crt (mhd_gtls_session_t session, opaque ** data)
}
int
mhd_gtls_gen_cert_client_certificate (mhd_gtls_session_t session,
MHD_gtls_gen_cert_client_certificate (MHD_gtls_session_t session,
opaque ** data)
{
switch (session->security_parameters.cert_type)
{
case MHD_GNUTLS_CRT_X509:
return mhd_gtls_gen_x509_crt (session, data);
return MHD_gtls_gen_x509_crt (session, data);
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
}
int
mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t session,
MHD_gtls_gen_cert_server_certificate (MHD_gtls_session_t session,
opaque ** data)
{
switch (session->security_parameters.cert_type)
{
case MHD_GNUTLS_CRT_X509:
return mhd_gtls_gen_x509_crt (session, data);
return MHD_gtls_gen_x509_crt (session, data);
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
}
@@ -634,49 +634,49 @@ mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t session,
/* Process server certificate
*/
#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) mhd_gtls_gcert_deinit(&peer_certificate_list[x])
#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) MHD_gtls_gcert_deinit(&peer_certificate_list[x])
int
mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
MHD_gtls_proc_x509_server_certificate (MHD_gtls_session_t session,
opaque * data, size_t data_size)
{
int size, len, ret;
opaque *p = data;
cert_auth_info_t info;
mhd_gtls_cert_credentials_t cred;
MHD_gtls_cert_credentials_t cred;
ssize_t dsize = data_size;
int i, j, x;
gnutls_cert *peer_certificate_list;
MHD_gnutls_cert *peer_certificate_list;
int peer_certificate_list_size = 0;
gnutls_datum_t tmp;
MHD_gnutls_datum_t tmp;
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
if ((ret =
mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 1)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
info = mhd_gtls_get_auth_info (session);
info = MHD_gtls_get_auth_info (session);
if (data == NULL || data_size == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* no certificate was sent */
return GNUTLS_E_NO_CERTIFICATE_FOUND;
}
DECR_LEN (dsize, 3);
size = mhd_gtls_read_uint24 (p);
size = MHD_gtls_read_uint24 (p);
p += 3;
/* some implementations send 0B 00 00 06 00 00 03 00 00 00
@@ -684,7 +684,7 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
*/
if (size == 0 || size == 3)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* no certificate was sent */
return GNUTLS_E_NO_CERTIFICATE_FOUND;
}
@@ -693,7 +693,7 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
while (i > 0)
{
DECR_LEN (dsize, 3);
len = mhd_gtls_read_uint24 (p);
len = MHD_gtls_read_uint24 (p);
p += 3;
DECR_LEN (dsize, len);
peer_certificate_list_size++;
@@ -703,7 +703,7 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
if (peer_certificate_list_size == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_CERTIFICATE_FOUND;
}
@@ -712,14 +712,14 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
*/
peer_certificate_list =
gnutls_malloc (sizeof (gnutls_cert) * (peer_certificate_list_size));
MHD_gnutls_malloc (sizeof (MHD_gnutls_cert) * (peer_certificate_list_size));
if (peer_certificate_list == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
memset (peer_certificate_list, 0, sizeof (gnutls_cert) *
memset (peer_certificate_list, 0, sizeof (MHD_gnutls_cert) *
peer_certificate_list_size);
p = data + 3;
@@ -731,18 +731,18 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
for (j = 0; j < peer_certificate_list_size; j++)
{
len = mhd_gtls_read_uint24 (p);
len = MHD_gtls_read_uint24 (p);
p += 3;
tmp.size = len;
tmp.data = p;
if ((ret =
mhd_gtls_x509_raw_cert_to_gcert (&peer_certificate_list
MHD_gtls_x509_raw_cert_to_gcert (&peer_certificate_list
[j], &tmp,
CERT_ONLY_EXTENSIONS)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
goto cleanup;
}
@@ -751,19 +751,19 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
if ((ret =
_gnutls_copy_certificate_auth_info (info,
MHD__gnutls_copy_certificate_auth_info (info,
peer_certificate_list,
peer_certificate_list_size)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
goto cleanup;
}
if ((ret =
_gnutls_check_key_usage (&peer_certificate_list[0],
gnutls_kx_get (session))) < 0)
MHD__gnutls_check_key_usage (&peer_certificate_list[0],
MHD_gnutls_kx_get (session))) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
goto cleanup;
}
@@ -771,23 +771,23 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
cleanup:
CLEAR_CERTS;
gnutls_free (peer_certificate_list);
MHD_gnutls_free (peer_certificate_list);
return ret;
}
#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) mhd_gtls_gcert_deinit(&peer_certificate_list[x])
#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) MHD_gtls_gcert_deinit(&peer_certificate_list[x])
int
mhd_gtls_proc_cert_server_certificate (mhd_gtls_session_t session,
MHD_gtls_proc_cert_server_certificate (MHD_gtls_session_t session,
opaque * data, size_t data_size)
{
switch (session->security_parameters.cert_type)
{
case MHD_GNUTLS_CRT_X509:
return mhd_gtls_proc_x509_server_certificate (session, data, data_size);
return MHD_gtls_proc_x509_server_certificate (session, data, data_size);
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
}
@@ -802,7 +802,7 @@ typedef enum CertificateSigType
* if true;
*/
inline static int
_gnutls_check_supported_sign_algo (CertificateSigType algo)
MHD__gnutls_check_supported_sign_algo (CertificateSigType algo)
{
switch (algo)
{
@@ -814,31 +814,31 @@ _gnutls_check_supported_sign_algo (CertificateSigType algo)
}
int
mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
MHD_gtls_proc_cert_cert_req (MHD_gtls_session_t session, opaque * data,
size_t data_size)
{
int size, ret;
opaque *p;
mhd_gtls_cert_credentials_t cred;
MHD_gtls_cert_credentials_t cred;
ssize_t dsize;
int i, j;
enum MHD_GNUTLS_PublicKeyAlgorithm pk_algos[MAX_SIGN_ALGOS];
int pk_algos_length;
enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
if ((ret =
mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 0)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -854,7 +854,7 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
for (i = 0; i < size; i++, p++)
{
DECR_LEN (dsize, 1);
if ((ret = _gnutls_check_supported_sign_algo (*p)) > 0)
if ((ret = MHD__gnutls_check_supported_sign_algo (*p)) > 0)
{
if (j < MAX_SIGN_ALGOS)
{
@@ -866,7 +866,7 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
if (pk_algos_length == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
}
@@ -885,7 +885,7 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
/* read the certificate authorities */
DECR_LEN (dsize, 2);
size = mhd_gtls_read_uint16 (p);
size = MHD_gtls_read_uint16 (p);
p += 2;
DECR_LEN (dsize, size);
@@ -896,7 +896,7 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
if ((ret =
_select_client_cert (session, p, size, pk_algos, pk_algos_length)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -909,34 +909,34 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
}
int
mhd_gtls_gen_cert_client_cert_vrfy (mhd_gtls_session_t session,
MHD_gtls_gen_cert_client_cert_vrfy (MHD_gtls_session_t session,
opaque ** data)
{
int ret;
gnutls_cert *apr_cert_list;
gnutls_privkey *apr_pkey;
MHD_gnutls_cert *apr_cert_list;
MHD_gnutls_privkey *apr_pkey;
int apr_cert_list_length, size;
gnutls_datum_t signature;
MHD_gnutls_datum_t signature;
*data = NULL;
/* find the appropriate certificate */
if ((ret =
mhd_gtls_get_selected_cert (session, &apr_cert_list,
MHD_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if (apr_cert_list_length > 0)
{
if ((ret =
mhd_gtls_tls_sign_hdata (session,
MHD_gtls_tls_sign_hdata (session,
&apr_cert_list[0],
apr_pkey, &signature)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
@@ -945,42 +945,42 @@ mhd_gtls_gen_cert_client_cert_vrfy (mhd_gtls_session_t session,
return 0;
}
*data = gnutls_malloc (signature.size + 2);
*data = MHD_gnutls_malloc (signature.size + 2);
if (*data == NULL)
{
_gnutls_free_datum (&signature);
MHD__gnutls_free_datum (&signature);
return GNUTLS_E_MEMORY_ERROR;
}
size = signature.size;
mhd_gtls_write_uint16 (size, *data);
MHD_gtls_write_uint16 (size, *data);
memcpy (&(*data)[2], signature.data, size);
_gnutls_free_datum (&signature);
MHD__gnutls_free_datum (&signature);
return size + 2;
}
int
mhd_gtls_proc_cert_client_cert_vrfy (mhd_gtls_session_t session,
MHD_gtls_proc_cert_client_cert_vrfy (MHD_gtls_session_t session,
opaque * data, size_t data_size)
{
int size, ret;
ssize_t dsize = data_size;
opaque *pdata = data;
gnutls_datum_t sig;
cert_auth_info_t info = mhd_gtls_get_auth_info (session);
gnutls_cert peer_cert;
MHD_gnutls_datum_t sig;
cert_auth_info_t info = MHD_gtls_get_auth_info (session);
MHD_gnutls_cert peer_cert;
if (info == NULL || info->ncerts == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* we need this in order to get peer's certificate */
return GNUTLS_E_INTERNAL_ERROR;
}
DECR_LEN (dsize, 2);
size = mhd_gtls_read_uint16 (pdata);
size = MHD_gtls_read_uint16 (pdata);
pdata += 2;
DECR_LEN (dsize, size);
@@ -988,47 +988,47 @@ mhd_gtls_proc_cert_client_cert_vrfy (mhd_gtls_session_t session,
sig.data = pdata;
sig.size = size;
ret = mhd_gtls_raw_cert_to_gcert (&peer_cert,
ret = MHD_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if ((ret = mhd_gtls_verify_sig_hdata (session, &peer_cert, &sig)) < 0)
if ((ret = MHD_gtls_verify_sig_hdata (session, &peer_cert, &sig)) < 0)
{
gnutls_assert ();
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gnutls_assert ();
MHD_gtls_gcert_deinit (&peer_cert);
return ret;
}
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gtls_gcert_deinit (&peer_cert);
return 0;
}
#define CERTTYPE_SIZE 3
int
mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
MHD_gtls_gen_cert_server_cert_req (MHD_gtls_session_t session, opaque ** data)
{
mhd_gtls_cert_credentials_t cred;
MHD_gtls_cert_credentials_t cred;
int size;
opaque *pdata;
enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
/* Now we need to generate the RDN sequence. This is
* already in the CERTIFICATE_CRED structure, to improve
* performance.
*/
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
@@ -1044,12 +1044,12 @@ mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
functions (see below). */
size += 1;
(*data) = gnutls_malloc (size);
(*data) = MHD_gnutls_malloc (size);
pdata = (*data);
if (pdata == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -1069,12 +1069,12 @@ mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_X509 &&
session->internals.ignore_rdn_sequence == 0)
{
mhd_gtls_write_datum16 (pdata, cred->x509_rdn_sequence);
MHD_gtls_write_datum16 (pdata, cred->x509_rdn_sequence);
/* pdata += cred->x509_rdn_sequence.size + 2; */
}
else
{
mhd_gtls_write_uint16 (0, pdata);
MHD_gtls_write_uint16 (0, pdata);
/* pdata+=2; */
}
@@ -1090,10 +1090,10 @@ mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
*
*/
int
mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
gnutls_cert ** apr_cert_list,
MHD_gtls_get_selected_cert (MHD_gtls_session_t session,
MHD_gnutls_cert ** apr_cert_list,
int *apr_cert_list_length,
gnutls_privkey ** apr_pkey)
MHD_gnutls_privkey ** apr_pkey)
{
if (session->security_parameters.entity == GNUTLS_SERVER)
{
@@ -1107,7 +1107,7 @@ mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
if (*apr_cert_list_length == 0 || *apr_cert_list == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
@@ -1128,70 +1128,70 @@ mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
return 0;
}
/* converts the given x509 certificate to gnutls_cert* and allocates
/* converts the given x509 certificate to MHD_gnutls_cert* and allocates
* space for them.
*/
static gnutls_cert *
alloc_and_load_x509_certs (gnutls_x509_crt_t * certs, unsigned ncerts)
static MHD_gnutls_cert *
alloc_and_load_x509_certs (MHD_gnutls_x509_crt_t * certs, unsigned ncerts)
{
gnutls_cert *local_certs;
MHD_gnutls_cert *local_certs;
int ret = 0;
unsigned i, j;
if (certs == NULL)
return NULL;
local_certs = gnutls_malloc (sizeof (gnutls_cert) * ncerts);
local_certs = MHD_gnutls_malloc (sizeof (MHD_gnutls_cert) * ncerts);
if (local_certs == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return NULL;
}
for (i = 0; i < ncerts; i++)
{
ret = mhd_gtls_x509_crt_to_gcert (&local_certs[i], certs[i], 0);
ret = MHD_gtls_x509_crt_to_gcert (&local_certs[i], certs[i], 0);
if (ret < 0)
break;
}
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
for (j = 0; j < i; j++)
{
mhd_gtls_gcert_deinit (&local_certs[j]);
MHD_gtls_gcert_deinit (&local_certs[j]);
}
gnutls_free (local_certs);
MHD_gnutls_free (local_certs);
return NULL;
}
return local_certs;
}
/* converts the given x509 key to gnutls_privkey* and allocates
/* converts the given x509 key to MHD_gnutls_privkey* and allocates
* space for it.
*/
static gnutls_privkey *
alloc_and_load_x509_key (gnutls_x509_privkey_t key)
static MHD_gnutls_privkey *
alloc_and_load_x509_key (MHD_gnutls_x509_privkey_t key)
{
gnutls_privkey *local_key;
MHD_gnutls_privkey *local_key;
int ret = 0;
if (key == NULL)
return NULL;
local_key = gnutls_malloc (sizeof (gnutls_privkey));
local_key = MHD_gnutls_malloc (sizeof (MHD_gnutls_privkey));
if (local_key == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return NULL;
}
ret = _gnutls_x509_privkey_to_gkey (local_key, key);
ret = MHD__gnutls_x509_privkey_to_gkey (local_key, key);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return NULL;
}
@@ -1199,7 +1199,7 @@ alloc_and_load_x509_key (gnutls_x509_privkey_t key)
}
void
mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session)
MHD_gtls_selected_certs_deinit (MHD_gtls_session_t session)
{
if (session->internals.selected_need_free != 0)
{
@@ -1207,16 +1207,16 @@ mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session)
for (i = 0; i < session->internals.selected_cert_list_length; i++)
{
mhd_gtls_gcert_deinit (&session->internals.selected_cert_list[i]);
MHD_gtls_gcert_deinit (&session->internals.selected_cert_list[i]);
}
gnutls_free (session->internals.selected_cert_list);
MHD_gnutls_free (session->internals.selected_cert_list);
session->internals.selected_cert_list = NULL;
session->internals.selected_cert_list_length = 0;
mhd_gtls_gkey_deinit (session->internals.selected_key);
MHD_gtls_gkey_deinit (session->internals.selected_key);
if (session->internals.selected_key)
{
gnutls_free (session->internals.selected_key);
MHD_gnutls_free (session->internals.selected_key);
session->internals.selected_key = NULL;
}
}
@@ -1225,11 +1225,11 @@ mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session)
}
void
mhd_gtls_selected_certs_set (mhd_gtls_session_t session,
gnutls_cert * certs, int ncerts,
gnutls_privkey * key, int need_free)
MHD_gtls_selected_certs_set (MHD_gtls_session_t session,
MHD_gnutls_cert * certs, int ncerts,
MHD_gnutls_privkey * key, int need_free)
{
mhd_gtls_selected_certs_deinit (session);
MHD_gtls_selected_certs_deinit (session);
session->internals.selected_cert_list = certs;
session->internals.selected_cert_list_length = ncerts;
@@ -1250,19 +1250,19 @@ mhd_gtls_selected_certs_set (mhd_gtls_session_t session,
*
*/
int
mhd_gtls_server_select_cert (mhd_gtls_session_t session,
MHD_gtls_server_select_cert (MHD_gtls_session_t session,
enum MHD_GNUTLS_PublicKeyAlgorithm
requested_algo)
{
unsigned i;
int idx, ret;
mhd_gtls_cert_credentials_t cred;
MHD_gtls_cert_credentials_t cred;
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
@@ -1301,7 +1301,7 @@ mhd_gtls_server_select_cert (mhd_gtls_session_t session,
*/
if (idx >= 0 && ret == 0)
{
mhd_gtls_selected_certs_set (session,
MHD_gtls_selected_certs_set (session,
&cred->cert_list[idx][0],
cred->cert_list_length[idx],
&cred->pkey[idx], 0);
@@ -1313,11 +1313,11 @@ mhd_gtls_server_select_cert (mhd_gtls_session_t session,
return ret;
}
/* Frees the mhd_gtls_rsa_info_st structure.
/* Frees the MHD_gtls_rsa_info_st structure.
*/
void
mhd_gtls_free_rsa_info (rsa_info_st * rsa)
MHD_gtls_free_rsa_info (rsa_info_st * rsa)
{
_gnutls_free_datum (&rsa->modulus);
_gnutls_free_datum (&rsa->exponent);
MHD__gnutls_free_datum (&rsa->modulus);
MHD__gnutls_free_datum (&rsa->exponent);
}
src/daemon/https/tls/auth_cert.h
+42 -42
View File
@@ -34,16 +34,16 @@
* support a server that has multiple certificates
*/
typedef struct mhd_gtls_certificate_credentials_st
typedef struct MHD_gtls_certificate_credentials_st
{
mhd_gtls_dh_params_t dh_params;
mhd_gtls_rsa_params_t rsa_params;
MHD_gtls_dh_params_t dh_params;
MHD_gtls_rsa_params_t rsa_params;
/* this callback is used to retrieve the DH or RSA
* parameters.
*/
gnutls_params_function *params_func;
MHD_gnutls_params_function *params_func;
gnutls_cert **cert_list;
MHD_gnutls_cert **cert_list;
/* contains a list of a list of certificates.
* eg (X509): [0] certificate1, certificate11, certificate111
* (if more than one, one certificate certifies the one before)
@@ -57,7 +57,7 @@ typedef struct mhd_gtls_certificate_credentials_st
* This is the same with the number of pkeys.
*/
gnutls_privkey *pkey;
MHD_gnutls_privkey *pkey;
/* private keys. It contains ncerts private
* keys. pkey[i] corresponds to certificate in
* cert_list[i][0].
@@ -66,19 +66,19 @@ typedef struct mhd_gtls_certificate_credentials_st
/* OpenPGP specific stuff */
#ifndef KEYRING_HACK
gnutls_openpgp_keyring_t keyring;
MHD_gnutls_openpgp_keyring_t keyring;
#else
gnutls_datum_t keyring;
MHD_gnutls_datum_t keyring;
int keyring_format;
#endif
/* X509 specific stuff */
gnutls_x509_crt_t *x509_ca_list;
MHD_gnutls_x509_crt_t *x509_ca_list;
unsigned x509_ncas; /* number of CAs in the ca_list
*/
gnutls_x509_crl_t *x509_crl_list;
MHD_gnutls_x509_crl_t *x509_crl_list;
unsigned x509_ncrls; /* number of CRLs in the crl_list
*/
@@ -93,19 +93,19 @@ typedef struct mhd_gtls_certificate_credentials_st
* This is better than
* generating on every handshake.
*/
gnutls_datum_t x509_rdn_sequence;
MHD_gnutls_datum_t x509_rdn_sequence;
gnutls_certificate_client_retrieve_function *client_get_cert_callback;
gnutls_certificate_server_retrieve_function *server_get_cert_callback;
} mhd_gtls_cert_credentials_st;
MHD_gnutls_certificate_client_retrieve_function *client_get_cert_callback;
MHD_gnutls_certificate_server_retrieve_function *server_get_cert_callback;
} MHD_gtls_cert_credentials_st;
typedef struct mhd_gtls_rsa_info_st
typedef struct MHD_gtls_rsa_info_st
{
gnutls_datum_t modulus;
gnutls_datum_t exponent;
MHD_gnutls_datum_t modulus;
MHD_gnutls_datum_t exponent;
} rsa_info_st;
typedef struct mhd_gtls_cert_auth_info_st
typedef struct MHD_gtls_cert_auth_info_st
{
int certificate_requested; /* if the peer requested certificate
* this is non zero;
@@ -114,46 +114,46 @@ typedef struct mhd_gtls_cert_auth_info_st
/* These (dh/rsa) are just copies from the credentials_t structure.
* They must be freed.
*/
mhd_gtls_dh_info_st dh;
MHD_gtls_dh_info_st dh;
rsa_info_st rsa_export;
gnutls_datum_t *raw_certificate_list; /* holds the raw certificate of the
MHD_gnutls_datum_t *raw_certificate_list; /* holds the raw certificate of the
* peer.
*/
unsigned int ncerts; /* holds the size of the list above */
} *cert_auth_info_t;
typedef struct mhd_gtls_cert_auth_info_st cert_auth_info_st;
typedef struct MHD_gtls_cert_auth_info_st cert_auth_info_st;
void mhd_gtls_free_rsa_info (rsa_info_st * rsa);
void MHD_gtls_free_rsa_info (rsa_info_st * rsa);
/* AUTH X509 functions */
int mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t, opaque **);
int mhd_gtls_gen_cert_client_certificate (mhd_gtls_session_t, opaque **);
int mhd_gtls_gen_cert_client_cert_vrfy (mhd_gtls_session_t, opaque **);
int mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t, opaque **);
int mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t, opaque *, size_t);
int mhd_gtls_proc_cert_client_cert_vrfy (mhd_gtls_session_t, opaque *,
int MHD_gtls_gen_cert_server_certificate (MHD_gtls_session_t, opaque **);
int MHD_gtls_gen_cert_client_certificate (MHD_gtls_session_t, opaque **);
int MHD_gtls_gen_cert_client_cert_vrfy (MHD_gtls_session_t, opaque **);
int MHD_gtls_gen_cert_server_cert_req (MHD_gtls_session_t, opaque **);
int MHD_gtls_proc_cert_cert_req (MHD_gtls_session_t, opaque *, size_t);
int MHD_gtls_proc_cert_client_cert_vrfy (MHD_gtls_session_t, opaque *,
size_t);
int mhd_gtls_proc_cert_server_certificate (mhd_gtls_session_t, opaque *,
int MHD_gtls_proc_cert_server_certificate (MHD_gtls_session_t, opaque *,
size_t);
int mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
gnutls_cert ** apr_cert_list,
int MHD_gtls_get_selected_cert (MHD_gtls_session_t session,
MHD_gnutls_cert ** apr_cert_list,
int *apr_cert_list_length,
gnutls_privkey ** apr_pkey);
MHD_gnutls_privkey ** apr_pkey);
int mhd_gtls_server_select_cert (struct MHD_gtls_session_int *,
int MHD_gtls_server_select_cert (struct MHD_gtls_session_int *,
enum MHD_GNUTLS_PublicKeyAlgorithm);
void mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session);
void mhd_gtls_selected_certs_set (mhd_gtls_session_t session,
gnutls_cert * certs, int ncerts,
gnutls_privkey * key, int need_free);
void MHD_gtls_selected_certs_deinit (MHD_gtls_session_t session);
void MHD_gtls_selected_certs_set (MHD_gtls_session_t session,
MHD_gnutls_cert * certs, int ncerts,
MHD_gnutls_privkey * key, int need_free);
#define _gnutls_proc_cert_client_certificate mhd_gtls_proc_cert_server_certificate
#define MHD__gnutls_proc_cert_client_certificate MHD_gtls_proc_cert_server_certificate
mhd_gtls_rsa_params_t
mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
gnutls_params_function * func,
mhd_gtls_session_t);
MHD_gtls_rsa_params_t
MHD_gtls_certificate_get_rsa_params (MHD_gtls_rsa_params_t rsa_params,
MHD_gnutls_params_function * func,
MHD_gtls_session_t);
#endif
src/daemon/https/tls/auth_dh_common.c
+71 -71
View File
@@ -39,19 +39,19 @@
#include <auth_dh_common.h>
#include <gnutls_algorithms.h>
/* Frees the mhd_gtls_dh_info_st structure.
/* Frees the MHD_gtls_dh_info_st structure.
*/
void
mhd_gtls_free_dh_info (mhd_gtls_dh_info_st * dh)
MHD_gtls_free_dh_info (MHD_gtls_dh_info_st * dh)
{
dh->secret_bits = 0;
_gnutls_free_datum (&dh->prime);
_gnutls_free_datum (&dh->generator);
_gnutls_free_datum (&dh->public_key);
MHD__gnutls_free_datum (&dh->prime);
MHD__gnutls_free_datum (&dh->generator);
MHD__gnutls_free_datum (&dh->public_key);
}
int
mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
MHD_gtls_proc_dh_common_client_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size,
mpi_t g, mpi_t p)
{
@@ -62,33 +62,33 @@ mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
DECR_LEN (data_size, 2);
n_Y = mhd_gtls_read_uint16 (&data[0]);
n_Y = MHD_gtls_read_uint16 (&data[0]);
_n_Y = n_Y;
DECR_LEN (data_size, n_Y);
if (mhd_gtls_mpi_scan_nz (&session->key->client_Y, &data[2], &_n_Y))
if (MHD_gtls_mpi_scan_nz (&session->key->client_Y, &data[2], &_n_Y))
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
mhd_gtls_dh_set_peer_public (session, session->key->client_Y);
MHD_gtls_dh_set_peer_public (session, session->key->client_Y);
session->key->KEY =
mhd_gtls_calc_dh_key (session->key->client_Y, session->key->dh_secret, p);
MHD_gtls_calc_dh_key (session->key->client_Y, session->key->dh_secret, p);
if (session->key->KEY == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
mhd_gtls_mpi_release (&session->key->client_Y);
mhd_gtls_mpi_release (&session->key->dh_secret);
MHD_gtls_mpi_release (&session->key->client_Y);
MHD_gtls_mpi_release (&session->key->dh_secret);
ret = mhd_gtls_mpi_dprint (&session->key->key, session->key->KEY);
ret = MHD_gtls_mpi_dprint (&session->key->key, session->key->KEY);
mhd_gtls_mpi_release (&session->key->KEY);
MHD_gtls_mpi_release (&session->key->KEY);
if (ret < 0)
{
@@ -99,7 +99,7 @@ mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
}
int
mhd_gtls_gen_dh_common_client_kx (mhd_gtls_session_t session, opaque ** data)
MHD_gtls_gen_dh_common_client_kx (MHD_gtls_session_t session, opaque ** data)
{
mpi_t x = NULL, X = NULL;
size_t n_X;
@@ -107,69 +107,69 @@ mhd_gtls_gen_dh_common_client_kx (mhd_gtls_session_t session, opaque ** data)
*data = NULL;
X = mhd_gtls_calc_dh_secret (&x, session->key->client_g,
X = MHD_gtls_calc_dh_secret (&x, session->key->client_g,
session->key->client_p);
if (X == NULL || x == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
ret = GNUTLS_E_MEMORY_ERROR;
goto error;
}
mhd_gtls_dh_set_secret_bits (session, _gnutls_mpi_get_nbits (x));
MHD_gtls_dh_set_secret_bits (session, MHD__gnutls_mpi_get_nbits (x));
mhd_gtls_mpi_print (NULL, &n_X, X);
(*data) = gnutls_malloc (n_X + 2);
MHD_gtls_mpi_print (NULL, &n_X, X);
(*data) = MHD_gnutls_malloc (n_X + 2);
if (*data == NULL)
{
ret = GNUTLS_E_MEMORY_ERROR;
goto error;
}
mhd_gtls_mpi_print (&(*data)[2], &n_X, X);
mhd_gtls_mpi_release (&X);
MHD_gtls_mpi_print (&(*data)[2], &n_X, X);
MHD_gtls_mpi_release (&X);
mhd_gtls_write_uint16 (n_X, &(*data)[0]);
MHD_gtls_write_uint16 (n_X, &(*data)[0]);
/* calculate the key after calculating the message */
session->key->KEY =
mhd_gtls_calc_dh_key (session->key->client_Y, x, session->key->client_p);
MHD_gtls_calc_dh_key (session->key->client_Y, x, session->key->client_p);
mhd_gtls_mpi_release (&x);
MHD_gtls_mpi_release (&x);
if (session->key->KEY == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
ret = GNUTLS_E_MEMORY_ERROR;
goto error;
}
/* THESE SHOULD BE DISCARDED */
mhd_gtls_mpi_release (&session->key->client_Y);
mhd_gtls_mpi_release (&session->key->client_p);
mhd_gtls_mpi_release (&session->key->client_g);
MHD_gtls_mpi_release (&session->key->client_Y);
MHD_gtls_mpi_release (&session->key->client_p);
MHD_gtls_mpi_release (&session->key->client_g);
ret = mhd_gtls_mpi_dprint (&session->key->key, session->key->KEY);
ret = MHD_gtls_mpi_dprint (&session->key->key, session->key->KEY);
mhd_gtls_mpi_release (&session->key->KEY);
MHD_gtls_mpi_release (&session->key->KEY);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
goto error;
}
return n_X + 2;
error:
mhd_gtls_mpi_release (&x);
mhd_gtls_mpi_release (&X);
gnutls_free (*data);
MHD_gtls_mpi_release (&x);
MHD_gtls_mpi_release (&X);
MHD_gnutls_free (*data);
*data = NULL;
return ret;
}
int
mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
MHD_gtls_proc_dh_common_server_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size, int psk)
{
uint16_t n_Y, n_g, n_p;
@@ -185,13 +185,13 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
if (psk != 0)
{
DECR_LEN (data_size, 2);
psk_size = mhd_gtls_read_uint16 (&data[i]);
psk_size = MHD_gtls_read_uint16 (&data[i]);
DECR_LEN (data_size, psk_size);
i += 2 + psk_size;
}
DECR_LEN (data_size, 2);
n_p = mhd_gtls_read_uint16 (&data[i]);
n_p = MHD_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_p);
@@ -199,7 +199,7 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
i += n_p;
DECR_LEN (data_size, 2);
n_g = mhd_gtls_read_uint16 (&data[i]);
n_g = MHD_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_g);
@@ -207,7 +207,7 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
i += n_g;
DECR_LEN (data_size, 2);
n_Y = mhd_gtls_read_uint16 (&data[i]);
n_Y = MHD_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_Y);
@@ -218,41 +218,41 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
_n_g = n_g;
_n_p = n_p;
if (mhd_gtls_mpi_scan_nz (&session->key->client_Y, data_Y, &_n_Y) != 0)
if (MHD_gtls_mpi_scan_nz (&session->key->client_Y, data_Y, &_n_Y) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
if (mhd_gtls_mpi_scan_nz (&session->key->client_g, data_g, &_n_g) != 0)
if (MHD_gtls_mpi_scan_nz (&session->key->client_g, data_g, &_n_g) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
if (mhd_gtls_mpi_scan_nz (&session->key->client_p, data_p, &_n_p) != 0)
if (MHD_gtls_mpi_scan_nz (&session->key->client_p, data_p, &_n_p) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
bits = mhd_gtls_dh_get_allowed_prime_bits (session);
bits = MHD_gtls_dh_get_allowed_prime_bits (session);
if (bits < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return bits;
}
if (_gnutls_mpi_get_nbits (session->key->client_p) < (size_t) bits)
if (MHD__gnutls_mpi_get_nbits (session->key->client_p) < (size_t) bits)
{
/* the prime used by the peer is not acceptable
*/
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_DH_PRIME_UNACCEPTABLE;
}
mhd_gtls_dh_set_group (session, session->key->client_g,
MHD_gtls_dh_set_group (session, session->key->client_g,
session->key->client_p);
mhd_gtls_dh_set_peer_public (session, session->key->client_Y);
MHD_gtls_dh_set_peer_public (session, session->key->client_Y);
ret = n_Y + n_p + n_g + 6;
if (psk != 0)
@@ -264,7 +264,7 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
/* If the psk flag is set, then an empty psk_identity_hint will
* be inserted */
int
mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t session,
MHD_gtls_dh_common_print_server_kx (MHD_gtls_session_t session,
mpi_t g, mpi_t p, opaque ** data, int psk)
{
mpi_t x, X;
@@ -272,28 +272,28 @@ mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t session,
int ret, data_size, pos;
uint8_t *pdata;
X = mhd_gtls_calc_dh_secret (&x, g, p);
X = MHD_gtls_calc_dh_secret (&x, g, p);
if (X == NULL || x == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
session->key->dh_secret = x;
mhd_gtls_dh_set_secret_bits (session, _gnutls_mpi_get_nbits (x));
MHD_gtls_dh_set_secret_bits (session, MHD__gnutls_mpi_get_nbits (x));
mhd_gtls_mpi_print (NULL, &n_g, g);
mhd_gtls_mpi_print (NULL, &n_p, p);
mhd_gtls_mpi_print (NULL, &n_X, X);
MHD_gtls_mpi_print (NULL, &n_g, g);
MHD_gtls_mpi_print (NULL, &n_p, p);
MHD_gtls_mpi_print (NULL, &n_X, X);
data_size = n_g + n_p + n_X + 6;
if (psk != 0)
data_size += 2;
(*data) = gnutls_malloc (data_size);
(*data) = MHD_gnutls_malloc (data_size);
if (*data == NULL)
{
mhd_gtls_mpi_release (&X);
MHD_gtls_mpi_release (&X);
return GNUTLS_E_MEMORY_ERROR;
}
@@ -302,24 +302,24 @@ mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t session,
if (psk != 0)
{
mhd_gtls_write_uint16 (0, &pdata[pos]);
MHD_gtls_write_uint16 (0, &pdata[pos]);
pos += 2;
}
mhd_gtls_mpi_print (&pdata[pos + 2], &n_p, p);
mhd_gtls_write_uint16 (n_p, &pdata[pos]);
MHD_gtls_mpi_print (&pdata[pos + 2], &n_p, p);
MHD_gtls_write_uint16 (n_p, &pdata[pos]);
pos += n_p + 2;
mhd_gtls_mpi_print (&pdata[pos + 2], &n_g, g);
mhd_gtls_write_uint16 (n_g, &pdata[pos]);
MHD_gtls_mpi_print (&pdata[pos + 2], &n_g, g);
MHD_gtls_write_uint16 (n_g, &pdata[pos]);
pos += n_g + 2;
mhd_gtls_mpi_print (&pdata[pos + 2], &n_X, X);
mhd_gtls_mpi_release (&X);
MHD_gtls_mpi_print (&pdata[pos + 2], &n_X, X);
MHD_gtls_mpi_release (&X);
mhd_gtls_write_uint16 (n_X, &pdata[pos]);
MHD_gtls_write_uint16 (n_X, &pdata[pos]);
ret = data_size;
src/daemon/https/tls/auth_dh_common.h
+9 -9
View File
@@ -29,19 +29,19 @@ typedef struct
{
int secret_bits;
gnutls_datum_t prime;
gnutls_datum_t generator;
gnutls_datum_t public_key;
} mhd_gtls_dh_info_st;
MHD_gnutls_datum_t prime;
MHD_gnutls_datum_t generator;
MHD_gnutls_datum_t public_key;
} MHD_gtls_dh_info_st;
void mhd_gtls_free_dh_info (mhd_gtls_dh_info_st * dh);
int mhd_gtls_gen_dh_common_client_kx (mhd_gtls_session_t, opaque **);
int mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
void MHD_gtls_free_dh_info (MHD_gtls_dh_info_st * dh);
int MHD_gtls_gen_dh_common_client_kx (MHD_gtls_session_t, opaque **);
int MHD_gtls_proc_dh_common_client_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size,
mpi_t p, mpi_t g);
int mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t, mpi_t g, mpi_t p,
int MHD_gtls_dh_common_print_server_kx (MHD_gtls_session_t, mpi_t g, mpi_t p,
opaque ** data, int psk);
int mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
int MHD_gtls_proc_dh_common_server_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size,
int psk);
src/daemon/https/tls/auth_dhe.c
+75 -75
View File
@@ -39,103 +39,103 @@
#include <gnutls_state.h>
#include <auth_dh_common.h>
static int gen_dhe_server_kx (mhd_gtls_session_t, opaque **);
static int proc_dhe_server_kx (mhd_gtls_session_t, opaque *, size_t);
static int proc_dhe_client_kx (mhd_gtls_session_t, opaque *, size_t);
static int gen_dhe_server_kx (MHD_gtls_session_t, opaque **);
static int proc_dhe_server_kx (MHD_gtls_session_t, opaque *, size_t);
static int proc_dhe_client_kx (MHD_gtls_session_t, opaque *, size_t);
const mhd_gtls_mod_auth_st mhd_gtls_dhe_rsa_auth_struct = {
const MHD_gtls_mod_auth_st MHD_gtls_dhe_rsa_auth_struct = {
"DHE_RSA",
mhd_gtls_gen_cert_server_certificate,
mhd_gtls_gen_cert_client_certificate,
MHD_gtls_gen_cert_server_certificate,
MHD_gtls_gen_cert_client_certificate,
gen_dhe_server_kx,
mhd_gtls_gen_dh_common_client_kx,
mhd_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
mhd_gtls_gen_cert_server_cert_req, /* server cert request */
MHD_gtls_gen_dh_common_client_kx,
MHD_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
MHD_gtls_gen_cert_server_cert_req, /* server cert request */
mhd_gtls_proc_cert_server_certificate,
_gnutls_proc_cert_client_certificate,
MHD_gtls_proc_cert_server_certificate,
MHD__gnutls_proc_cert_client_certificate,
proc_dhe_server_kx,
proc_dhe_client_kx,
mhd_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
mhd_gtls_proc_cert_cert_req /* proc server cert request */
MHD_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
MHD_gtls_proc_cert_cert_req /* proc server cert request */
};
const mhd_gtls_mod_auth_st mhd_gtls_dhe_dss_auth_struct = {
const MHD_gtls_mod_auth_st MHD_gtls_dhe_dss_auth_struct = {
"DHE_DSS",
mhd_gtls_gen_cert_server_certificate,
mhd_gtls_gen_cert_client_certificate,
MHD_gtls_gen_cert_server_certificate,
MHD_gtls_gen_cert_client_certificate,
gen_dhe_server_kx,
mhd_gtls_gen_dh_common_client_kx,
mhd_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
mhd_gtls_gen_cert_server_cert_req, /* server cert request */
MHD_gtls_gen_dh_common_client_kx,
MHD_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
MHD_gtls_gen_cert_server_cert_req, /* server cert request */
mhd_gtls_proc_cert_server_certificate,
_gnutls_proc_cert_client_certificate,
MHD_gtls_proc_cert_server_certificate,
MHD__gnutls_proc_cert_client_certificate,
proc_dhe_server_kx,
proc_dhe_client_kx,
mhd_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
mhd_gtls_proc_cert_cert_req /* proc server cert request */
MHD_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
MHD_gtls_proc_cert_cert_req /* proc server cert request */
};
static int
gen_dhe_server_kx (mhd_gtls_session_t session, opaque ** data)
gen_dhe_server_kx (MHD_gtls_session_t session, opaque ** data)
{
mpi_t g, p;
const mpi_t *mpis;
int ret = 0, data_size;
int bits;
gnutls_cert *apr_cert_list;
gnutls_privkey *apr_pkey;
MHD_gnutls_cert *apr_cert_list;
MHD_gnutls_privkey *apr_pkey;
int apr_cert_list_length;
gnutls_datum_t signature, ddata;
mhd_gtls_cert_credentials_t cred;
mhd_gtls_dh_params_t dh_params;
MHD_gnutls_datum_t signature, ddata;
MHD_gtls_cert_credentials_t cred;
MHD_gtls_dh_params_t dh_params;
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
bits = mhd_gtls_dh_get_allowed_prime_bits (session);
bits = MHD_gtls_dh_get_allowed_prime_bits (session);
/* find the appropriate certificate */
if ((ret =
mhd_gtls_get_selected_cert (session, &apr_cert_list,
MHD_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
dh_params =
mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = mhd_gtls_dh_params_to_mpi (dh_params);
MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = MHD_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
}
p = mpis[0];
g = mpis[1];
if ((ret = mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
if ((ret = MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 0)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
mhd_gtls_dh_set_group (session, g, p);
MHD_gtls_dh_set_group (session, g, p);
ret = mhd_gtls_dh_common_print_server_kx (session, g, p, data, 0);
ret = MHD_gtls_dh_common_print_server_kx (session, g, p, data, 0);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
data_size = ret;
@@ -148,58 +148,58 @@ gen_dhe_server_kx (mhd_gtls_session_t session, opaque ** data)
if (apr_cert_list_length > 0)
{
if ((ret =
mhd_gtls_tls_sign_params (session, &apr_cert_list[0],
MHD_gtls_tls_sign_params (session, &apr_cert_list[0],
apr_pkey, &ddata, &signature)) < 0)
{
gnutls_assert ();
gnutls_free (*data);
MHD_gnutls_assert ();
MHD_gnutls_free (*data);
return ret;
}
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return data_size; /* do not put a signature - ILLEGAL! */
}
*data = mhd_gtls_realloc_fast (*data, data_size + signature.size + 2);
*data = MHD_gtls_realloc_fast (*data, data_size + signature.size + 2);
if (*data == NULL)
{
_gnutls_free_datum (&signature);
gnutls_assert ();
MHD__gnutls_free_datum (&signature);
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
mhd_gtls_write_datum16 (&(*data)[data_size], signature);
MHD_gtls_write_datum16 (&(*data)[data_size], signature);
data_size += signature.size + 2;
_gnutls_free_datum (&signature);
MHD__gnutls_free_datum (&signature);
return data_size;
}
static int
proc_dhe_server_kx (mhd_gtls_session_t session, opaque * data,
proc_dhe_server_kx (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
int sigsize;
gnutls_datum_t vparams, signature;
MHD_gnutls_datum_t vparams, signature;
int ret;
cert_auth_info_t info = mhd_gtls_get_auth_info (session);
cert_auth_info_t info = MHD_gtls_get_auth_info (session);
ssize_t data_size = _data_size;
gnutls_cert peer_cert;
MHD_gnutls_cert peer_cert;
if (info == NULL || info->ncerts == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* we need this in order to get peer's certificate */
return GNUTLS_E_INTERNAL_ERROR;
}
ret = mhd_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
ret = MHD_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -209,29 +209,29 @@ proc_dhe_server_kx (mhd_gtls_session_t session, opaque * data,
vparams.data = data;
DECR_LEN (data_size, 2);
sigsize = mhd_gtls_read_uint16 (&data[vparams.size]);
sigsize = MHD_gtls_read_uint16 (&data[vparams.size]);
DECR_LEN (data_size, sigsize);
signature.data = &data[vparams.size + 2];
signature.size = sigsize;
if ((ret =
mhd_gtls_raw_cert_to_gcert (&peer_cert,
MHD_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret =
mhd_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
MHD_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gtls_gcert_deinit (&peer_cert);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -241,36 +241,36 @@ proc_dhe_server_kx (mhd_gtls_session_t session, opaque * data,
static int
proc_dhe_client_kx (mhd_gtls_session_t session, opaque * data,
proc_dhe_client_kx (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
mhd_gtls_cert_credentials_t cred;
MHD_gtls_cert_credentials_t cred;
int ret;
mpi_t p, g;
const mpi_t *mpis;
mhd_gtls_dh_params_t dh_params;
MHD_gtls_dh_params_t dh_params;
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
dh_params =
mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = mhd_gtls_dh_params_to_mpi (dh_params);
MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = MHD_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
}
p = mpis[0];
g = mpis[1];
ret = mhd_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
ret = MHD_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
return ret;
src/daemon/https/tls/auth_rsa.c
+88 -81
View File
@@ -42,85 +42,85 @@
#include <gnutls_x509.h>
#include <gc.h>
int _gnutls_gen_rsa_client_kx (mhd_gtls_session_t, opaque **);
int _gnutls_proc_rsa_client_kx (mhd_gtls_session_t, opaque *, size_t);
int MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t, opaque **);
int MHD__gnutls_proc_rsa_client_kx (MHD_gtls_session_t, opaque *, size_t);
const mhd_gtls_mod_auth_st mhd_gtls_rsa_auth_struct = {
const MHD_gtls_mod_auth_st MHD_gtls_rsa_auth_struct = {
"RSA",
mhd_gtls_gen_cert_server_certificate,
mhd_gtls_gen_cert_client_certificate,
MHD_gtls_gen_cert_server_certificate,
MHD_gtls_gen_cert_client_certificate,
NULL, /* gen server kx */
_gnutls_gen_rsa_client_kx,
mhd_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
mhd_gtls_gen_cert_server_cert_req, /* server cert request */
MHD__gnutls_gen_rsa_client_kx,
MHD_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
MHD_gtls_gen_cert_server_cert_req, /* server cert request */
mhd_gtls_proc_cert_server_certificate,
_gnutls_proc_cert_client_certificate,
MHD_gtls_proc_cert_server_certificate,
MHD__gnutls_proc_cert_client_certificate,
NULL, /* proc server kx */
_gnutls_proc_rsa_client_kx, /* proc client kx */
mhd_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
mhd_gtls_proc_cert_cert_req /* proc server cert request */
MHD__gnutls_proc_rsa_client_kx, /* proc client kx */
MHD_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
MHD_gtls_proc_cert_cert_req /* proc server cert request */
};
/* This function reads the RSA parameters from peer's certificate;
*/
int
_gnutls_get_public_rsa_params (mhd_gtls_session_t session,
MHD__gnutls_get_public_rsa_params (MHD_gtls_session_t session,
mpi_t params[MAX_PUBLIC_PARAMS_SIZE],
int *params_len)
{
int ret;
cert_auth_info_t info;
gnutls_cert peer_cert;
MHD_gnutls_cert peer_cert;
int i;
/* normal non export case */
info = mhd_gtls_get_auth_info (session);
info = MHD_gtls_get_auth_info (session);
if (info == NULL || info->ncerts == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
ret =
mhd_gtls_raw_cert_to_gcert (&peer_cert,
MHD_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_ONLY_PUBKEY | CERT_NO_COPY);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
/* EXPORT case: */
if (mhd_gtls_cipher_suite_get_kx_algo
if (MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.current_cipher_suite)
== MHD_GNUTLS_KX_RSA_EXPORT
&& _gnutls_mpi_get_nbits (peer_cert.params[0]) > 512)
&& MHD__gnutls_mpi_get_nbits (peer_cert.params[0]) > 512)
{
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gtls_gcert_deinit (&peer_cert);
if (session->key->rsa[0] == NULL || session->key->rsa[1] == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (*params_len < 2)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
*params_len = 2;
for (i = 0; i < *params_len; i++)
{
params[i] = _gnutls_mpi_copy (session->key->rsa[i]);
params[i] = MHD__gnutls_mpi_copy (session->key->rsa[i]);
}
return 0;
@@ -130,16 +130,16 @@ _gnutls_get_public_rsa_params (mhd_gtls_session_t session,
if (*params_len < peer_cert.params_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
*params_len = peer_cert.params_size;
for (i = 0; i < *params_len; i++)
{
params[i] = _gnutls_mpi_copy (peer_cert.params[i]);
params[i] = MHD__gnutls_mpi_copy (peer_cert.params[i]);
}
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gtls_gcert_deinit (&peer_cert);
return 0;
}
@@ -147,43 +147,43 @@ _gnutls_get_public_rsa_params (mhd_gtls_session_t session,
/* This function reads the RSA parameters from the private key
*/
int
_gnutls_get_private_rsa_params (mhd_gtls_session_t session,
MHD__gnutls_get_private_rsa_params (MHD_gtls_session_t session,
mpi_t ** params, int *params_size)
{
int bits;
mhd_gtls_cert_credentials_t cred;
mhd_gtls_rsa_params_t rsa_params;
MHD_gtls_cert_credentials_t cred;
MHD_gtls_rsa_params_t rsa_params;
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
if (session->internals.selected_cert_list == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
bits =
_gnutls_mpi_get_nbits (session->internals.selected_cert_list[0].
MHD__gnutls_mpi_get_nbits (session->internals.selected_cert_list[0].
params[0]);
if (mhd_gtls_cipher_suite_get_kx_algo
if (MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.current_cipher_suite)
== MHD_GNUTLS_KX_RSA_EXPORT && bits > 512)
{
rsa_params =
mhd_gtls_certificate_get_rsa_params (cred->rsa_params,
MHD_gtls_certificate_get_rsa_params (cred->rsa_params,
cred->params_func, session);
/* EXPORT case: */
if (rsa_params == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_TEMPORARY_RSA_PARAMS;
}
@@ -206,18 +206,18 @@ _gnutls_get_private_rsa_params (mhd_gtls_session_t session,
}
int
_gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
MHD__gnutls_proc_rsa_client_kx (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
gnutls_datum_t plaintext;
gnutls_datum_t ciphertext;
MHD_gnutls_datum_t plaintext;
MHD_gnutls_datum_t ciphertext;
int ret, dsize;
mpi_t *params;
int params_len;
int randomize_key = 0;
ssize_t data_size = _data_size;
if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
{
/* SSL 3.0
*/
@@ -230,24 +230,24 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
*/
DECR_LEN (data_size, 2);
ciphertext.data = &data[2];
dsize = mhd_gtls_read_uint16 (data);
dsize = MHD_gtls_read_uint16 (data);
if (dsize != data_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
ciphertext.size = dsize;
}
ret = _gnutls_get_private_rsa_params (session, &params, &params_len);
ret = MHD__gnutls_get_private_rsa_params (session, &params, &params_len);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret = mhd_gtls_pkcs1_rsa_decrypt (&plaintext, &ciphertext, params, params_len, 2); /* btype==2 */
ret = MHD_gtls_pkcs1_rsa_decrypt (&plaintext, &ciphertext, params, params_len, 2); /* btype==2 */
if (ret < 0 || plaintext.size != TLS_MASTER_SIZE)
{
@@ -255,8 +255,8 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
* the peer. Just use a random key. (in order to avoid
* attack against pkcs-1 formating).
*/
gnutls_assert ();
_gnutls_x509_log ("auth_rsa: Possible PKCS #1 format attack\n");
MHD_gnutls_assert ();
MHD__gnutls_x509_log ("auth_rsa: Possible PKCS #1 format attack\n");
randomize_key = 1;
}
else
@@ -264,8 +264,8 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
/* If the secret was properly formatted, then
* check the version number.
*/
if (_gnutls_get_adv_version_major (session) != plaintext.data[0]
|| _gnutls_get_adv_version_minor (session) != plaintext.data[1])
if (MHD__gnutls_get_adv_version_major (session) != plaintext.data[0]
|| MHD__gnutls_get_adv_version_minor (session) != plaintext.data[1])
{
/* No error is returned here, if the version number check
* fails. We proceed normally.
@@ -273,8 +273,8 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
* "Attacking RSA-based sessions in SSL/TLS" by Vlastimil Klima,
* Ondej Pokorny and Tomas Rosa.
*/
gnutls_assert ();
_gnutls_x509_log
MHD_gnutls_assert ();
MHD__gnutls_x509_log
("auth_rsa: Possible PKCS #1 version check format attack\n");
}
}
@@ -282,18 +282,18 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
if (randomize_key != 0)
{
session->key->key.size = TLS_MASTER_SIZE;
session->key->key.data = gnutls_malloc (session->key->key.size);
session->key->key.data = MHD_gnutls_malloc (session->key->key.size);
if (session->key->key.data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
/* we do not need strong random numbers here.
*/
if (gc_nonce (session->key->key.data, session->key->key.size) != GC_OK)
if (MHD_gc_nonce (session->key->key.data, session->key->key.size) != GC_OK)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RANDOM_FAILED;
}
@@ -307,8 +307,8 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
/* This is here to avoid the version check attack
* discussed above.
*/
session->key->key.data[0] = _gnutls_get_adv_version_major (session);
session->key->key.data[1] = _gnutls_get_adv_version_minor (session);
session->key->key.data[0] = MHD__gnutls_get_adv_version_major (session);
session->key->key.data[1] = MHD__gnutls_get_adv_version_minor (session);
return 0;
}
@@ -318,46 +318,53 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
/* return RSA(random) using the peers public key
*/
int
_gnutls_gen_rsa_client_kx (mhd_gtls_session_t session, opaque ** data)
MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t session, opaque ** data)
{
cert_auth_info_t auth = session->key->auth_info;
gnutls_datum_t sdata; /* data to send */
cert_auth_info_t auth;
MHD_gnutls_datum_t sdata; /* data to send */
mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
int params_len = MAX_PUBLIC_PARAMS_SIZE;
int ret, i;
enum MHD_GNUTLS_Protocol ver;
if (session->key == NULL)
{
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
auth = session->key->auth_info;
if (auth == NULL)
{
/* this shouldn't have happened. The proc_certificate
* function should have detected that.
*/
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
session->key->key.size = TLS_MASTER_SIZE;
session->key->key.data = gnutls_secure_malloc (session->key->key.size);
session->key->key.data = MHD_gnutls_secure_malloc (session->key->key.size);
if (session->key->key.data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
if (gc_pseudo_random (session->key->key.data,
if (MHD_gc_pseudo_random (session->key->key.data,
session->key->key.size) != GC_OK)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RANDOM_FAILED;
}
ver = mhd_gtls_get_adv_version (session);
ver = MHD_gtls_get_adv_version (session);
if (session->internals.rsa_pms_version[0] == 0)
{
session->key->key.data[0] = mhd_gtls_version_get_major (ver);
session->key->key.data[1] = mhd_gtls_version_get_minor (ver);
session->key->key.data[0] = MHD_gtls_version_get_major (ver);
session->key->key.data[1] = MHD_gtls_version_get_minor (ver);
}
else
{ /* use the version provided */
@@ -368,24 +375,24 @@ _gnutls_gen_rsa_client_kx (mhd_gtls_session_t session, opaque ** data)
/* move RSA parameters to key (session).
*/
if ((ret =
_gnutls_get_public_rsa_params (session, params, &params_len)) < 0)
MHD__gnutls_get_public_rsa_params (session, params, &params_len)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if ((ret =
mhd_gtls_pkcs1_rsa_encrypt (&sdata, &session->key->key,
MHD_gtls_pkcs1_rsa_encrypt (&sdata, &session->key->key,
params, params_len, 2)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
for (i = 0; i < params_len; i++)
mhd_gtls_mpi_release (&params[i]);
MHD_gtls_mpi_release (&params[i]);
if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
{
/* SSL 3.0 */
*data = sdata.data;
@@ -393,15 +400,15 @@ _gnutls_gen_rsa_client_kx (mhd_gtls_session_t session, opaque ** data)
}
else
{ /* TLS 1 */
*data = gnutls_malloc (sdata.size + 2);
*data = MHD_gnutls_malloc (sdata.size + 2);
if (*data == NULL)
{
_gnutls_free_datum (&sdata);
MHD__gnutls_free_datum (&sdata);
return GNUTLS_E_MEMORY_ERROR;
}
mhd_gtls_write_datum16 (*data, sdata);
MHD_gtls_write_datum16 (*data, sdata);
ret = sdata.size + 2;
_gnutls_free_datum (&sdata);
MHD__gnutls_free_datum (&sdata);
return ret;
}
src/daemon/https/tls/auth_rsa_export.c
+79 -79
View File
@@ -43,105 +43,105 @@
#include <gnutls_rsa_export.h>
#include <gnutls_state.h>
int _gnutls_gen_rsa_client_kx (mhd_gtls_session_t, opaque **);
int _gnutls_proc_rsa_client_kx (mhd_gtls_session_t, opaque *, size_t);
static int gen_rsa_export_server_kx (mhd_gtls_session_t, opaque **);
static int proc_rsa_export_server_kx (mhd_gtls_session_t, opaque *, size_t);
int MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t, opaque **);
int MHD__gnutls_proc_rsa_client_kx (MHD_gtls_session_t, opaque *, size_t);
static int gen_rsa_export_server_kx (MHD_gtls_session_t, opaque **);
static int proc_rsa_export_server_kx (MHD_gtls_session_t, opaque *, size_t);
const mhd_gtls_mod_auth_st rsa_export_auth_struct = {
const MHD_gtls_mod_auth_st rsa_export_auth_struct = {
"RSA EXPORT",
mhd_gtls_gen_cert_server_certificate,
mhd_gtls_gen_cert_client_certificate,
MHD_gtls_gen_cert_server_certificate,
MHD_gtls_gen_cert_client_certificate,
gen_rsa_export_server_kx,
_gnutls_gen_rsa_client_kx,
mhd_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
mhd_gtls_gen_cert_server_cert_req, /* server cert request */
MHD__gnutls_gen_rsa_client_kx,
MHD_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
MHD_gtls_gen_cert_server_cert_req, /* server cert request */
mhd_gtls_proc_cert_server_certificate,
_gnutls_proc_cert_client_certificate,
MHD_gtls_proc_cert_server_certificate,
MHD__gnutls_proc_cert_client_certificate,
proc_rsa_export_server_kx,
_gnutls_proc_rsa_client_kx, /* proc client kx */
mhd_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
mhd_gtls_proc_cert_cert_req /* proc server cert request */
MHD__gnutls_proc_rsa_client_kx, /* proc client kx */
MHD_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
MHD_gtls_proc_cert_cert_req /* proc server cert request */
};
static int
gen_rsa_export_server_kx (mhd_gtls_session_t session, opaque ** data)
gen_rsa_export_server_kx (MHD_gtls_session_t session, opaque ** data)
{
mhd_gtls_rsa_params_t rsa_params;
MHD_gtls_rsa_params_t rsa_params;
const mpi_t *rsa_mpis;
size_t n_e, n_m;
uint8_t *data_e, *data_m;
int ret = 0, data_size;
gnutls_cert *apr_cert_list;
gnutls_privkey *apr_pkey;
MHD_gnutls_cert *apr_cert_list;
MHD_gnutls_privkey *apr_pkey;
int apr_cert_list_length;
gnutls_datum_t signature, ddata;
mhd_gtls_cert_credentials_t cred;
MHD_gnutls_datum_t signature, ddata;
MHD_gtls_cert_credentials_t cred;
cred = (mhd_gtls_cert_credentials_t)
mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
/* find the appropriate certificate */
if ((ret =
mhd_gtls_get_selected_cert (session, &apr_cert_list,
MHD_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
/* abort sending this message if we have a certificate
* of 512 bits or less.
*/
if (apr_pkey && _gnutls_mpi_get_nbits (apr_pkey->params[0]) <= 512)
if (apr_pkey && MHD__gnutls_mpi_get_nbits (apr_pkey->params[0]) <= 512)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INT_RET_0;
}
rsa_params =
mhd_gtls_certificate_get_rsa_params (cred->rsa_params, cred->params_func,
MHD_gtls_certificate_get_rsa_params (cred->rsa_params, cred->params_func,
session);
rsa_mpis = _gnutls_rsa_params_to_mpi (rsa_params);
rsa_mpis = MHD__gnutls_rsa_params_to_mpi (rsa_params);
if (rsa_mpis == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_TEMPORARY_RSA_PARAMS;
}
if ((ret = mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
if ((ret = MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 0)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
mhd_gtls_rsa_export_set_pubkey (session, rsa_mpis[1], rsa_mpis[0]);
MHD_gtls_rsa_export_set_pubkey (session, rsa_mpis[1], rsa_mpis[0]);
mhd_gtls_mpi_print (NULL, &n_m, rsa_mpis[0]);
mhd_gtls_mpi_print (NULL, &n_e, rsa_mpis[1]);
MHD_gtls_mpi_print (NULL, &n_m, rsa_mpis[0]);
MHD_gtls_mpi_print (NULL, &n_e, rsa_mpis[1]);
(*data) = gnutls_malloc (n_e + n_m + 4);
(*data) = MHD_gnutls_malloc (n_e + n_m + 4);
if (*data == NULL)
{
return GNUTLS_E_MEMORY_ERROR;
}
data_m = &(*data)[0];
mhd_gtls_mpi_print (&data_m[2], &n_m, rsa_mpis[0]);
MHD_gtls_mpi_print (&data_m[2], &n_m, rsa_mpis[0]);
mhd_gtls_write_uint16 (n_m, data_m);
MHD_gtls_write_uint16 (n_m, data_m);
data_e = &data_m[2 + n_m];
mhd_gtls_mpi_print (&data_e[2], &n_e, rsa_mpis[1]);
MHD_gtls_mpi_print (&data_e[2], &n_e, rsa_mpis[1]);
mhd_gtls_write_uint16 (n_e, data_e);
MHD_gtls_write_uint16 (n_e, data_e);
data_size = n_m + n_e + 4;
@@ -154,33 +154,33 @@ gen_rsa_export_server_kx (mhd_gtls_session_t session, opaque ** data)
if (apr_cert_list_length > 0)
{
if ((ret =
mhd_gtls_tls_sign_params (session, &apr_cert_list[0],
MHD_gtls_tls_sign_params (session, &apr_cert_list[0],
apr_pkey, &ddata, &signature)) < 0)
{
gnutls_assert ();
gnutls_free (*data);
MHD_gnutls_assert ();
MHD_gnutls_free (*data);
*data = NULL;
return ret;
}
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return data_size; /* do not put a signature - ILLEGAL! */
}
*data = mhd_gtls_realloc_fast (*data, data_size + signature.size + 2);
*data = MHD_gtls_realloc_fast (*data, data_size + signature.size + 2);
if (*data == NULL)
{
_gnutls_free_datum (&signature);
gnutls_assert ();
MHD__gnutls_free_datum (&signature);
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
mhd_gtls_write_datum16 (&((*data)[data_size]), signature);
MHD_gtls_write_datum16 (&((*data)[data_size]), signature);
data_size += signature.size + 2;
_gnutls_free_datum (&signature);
MHD__gnutls_free_datum (&signature);
return data_size;
}
@@ -188,49 +188,49 @@ gen_rsa_export_server_kx (mhd_gtls_session_t session, opaque ** data)
/* if the peer's certificate is of 512 bits or less, returns non zero.
*/
int
_gnutls_peers_cert_less_512 (mhd_gtls_session_t session)
MHD__gnutls_peers_cert_less_512 (MHD_gtls_session_t session)
{
gnutls_cert peer_cert;
MHD_gnutls_cert peer_cert;
int ret;
cert_auth_info_t info = mhd_gtls_get_auth_info (session);
cert_auth_info_t info = MHD_gtls_get_auth_info (session);
if (info == NULL || info->ncerts == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* we need this in order to get peer's certificate */
return 0;
}
if ((ret =
mhd_gtls_raw_cert_to_gcert (&peer_cert,
MHD_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
if (peer_cert.subject_pk_algorithm != MHD_GNUTLS_PK_RSA)
{
gnutls_assert ();
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gnutls_assert ();
MHD_gtls_gcert_deinit (&peer_cert);
return 0;
}
if (_gnutls_mpi_get_nbits (peer_cert.params[0]) <= 512)
if (MHD__gnutls_mpi_get_nbits (peer_cert.params[0]) <= 512)
{
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gtls_gcert_deinit (&peer_cert);
return 1;
}
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gtls_gcert_deinit (&peer_cert);
return 0;
}
static int
proc_rsa_export_server_kx (mhd_gtls_session_t session,
proc_rsa_export_server_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size)
{
uint16_t n_m, n_e;
@@ -238,16 +238,16 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
uint8_t *data_m;
uint8_t *data_e;
int i, sigsize;
gnutls_datum_t vparams, signature;
MHD_gnutls_datum_t vparams, signature;
int ret;
ssize_t data_size = _data_size;
cert_auth_info_t info;
gnutls_cert peer_cert;
MHD_gnutls_cert peer_cert;
info = mhd_gtls_get_auth_info (session);
info = MHD_gtls_get_auth_info (session);
if (info == NULL || info->ncerts == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* we need this in order to get peer's certificate */
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -256,7 +256,7 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
i = 0;
DECR_LEN (data_size, 2);
n_m = mhd_gtls_read_uint16 (&data[i]);
n_m = MHD_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_m);
@@ -264,7 +264,7 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
i += n_m;
DECR_LEN (data_size, 2);
n_e = mhd_gtls_read_uint16 (&data[i]);
n_e = MHD_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_e);
@@ -274,19 +274,19 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
_n_e = n_e;
_n_m = n_m;
if (mhd_gtls_mpi_scan_nz (&session->key->rsa[0], data_m, &_n_m) != 0)
if (MHD_gtls_mpi_scan_nz (&session->key->rsa[0], data_m, &_n_m) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
if (mhd_gtls_mpi_scan_nz (&session->key->rsa[1], data_e, &_n_e) != 0)
if (MHD_gtls_mpi_scan_nz (&session->key->rsa[1], data_e, &_n_e) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
mhd_gtls_rsa_export_set_pubkey (session, session->key->rsa[1],
MHD_gtls_rsa_export_set_pubkey (session, session->key->rsa[1],
session->key->rsa[0]);
/* VERIFY SIGNATURE */
@@ -295,29 +295,29 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
vparams.data = data;
DECR_LEN (data_size, 2);
sigsize = mhd_gtls_read_uint16 (&data[vparams.size]);
sigsize = MHD_gtls_read_uint16 (&data[vparams.size]);
DECR_LEN (data_size, sigsize);
signature.data = &data[vparams.size + 2];
signature.size = sigsize;
if ((ret =
mhd_gtls_raw_cert_to_gcert (&peer_cert,
MHD_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret =
mhd_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
MHD_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
mhd_gtls_gcert_deinit (&peer_cert);
MHD_gtls_gcert_deinit (&peer_cert);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
}
return ret;
src/daemon/https/tls/debug.c
+11 -11
View File
@@ -32,26 +32,26 @@
void
_gnutls_print_state (mhd_gtls_session_t session)
MHD__gnutls_print_state (MHD_gtls_session_t session)
{
_gnutls_debug_log ("GNUTLS State:\n");
_gnutls_debug_log ("Connection End: %d\n",
MHD__gnutls_debug_log ("GNUTLS State:\n");
MHD__gnutls_debug_log ("Connection End: %d\n",
session->security_parameters.entity);
_gnutls_debug_log ("Cipher Algorithm: %d\n",
MHD__gnutls_debug_log ("Cipher Algorithm: %d\n",
session->security_parameters.read_bulk_cipher_algorithm);
_gnutls_debug_log ("MAC algorithm: %d\n",
MHD__gnutls_debug_log ("MAC algorithm: %d\n",
session->security_parameters.read_mac_algorithm);
_gnutls_debug_log ("Compression Algorithm: %d\n",
MHD__gnutls_debug_log ("Compression Algorithm: %d\n",
session->security_parameters.read_compression_algorithm);
_gnutls_debug_log ("\n");
MHD__gnutls_debug_log ("\n");
}
#endif
const char *
_gnutls_packet2str (content_type_t packet)
MHD__gnutls_packet2str (content_type_t packet)
{
switch (packet)
{
@@ -72,7 +72,7 @@ _gnutls_packet2str (content_type_t packet)
}
const char *
_gnutls_handshake2str (gnutls_handshake_description_t handshake)
MHD__gnutls_handshake2str (MHD_gnutls_handshake_description_t handshake)
{
switch (handshake)
@@ -117,12 +117,12 @@ _gnutls_handshake2str (gnutls_handshake_description_t handshake)
}
void
_gnutls_dump_mpi (const char *prefix, mpi_t a)
MHD__gnutls_dump_mpi (const char *prefix, mpi_t a)
{
opaque buf[1024];
size_t n = sizeof buf;
if (gcry_mpi_print (GCRYMPI_FMT_HEX, buf, n, &n, a))
strcpy (buf, "[can't print value]"); /* Flawfinder: ignore */
_gnutls_hard_log ("MPI: length: %d\n\t%s%s\n", (n - 1) / 2, prefix, buf);
MHD__gnutls_hard_log ("MPI: length: %d\n\t%s%s\n", (n - 1) / 2, prefix, buf);
}
src/daemon/https/tls/debug.h
+4 -4
View File
@@ -23,8 +23,8 @@
*/
#ifdef DEBUG
void _gnutls_print_state (mhd_gtls_session_t session);
void MHD__gnutls_print_state (MHD_gtls_session_t session);
#endif
const char *_gnutls_packet2str (content_type_t packet);
const char *_gnutls_handshake2str (gnutls_handshake_description_t handshake);
void _gnutls_dump_mpi (const char *prefix, mpi_t a);
const char *MHD__gnutls_packet2str (content_type_t packet);
const char *MHD__gnutls_handshake2str (MHD_gnutls_handshake_description_t handshake);
void MHD__gnutls_dump_mpi (const char *prefix, mpi_t a);
src/daemon/https/tls/ext_cert_type.c
+24 -24
View File
@@ -33,12 +33,12 @@
#include "gnutls_state.h"
#include "gnutls_num.h"
inline static int _gnutls_num2cert_type (int num);
inline static int _gnutls_cert_type2num (int record_size);
inline static int MHD__gnutls_num2cert_type (int num);
inline static int MHD__gnutls_cert_type2num (int record_size);
/*
* In case of a server: if a CERT_TYPE extension type is received then it stores
* into the session security parameters the new value. The server may use gnutls_session_certificate_type_get(),
* into the session security parameters the new value. The server may use MHD_gnutls_session_certificate_type_get(),
* to access it.
*
* In case of a client: If a cert_types have been specified then we send the extension.
@@ -46,7 +46,7 @@ inline static int _gnutls_cert_type2num (int record_size);
*/
int
mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
MHD_gtls_cert_type_recv_params (MHD_gtls_session_t session,
const opaque * data, size_t _data_size)
{
int new_type = -1, ret, i;
@@ -59,27 +59,27 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
{
if (data_size != 1)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
new_type = _gnutls_num2cert_type (data[0]);
new_type = MHD__gnutls_num2cert_type (data[0]);
if (new_type < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return new_type;
}
/* Check if we support this cert_type */
if ((ret =
mhd_gtls_session_cert_type_supported (session, new_type)) < 0)
MHD_gtls_session_cert_type_supported (session, new_type)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
_gnutls_session_cert_type_set (session, new_type);
MHD__gnutls_session_cert_type_set (session, new_type);
}
}
else
@@ -96,17 +96,17 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
for (i = 0; i < len; i++)
{
new_type = _gnutls_num2cert_type (data[i + 1]);
new_type = MHD__gnutls_num2cert_type (data[i + 1]);
if (new_type < 0)
continue;
/* Check if we support this cert_type */
if ((ret =
mhd_gtls_session_cert_type_supported (session,
MHD_gtls_session_cert_type_supported (session,
new_type)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
continue;
}
else
@@ -116,14 +116,14 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
if (new_type < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
}
if ((ret =
mhd_gtls_session_cert_type_supported (session, new_type)) < 0)
MHD_gtls_session_cert_type_supported (session, new_type)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* The peer has requested unsupported certificate
* types. Instead of failing, procceed normally.
* (the ciphersuite selection would fail, or a
@@ -132,7 +132,7 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
return 0;
}
_gnutls_session_cert_type_set (session, new_type);
MHD__gnutls_session_cert_type_set (session, new_type);
}
@@ -144,7 +144,7 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
/* returns data_size or a negative number on failure
*/
int
mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
MHD_gtls_cert_type_send_params (MHD_gtls_session_t session, opaque * data,
size_t data_size)
{
unsigned len, i;
@@ -171,7 +171,7 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
if (data_size < len + 1)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
@@ -182,7 +182,7 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
for (i = 0; i < len; i++)
{
data[i + 1] =
_gnutls_cert_type2num (session->internals.
MHD__gnutls_cert_type2num (session->internals.
priorities.cert_type.priority[i]);
}
return len + 1;
@@ -197,12 +197,12 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
len = 1;
if (data_size < len)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
data[0] =
_gnutls_cert_type2num (session->security_parameters.cert_type);
MHD__gnutls_cert_type2num (session->security_parameters.cert_type);
return len;
}
@@ -216,7 +216,7 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
* extensions draft.
*/
inline static int
_gnutls_num2cert_type (int num)
MHD__gnutls_num2cert_type (int num)
{
switch (num)
{
@@ -231,7 +231,7 @@ _gnutls_num2cert_type (int num)
* extensions draft.
*/
inline static int
_gnutls_cert_type2num (int cert_type)
MHD__gnutls_cert_type2num (int cert_type)
{
switch (cert_type)
{
src/daemon/https/tls/ext_cert_type.h
+2 -2
View File
@@ -25,7 +25,7 @@
/* Maps record size to numbers according to the
* extensions draft.
*/
int mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
int MHD_gtls_cert_type_recv_params (MHD_gtls_session_t session,
const opaque * data, size_t data_size);
int mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
int MHD_gtls_cert_type_send_params (MHD_gtls_session_t session, opaque * data,
size_t);
src/daemon/https/tls/ext_max_record.c
+14 -14
View File
@@ -32,7 +32,7 @@
/*
* In case of a server: if a MAX_RECORD_SIZE extension type is received then it stores
* into the session the new value. The server may use gnutls_get_max_record_size(),
* into the session the new value. The server may use MHD_gnutls_get_max_record_size(),
* in order to access it.
*
* In case of a client: If a different max record size (than the default) has
@@ -41,7 +41,7 @@
*/
int
mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
MHD_gtls_max_record_recv_params (MHD_gtls_session_t session,
const opaque * data, size_t _data_size)
{
ssize_t new_size;
@@ -53,11 +53,11 @@ mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
{
DECR_LEN (data_size, 1);
new_size = mhd_gtls_mre_num2record (data[0]);
new_size = MHD_gtls_mre_num2record (data[0]);
if (new_size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return new_size;
}
@@ -73,16 +73,16 @@ mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
if (data_size != 1)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
new_size = mhd_gtls_mre_num2record (data[0]);
new_size = MHD_gtls_mre_num2record (data[0]);
if (new_size < 0
|| new_size != session->internals.proposed_record_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
}
else
@@ -102,7 +102,7 @@ mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
/* returns data_size or a negative number on failure
*/
int
mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
MHD_gtls_max_record_send_params (MHD_gtls_session_t session, opaque * data,
size_t data_size)
{
uint16_t len;
@@ -116,12 +116,12 @@ mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
len = 1;
if (data_size < len)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
data[0] =
(uint8_t) mhd_gtls_mre_record2num (session->internals.
(uint8_t) MHD_gtls_mre_record2num (session->internals.
proposed_record_size);
return len;
}
@@ -137,13 +137,13 @@ mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
len = 1;
if (data_size < len)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
data[0] =
(uint8_t)
mhd_gtls_mre_record2num
MHD_gtls_mre_record2num
(session->security_parameters.max_record_recv_size);
return len;
}
@@ -158,7 +158,7 @@ mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
* extensions draft.
*/
int
mhd_gtls_mre_num2record (int num)
MHD_gtls_mre_num2record (int num)
{
switch (num)
{
@@ -179,7 +179,7 @@ mhd_gtls_mre_num2record (int num)
* extensions draft.
*/
int
mhd_gtls_mre_record2num (uint16_t record_size)
MHD_gtls_mre_record2num (uint16_t record_size)
{
switch (record_size)
{
src/daemon/https/tls/ext_max_record.h
+4 -4
View File
@@ -25,9 +25,9 @@
/* Maps record size to numbers according to the
* extensions draft.
*/
int mhd_gtls_mre_num2record (int num);
int mhd_gtls_mre_record2num (uint16_t record_size);
int mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
int MHD_gtls_mre_num2record (int num);
int MHD_gtls_mre_record2num (uint16_t record_size);
int MHD_gtls_max_record_recv_params (MHD_gtls_session_t session,
const opaque * data, size_t data_size);
int mhd_gtls_max_record_send_params (mhd_gtls_session_t session,
int MHD_gtls_max_record_send_params (MHD_gtls_session_t session,
opaque * data, size_t);
src/daemon/https/tls/ext_oprfi.c
+29 -29
View File
@@ -34,7 +34,7 @@
#include <gnutls_num.h>
static int
oprfi_recv_server (mhd_gtls_session_t session,
oprfi_recv_server (MHD_gtls_session_t session,
const opaque * data, size_t _data_size)
{
ssize_t data_size = _data_size;
@@ -42,26 +42,26 @@ oprfi_recv_server (mhd_gtls_session_t session,
if (!session->security_parameters.extensions.oprfi_cb)
{
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
DECR_LEN (data_size, 2);
len = mhd_gtls_read_uint16 (data);
len = MHD_gtls_read_uint16 (data);
data += 2;
if (len != data_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
/* Store incoming data. */
session->security_parameters.extensions.oprfi_client_len = len;
session->security_parameters.extensions.oprfi_client = gnutls_malloc (len);
session->security_parameters.extensions.oprfi_client = MHD_gnutls_malloc (len);
if (!session->security_parameters.extensions.oprfi_client)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
memcpy (session->security_parameters.extensions.oprfi_client, data, len);
@@ -70,7 +70,7 @@ oprfi_recv_server (mhd_gtls_session_t session,
}
static int
oprfi_recv_client (mhd_gtls_session_t session,
oprfi_recv_client (MHD_gtls_session_t session,
const opaque * data, size_t _data_size)
{
ssize_t data_size = _data_size;
@@ -78,32 +78,32 @@ oprfi_recv_client (mhd_gtls_session_t session,
if (session->security_parameters.extensions.oprfi_client == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
DECR_LEN (data_size, 2);
len = mhd_gtls_read_uint16 (data);
len = MHD_gtls_read_uint16 (data);
data += 2;
if (len != data_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
if (len != session->security_parameters.extensions.oprfi_client_len)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
}
/* Store incoming data. */
session->security_parameters.extensions.oprfi_server_len = len;
session->security_parameters.extensions.oprfi_server = gnutls_malloc (len);
session->security_parameters.extensions.oprfi_server = MHD_gnutls_malloc (len);
if (!session->security_parameters.extensions.oprfi_server)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
memcpy (session->security_parameters.extensions.oprfi_server, data, len);
@@ -112,7 +112,7 @@ oprfi_recv_client (mhd_gtls_session_t session,
}
int
mhd_gtls_oprfi_recv_params (mhd_gtls_session_t session,
MHD_gtls_oprfi_recv_params (MHD_gtls_session_t session,
const opaque * data, size_t data_size)
{
#if MHD_DEBUG_TLS
@@ -124,7 +124,7 @@ mhd_gtls_oprfi_recv_params (mhd_gtls_session_t session,
}
static int
oprfi_send_client (mhd_gtls_session_t session, opaque * data,
oprfi_send_client (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
opaque *p = data;
@@ -135,7 +135,7 @@ oprfi_send_client (mhd_gtls_session_t session, opaque * data,
return 0;
DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
mhd_gtls_write_uint16 (oprf_size, p);
MHD_gtls_write_uint16 (oprf_size, p);
p += 2;
DECR_LENGTH_RET (data_size, oprf_size, GNUTLS_E_SHORT_MEMORY_BUFFER);
@@ -146,7 +146,7 @@ oprfi_send_client (mhd_gtls_session_t session, opaque * data,
}
static int
oprfi_send_server (mhd_gtls_session_t session, opaque * data,
oprfi_send_server (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
opaque *p = data;
@@ -161,10 +161,10 @@ oprfi_send_server (mhd_gtls_session_t session, opaque * data,
session->security_parameters.extensions.oprfi_server_len =
session->security_parameters.extensions.oprfi_client_len;
session->security_parameters.extensions.oprfi_server =
gnutls_malloc (session->security_parameters.extensions.oprfi_server_len);
MHD_gnutls_malloc (session->security_parameters.extensions.oprfi_server_len);
if (!session->security_parameters.extensions.oprfi_server)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -176,13 +176,13 @@ oprfi_send_server (mhd_gtls_session_t session, opaque * data,
session->security_parameters.extensions.oprfi_server);
if (ret < 0)
{
gnutls_assert ();
gnutls_free (session->security_parameters.extensions.oprfi_server);
MHD_gnutls_assert ();
MHD_gnutls_free (session->security_parameters.extensions.oprfi_server);
return ret;
}
DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
mhd_gtls_write_uint16 (session->security_parameters.
MHD_gtls_write_uint16 (session->security_parameters.
extensions.oprfi_server_len, p);
p += 2;
@@ -197,7 +197,7 @@ oprfi_send_server (mhd_gtls_session_t session, opaque * data,
}
int
mhd_gtls_oprfi_send_params (mhd_gtls_session_t session,
MHD_gtls_oprfi_send_params (MHD_gtls_session_t session,
opaque * data, size_t data_size)
{
#if MHD_DEBUG_TLS
@@ -210,7 +210,7 @@ mhd_gtls_oprfi_send_params (mhd_gtls_session_t session,
/**
* MHD_gtls_oprfi_enable_client:
* @session: is a #mhd_gtls_session_t structure.
* @session: is a #MHD_gtls_session_t structure.
* @len: length of Opaque PRF data to use in client.
* @data: Opaque PRF data to use in client.
*
@@ -222,7 +222,7 @@ mhd_gtls_oprfi_send_params (mhd_gtls_session_t session,
* may de-allocate it immediately after calling this function.
**/
void
MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
MHD_gtls_oprfi_enable_client (MHD_gtls_session_t session,
size_t len, unsigned char *data)
{
session->security_parameters.extensions.oprfi_client_len = len;
@@ -231,7 +231,7 @@ MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
/**
* MHD_gtls_oprfi_enable_server:
* @session: is a #mhd_gtls_session_t structure.
* @session: is a #MHD_gtls_session_t structure.
* @cb: function pointer to Opaque PRF extension server callback.
* @userdata: hook passed to callback function for passing application state.
*
@@ -240,7 +240,7 @@ MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
* provided callback @cb will be invoked. The callback must have the
* following prototype:
*
* int callback (mhd_gtls_session_t session, void *userdata,
* int callback (MHD_gtls_session_t session, void *userdata,
* size_t oprfi_len, const unsigned char *in_oprfi,
* unsigned char *out_oprfi);
*
@@ -250,8 +250,8 @@ MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
* handshake will be aborted.
**/
void
MHD_gtls_oprfi_enable_server (mhd_gtls_session_t session,
gnutls_oprfi_callback_func cb, void *userdata)
MHD_gtls_oprfi_enable_server (MHD_gtls_session_t session,
MHD_gnutls_oprfi_callback_func cb, void *userdata)
{
session->security_parameters.extensions.oprfi_cb = cb;
session->security_parameters.extensions.oprfi_userdata = userdata;
src/daemon/https/tls/ext_oprfi.h
+2 -2
View File
@@ -24,8 +24,8 @@
#include <gnutls_int.h>
int mhd_gtls_oprfi_recv_params (mhd_gtls_session_t state,
int MHD_gtls_oprfi_recv_params (MHD_gtls_session_t state,
const opaque * data, size_t data_size);
int mhd_gtls_oprfi_send_params (mhd_gtls_session_t state,
int MHD_gtls_oprfi_send_params (MHD_gtls_session_t state,
opaque * data, size_t data_size);
src/daemon/https/tls/ext_server_name.c
+20 -20
View File
@@ -30,7 +30,7 @@
/*
* In case of a server: if a NAME_DNS extension type is received then it stores
* into the session the value of NAME_DNS. The server may use gnutls_ext_get_server_name(),
* into the session the value of NAME_DNS. The server may use MHD_gnutls_ext_get_server_name(),
* in order to access it.
*
* In case of a client: If a proper NAME_DNS extension type is found in the session then
@@ -39,7 +39,7 @@
*/
int
mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
MHD_gtls_server_name_recv_params (MHD_gtls_session_t session,
const opaque * data, size_t _data_size)
{
int i;
@@ -51,14 +51,14 @@ mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
if (session->security_parameters.entity == GNUTLS_SERVER)
{
DECR_LENGTH_RET (data_size, 2, 0);
len = mhd_gtls_read_uint16 (data);
len = MHD_gtls_read_uint16 (data);
if (len != data_size)
{
/* This is unexpected packet length, but
* just ignore it, for now.
*/
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
@@ -71,7 +71,7 @@ mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
p++;
DECR_LEN (data_size, 2);
len = mhd_gtls_read_uint16 (p);
len = MHD_gtls_read_uint16 (p);
p += 2;
DECR_LENGTH_RET (data_size, len, 0);
@@ -96,7 +96,7 @@ mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
type = *p;
p++;
len = mhd_gtls_read_uint16 (p);
len = MHD_gtls_read_uint16 (p);
p += 2;
switch (type)
@@ -124,7 +124,7 @@ mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
/* returns data_size or a negative number on failure
*/
int
mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
MHD_gtls_server_name_send_params (MHD_gtls_session_t session,
opaque * data, size_t _data_size)
{
int total_size = 0;
@@ -163,7 +163,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
/* UINT16: write total size of all names
*/
DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
mhd_gtls_write_uint16 (total_size - 2, p);
MHD_gtls_write_uint16 (total_size - 2, p);
p += 2;
for (i = 0;
@@ -191,7 +191,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
*p = 0; /* NAME_DNS type */
p++;
mhd_gtls_write_uint16 (len, p);
MHD_gtls_write_uint16 (len, p);
p += 2;
memcpy (p,
@@ -200,7 +200,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
p += len;
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
}
@@ -210,8 +210,8 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
}
/**
* MHD_gnutls_server_name_get - Used to get the server name indicator send by a client
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_server_name_get - Used to get the server name indicator send by a client
* @session: is a #MHD_gtls_session_t structure.
* @data: will hold the data
* @data_length: will hold the data length. Must hold the maximum size of data.
* @type: will hold the server name indicator type
@@ -219,7 +219,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
*
* This function will allow you to get the name indication (if any),
* a client has sent. The name indication may be any of the enumeration
* gnutls_server_name_type_t.
* MHD_gnutls_server_name_type_t.
*
* If @type is GNUTLS_NAME_DNS, then this function is to be used by servers
* that support virtual hosting, and the data will be a null terminated UTF-8 string.
@@ -233,7 +233,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
*
**/
int
MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
MHD__gnutls_server_name_get (MHD_gtls_session_t session, void *data,
size_t * data_length,
unsigned int *type, unsigned int indx)
{
@@ -241,7 +241,7 @@ MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
#if MHD_DEBUG_TLS
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
#endif
@@ -278,8 +278,8 @@ MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
}
/**
* MHD_gnutls_server_name_set - Used to set a name indicator to be sent as an extension
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_server_name_set - Used to set a name indicator to be sent as an extension
* @session: is a #MHD_gtls_session_t structure.
* @type: specifies the indicator type
* @name: is a string that contains the server name.
* @name_length: holds the length of name
@@ -295,15 +295,15 @@ MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
*
**/
int
MHD_gnutls_server_name_set (mhd_gtls_session_t session,
gnutls_server_name_type_t type,
MHD__gnutls_server_name_set (MHD_gtls_session_t session,
MHD_gnutls_server_name_type_t type,
const void *name, size_t name_length)
{
int server_names;
if (session->security_parameters.entity == GNUTLS_SERVER)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
src/daemon/https/tls/ext_server_name.h
+2 -2
View File
@@ -22,7 +22,7 @@
*
*/
int mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
int MHD_gtls_server_name_recv_params (MHD_gtls_session_t session,
const opaque * data, size_t data_size);
int mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
int MHD_gtls_server_name_send_params (MHD_gtls_session_t session,
opaque * data, size_t);
src/daemon/https/tls/gnutls_alert.c
+24 -24
View File
@@ -29,11 +29,11 @@
typedef struct
{
gnutls_alert_description_t alert;
MHD_gnutls_alert_description_t alert;
const char *desc;
} gnutls_alert_entry;
} MHD_gnutls_alert_entry;
static const gnutls_alert_entry mhd_gtls_sup_alerts[] = {
static const MHD_gnutls_alert_entry MHD_gtls_sup_alerts[] = {
{GNUTLS_A_CLOSE_NOTIFY, "Close notify"},
{GNUTLS_A_UNEXPECTED_MESSAGE, "Unexpected message"},
{GNUTLS_A_BAD_RECORD_MAC, "Bad record MAC"},
@@ -67,23 +67,23 @@ static const gnutls_alert_entry mhd_gtls_sup_alerts[] = {
};
#define GNUTLS_ALERT_LOOP(b) \
const gnutls_alert_entry *p; \
for(p = mhd_gtls_sup_alerts; p->desc != NULL; p++) { b ; }
const MHD_gnutls_alert_entry *p; \
for(p = MHD_gtls_sup_alerts; p->desc != NULL; p++) { b ; }
#define GNUTLS_ALERT_ID_LOOP(a) \
GNUTLS_ALERT_LOOP( if(p->alert == alert) { a; break; })
/**
* MHD_gnutls_alert_get_name - Returns a string describing the alert number given
* @alert: is an alert number #mhd_gtls_session_t structure.
* MHD__gnutls_alert_get_name - Returns a string describing the alert number given
* @alert: is an alert number #MHD_gtls_session_t structure.
*
* This function will return a string that describes the given alert
* number or NULL. See gnutls_alert_get().
* number or NULL. See MHD_gnutls_alert_get().
*
**/
const char *
MHD_gnutls_alert_get_name (gnutls_alert_description_t alert)
MHD__gnutls_alert_get_name (MHD_gnutls_alert_description_t alert)
{
const char *ret = NULL;
@@ -93,8 +93,8 @@ MHD_gnutls_alert_get_name (gnutls_alert_description_t alert)
}
/**
* MHD_gnutls_alert_send - This function sends an alert message to the peer
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_alert_send - This function sends an alert message to the peer
* @session: is a #MHD_gtls_session_t structure.
* @level: is the level of the alert
* @desc: is the alert description
*
@@ -110,8 +110,8 @@ MHD_gnutls_alert_get_name (gnutls_alert_description_t alert)
*
**/
int
MHD_gnutls_alert_send (mhd_gtls_session_t session, gnutls_alert_level_t level,
gnutls_alert_description_t desc)
MHD__gnutls_alert_send (MHD_gtls_session_t session, MHD_gnutls_alert_level_t level,
MHD_gnutls_alert_description_t desc)
{
uint8_t data[2];
int ret;
@@ -120,13 +120,13 @@ MHD_gnutls_alert_send (mhd_gtls_session_t session, gnutls_alert_level_t level,
data[0] = (uint8_t) level;
data[1] = (uint8_t) desc;
name = MHD_gnutls_alert_get_name ((int) data[1]);
name = MHD__gnutls_alert_get_name ((int) data[1]);
if (name == NULL)
name = "(unknown)";
_gnutls_record_log ("REC: Sending Alert[%d|%d] - %s\n", data[0],
MHD__gnutls_record_log ("REC: Sending Alert[%d|%d] - %s\n", data[0],
data[1], name);
if ((ret = mhd_gtls_send_int (session, GNUTLS_ALERT, -1, data, 2)) >= 0)
if ((ret = MHD_gtls_send_int (session, GNUTLS_ALERT, -1, data, 2)) >= 0)
return 0;
else
return ret;
@@ -245,8 +245,8 @@ MHD_gtls_error_to_alert (int err, int *level)
/**
* MHD_gnutls_alert_send_appropriate - This function sends an alert to the peer depending on the error code
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_alert_send_appropriate - This function sends an alert to the peer depending on the error code
* @session: is a #MHD_gtls_session_t structure.
* @err: is an integer
*
* Sends an alert to the peer depending on the error code returned by a gnutls
@@ -261,7 +261,7 @@ MHD_gtls_error_to_alert (int err, int *level)
* Returns zero on success.
*/
int
MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err)
MHD__gnutls_alert_send_appropriate (MHD_gtls_session_t session, int err)
{
int alert;
int level;
@@ -272,12 +272,12 @@ MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err)
return alert;
}
return MHD_gnutls_alert_send (session, level, alert);
return MHD__gnutls_alert_send (session, level, alert);
}
/**
* gnutls_alert_get - Returns the last alert number received.
* @session: is a #mhd_gtls_session_t structure.
* MHD_gnutls_alert_get - Returns the last alert number received.
* @session: is a #MHD_gtls_session_t structure.
*
* This function will return the last alert number received. This
* function should be called if GNUTLS_E_WARNING_ALERT_RECEIVED or
@@ -288,8 +288,8 @@ MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err)
* If no alert has been received the returned value is undefined.
*
**/
gnutls_alert_description_t
gnutls_alert_get (mhd_gtls_session_t session)
MHD_gnutls_alert_description_t
MHD_gnutls_alert_get (MHD_gtls_session_t session)
{
return session->internals.last_alert;
}
src/daemon/https/tls/gnutls_algorithms.c
+207 -207
View File
@@ -39,9 +39,9 @@ typedef struct
enum MHD_GNUTLS_CredentialsType client_type;
enum MHD_GNUTLS_CredentialsType server_type; /* The type of credentials a server
* needs to set */
} gnutls_cred_map;
} MHD_gnutls_cred_map;
static const gnutls_cred_map mhd_gtls_cred_mappings[] = {
static const MHD_gnutls_cred_map MHD_gtls_cred_mappings[] = {
{MHD_GNUTLS_KX_ANON_DH,
MHD_GNUTLS_CRD_ANON,
MHD_GNUTLS_CRD_ANON},
@@ -72,8 +72,8 @@ static const gnutls_cred_map mhd_gtls_cred_mappings[] = {
};
#define GNUTLS_KX_MAP_LOOP(b) \
const gnutls_cred_map *p; \
for(p = mhd_gtls_cred_mappings; p->algorithm != 0; p++) { b ; }
const MHD_gnutls_cred_map *p; \
for(p = MHD_gtls_cred_mappings; p->algorithm != 0; p++) { b ; }
#define GNUTLS_KX_MAP_ALG_LOOP_SERVER(a) \
GNUTLS_KX_MAP_LOOP( if(p->server_type == type) { a; break; })
@@ -93,14 +93,14 @@ typedef struct
* This is useful to certificate cipher suites, which check
* against the certificate key usage bits.
*/
} gnutls_pk_map;
} MHD_gnutls_pk_map;
/* This table maps the Key exchange algorithms to
* the certificate algorithms. Eg. if we have
* RSA algorithm in the certificate then we can
* use GNUTLS_KX_RSA or GNUTLS_KX_DHE_RSA.
*/
static const gnutls_pk_map mhd_gtls_pk_mappings[] = {
static const MHD_gnutls_pk_map MHD_gtls_pk_mappings[] = {
{MHD_GNUTLS_KX_RSA,
MHD_GNUTLS_PK_RSA,
CIPHER_ENCRYPT},
@@ -119,8 +119,8 @@ static const gnutls_pk_map mhd_gtls_pk_mappings[] = {
};
#define GNUTLS_PK_MAP_LOOP(b) \
const gnutls_pk_map *p; \
for(p = mhd_gtls_pk_mappings; p->kx_algorithm != 0; p++) { b }
const MHD_gnutls_pk_map *p; \
for(p = MHD_gtls_pk_mappings; p->kx_algorithm != 0; p++) { b }
#define GNUTLS_PK_MAP_ALG_LOOP(a) \
GNUTLS_PK_MAP_LOOP( if(p->kx_algorithm == kx_algorithm) { a; break; })
@@ -134,9 +134,9 @@ typedef struct
int major; /* defined by the protocol */
int minor; /* defined by the protocol */
int supported; /* 0 not supported, > 0 is supported */
} gnutls_version_entry;
} MHD_gnutls_version_entry;
static const gnutls_version_entry mhd_gtls_sup_versions[] = {
static const MHD_gnutls_version_entry MHD_gtls_sup_versions[] = {
{"SSL3.0",
MHD_GNUTLS_PROTOCOL_SSL3,
3,
@@ -165,7 +165,7 @@ static const gnutls_version_entry mhd_gtls_sup_versions[] = {
};
/* Keep the contents of this struct the same as the previous one. */
static const enum MHD_GNUTLS_Protocol mhd_gtls_supported_protocols[] =
static const enum MHD_GNUTLS_Protocol MHD_gtls_supported_protocols[] =
{ MHD_GNUTLS_PROTOCOL_SSL3,
MHD_GNUTLS_PROTOCOL_TLS1_0,
MHD_GNUTLS_PROTOCOL_TLS1_1,
@@ -174,13 +174,13 @@ static const enum MHD_GNUTLS_Protocol mhd_gtls_supported_protocols[] =
};
#define GNUTLS_VERSION_LOOP(b) \
const gnutls_version_entry *p; \
for(p = mhd_gtls_sup_versions; p->name != NULL; p++) { b ; }
const MHD_gnutls_version_entry *p; \
for(p = MHD_gtls_sup_versions; p->name != NULL; p++) { b ; }
#define GNUTLS_VERSION_ALG_LOOP(a) \
GNUTLS_VERSION_LOOP( if(p->id == version) { a; break; })
struct gnutls_cipher_entry
struct MHD_gnutls_cipher_entry
{
const char *name;
enum MHD_GNUTLS_CipherAlgorithm id;
@@ -190,14 +190,14 @@ struct gnutls_cipher_entry
uint16_t iv;
int export_flag; /* 0 non export */
};
typedef struct gnutls_cipher_entry gnutls_cipher_entry;
typedef struct MHD_gnutls_cipher_entry MHD_gnutls_cipher_entry;
/* Note that all algorithms are in CBC or STREAM modes.
* Do not add any algorithms in other modes (avoid modified algorithms).
* View first: "The order of encryption and authentication for
* protecting communications" by Hugo Krawczyk - CRYPTO 2001
*/
static const gnutls_cipher_entry mhd_gtls_algorithms[] = {
static const MHD_gnutls_cipher_entry MHD_gtls_algorithms[] = {
{"AES-256-CBC",
MHD_GNUTLS_CIPHER_AES_256_CBC,
16,
@@ -272,7 +272,7 @@ static const gnutls_cipher_entry mhd_gtls_algorithms[] = {
};
/* Keep the contents of this struct the same as the previous one. */
static const enum MHD_GNUTLS_CipherAlgorithm mhd_gtls_supported_ciphers[] =
static const enum MHD_GNUTLS_CipherAlgorithm MHD_gtls_supported_ciphers[] =
{ MHD_GNUTLS_CIPHER_AES_256_CBC,
MHD_GNUTLS_CIPHER_AES_128_CBC,
MHD_GNUTLS_CIPHER_3DES_CBC,
@@ -289,22 +289,22 @@ static const enum MHD_GNUTLS_CipherAlgorithm mhd_gtls_supported_ciphers[] =
};
#define GNUTLS_LOOP(b) \
const gnutls_cipher_entry *p; \
for(p = mhd_gtls_algorithms; p->name != NULL; p++) { b ; }
const MHD_gnutls_cipher_entry *p; \
for(p = MHD_gtls_algorithms; p->name != NULL; p++) { b ; }
#define GNUTLS_ALG_LOOP(a) \
GNUTLS_LOOP( if(p->id == algorithm) { a; break; } )
struct gnutls_hash_entry
struct MHD_gnutls_hash_entry
{
const char *name;
const char *oid;
enum MHD_GNUTLS_HashAlgorithm id;
size_t key_size; /* in case of mac */
};
typedef struct gnutls_hash_entry gnutls_hash_entry;
typedef struct MHD_gnutls_hash_entry MHD_gnutls_hash_entry;
static const gnutls_hash_entry mhd_gtls_hash_algorithms[] = {
static const MHD_gnutls_hash_entry MHD_gtls_hash_algorithms[] = {
{"SHA1",
HASH_OID_SHA1,
MHD_GNUTLS_MAC_SHA1,
@@ -328,7 +328,7 @@ static const gnutls_hash_entry mhd_gtls_hash_algorithms[] = {
};
/* Keep the contents of this struct the same as the previous one. */
static const enum MHD_GNUTLS_HashAlgorithm mhd_gtls_supported_macs[] =
static const enum MHD_GNUTLS_HashAlgorithm MHD_gtls_supported_macs[] =
{ MHD_GNUTLS_MAC_SHA1,
MHD_GNUTLS_MAC_MD5,
MHD_GNUTLS_MAC_SHA256,
@@ -337,8 +337,8 @@ static const enum MHD_GNUTLS_HashAlgorithm mhd_gtls_supported_macs[] =
};
#define GNUTLS_HASH_LOOP(b) \
const gnutls_hash_entry *p; \
for(p = mhd_gtls_hash_algorithms; p->name != NULL; p++) { b ; }
const MHD_gnutls_hash_entry *p; \
for(p = MHD_gtls_hash_algorithms; p->name != NULL; p++) { b ; }
#define GNUTLS_HASH_ALG_LOOP(a) \
GNUTLS_HASH_LOOP( if(p->id == algorithm) { a; break; } )
@@ -348,11 +348,11 @@ static const enum MHD_GNUTLS_HashAlgorithm mhd_gtls_supported_macs[] =
{ #name, name, id, wb, ml, cl}
#define MAX_COMP_METHODS 5
const int _gnutls_comp_algorithms_size = MAX_COMP_METHODS;
const int MHD__gnutls_comp_algorithms_size = MAX_COMP_METHODS;
/* the compression entry is defined in gnutls_algorithms.h */
/* the compression entry is defined in MHD_gnutls_algorithms.h */
gnutls_compression_entry _gnutls_compression_algorithms[MAX_COMP_METHODS] =
MHD_gnutls_compression_entry MHD__gnutls_compression_algorithms[MAX_COMP_METHODS] =
{ GNUTLS_COMPRESSION_ENTRY (MHD_GNUTLS_COMP_NULL, 0x00, 0, 0, 0),
#ifdef HAVE_LIBZ
/* draft-ietf-tls-compression-02 */
@@ -367,7 +367,7 @@ gnutls_compression_entry _gnutls_compression_algorithms[MAX_COMP_METHODS] =
};
static const enum MHD_GNUTLS_CompressionMethod
mhd_gtls_supported_compressions[] =
MHD_gtls_supported_compressions[] =
{
#ifdef HAVE_LIBZ
MHD_GNUTLS_COMP_DEFLATE,
@@ -377,41 +377,41 @@ static const enum MHD_GNUTLS_CompressionMethod
};
#define GNUTLS_COMPRESSION_LOOP(b) \
const gnutls_compression_entry *p; \
for(p = _gnutls_compression_algorithms; p->name != NULL; p++) { b ; }
const MHD_gnutls_compression_entry *p; \
for(p = MHD__gnutls_compression_algorithms; p->name != NULL; p++) { b ; }
#define GNUTLS_COMPRESSION_ALG_LOOP(a) \
GNUTLS_COMPRESSION_LOOP( if(p->id == algorithm) { a; break; } )
#define GNUTLS_COMPRESSION_ALG_LOOP_NUM(a) \
GNUTLS_COMPRESSION_LOOP( if(p->num == num) { a; break; } )
/* Key Exchange Section */
extern mhd_gtls_mod_auth_st mhd_gtls_rsa_auth_struct;
extern mhd_gtls_mod_auth_st rsa_export_auth_struct;
extern mhd_gtls_mod_auth_st mhd_gtls_dhe_rsa_auth_struct;
extern mhd_gtls_mod_auth_st mhd_gtls_dhe_dss_auth_struct;
extern mhd_gtls_mod_auth_st mhd_gtls_anon_auth_struct;
extern mhd_gtls_mod_auth_st srp_auth_struct;
extern mhd_gtls_mod_auth_st psk_auth_struct;
extern mhd_gtls_mod_auth_st dhe_psk_auth_struct;
extern mhd_gtls_mod_auth_st srp_rsa_auth_struct;
extern mhd_gtls_mod_auth_st srp_dss_auth_struct;
extern MHD_gtls_mod_auth_st MHD_gtls_rsa_auth_struct;
extern MHD_gtls_mod_auth_st rsa_export_auth_struct;
extern MHD_gtls_mod_auth_st MHD_gtls_dhe_rsa_auth_struct;
extern MHD_gtls_mod_auth_st MHD_gtls_dhe_dss_auth_struct;
extern MHD_gtls_mod_auth_st MHD_gtls_anon_auth_struct;
extern MHD_gtls_mod_auth_st srp_auth_struct;
extern MHD_gtls_mod_auth_st psk_auth_struct;
extern MHD_gtls_mod_auth_st dhe_psk_auth_struct;
extern MHD_gtls_mod_auth_st srp_rsa_auth_struct;
extern MHD_gtls_mod_auth_st srp_dss_auth_struct;
typedef struct mhd_gtls_kx_algo_entry
typedef struct MHD_gtls_kx_algo_entry
{
const char *name;
enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm;
mhd_gtls_mod_auth_st *auth_struct;
MHD_gtls_mod_auth_st *auth_struct;
int needs_dh_params;
int needs_rsa_params;
} mhd_gtls_kx_algo_entry_t;
} MHD_gtls_kx_algo_entry_t;
static const mhd_gtls_kx_algo_entry_t mhd_gtls_kx_algorithms[] = {
static const MHD_gtls_kx_algo_entry_t MHD_gtls_kx_algorithms[] = {
#ifdef ENABLE_ANON
{"ANON-DH", MHD_GNUTLS_KX_ANON_DH, &mhd_gtls_anon_auth_struct, 1, 0},
{"ANON-DH", MHD_GNUTLS_KX_ANON_DH, &MHD_gtls_anon_auth_struct, 1, 0},
#endif
{"RSA",
MHD_GNUTLS_KX_RSA,
&mhd_gtls_rsa_auth_struct,
&MHD_gtls_rsa_auth_struct,
0,
0},
{"RSA-EXPORT",
@@ -421,12 +421,12 @@ static const mhd_gtls_kx_algo_entry_t mhd_gtls_kx_algorithms[] = {
1 /* needs RSA params */ },
{"DHE-RSA",
MHD_GNUTLS_KX_DHE_RSA,
&mhd_gtls_dhe_rsa_auth_struct,
&MHD_gtls_dhe_rsa_auth_struct,
1,
0},
{"DHE-DSS",
MHD_GNUTLS_KX_DHE_DSS,
&mhd_gtls_dhe_dss_auth_struct,
&MHD_gtls_dhe_dss_auth_struct,
1,
0},
@@ -448,7 +448,7 @@ static const mhd_gtls_kx_algo_entry_t mhd_gtls_kx_algorithms[] = {
};
/* Keep the contents of this struct the same as the previous one. */
static const enum MHD_GNUTLS_KeyExchangeAlgorithm mhd_gtls_supported_kxs[] =
static const enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gtls_supported_kxs[] =
{
#ifdef ENABLE_ANON
MHD_GNUTLS_KX_ANON_DH,
@@ -470,8 +470,8 @@ static const enum MHD_GNUTLS_KeyExchangeAlgorithm mhd_gtls_supported_kxs[] =
};
#define GNUTLS_KX_LOOP(b) \
const mhd_gtls_kx_algo_entry_t *p; \
for(p = mhd_gtls_kx_algorithms; p->name != NULL; p++) { b ; }
const MHD_gtls_kx_algo_entry_t *p; \
for(p = MHD_gtls_kx_algorithms; p->name != NULL; p++) { b ; }
#define GNUTLS_KX_ALG_LOOP(a) \
GNUTLS_KX_LOOP( if(p->algorithm == algorithm) { a; break; } )
@@ -490,7 +490,7 @@ typedef struct
enum MHD_GNUTLS_Protocol version; /* this cipher suite is supported
* from 'version' and above;
*/
} mhd_gtls_cipher_suite_entry;
} MHD_gtls_cipher_suite_entry;
/* RSA with NULL cipher and MD5 MAC
* for test purposes.
@@ -586,9 +586,9 @@ typedef struct
#define GNUTLS_DHE_RSA_CAMELLIA_128_CBC_SHA1 { 0x00,0x45 }
#define GNUTLS_DHE_RSA_CAMELLIA_256_CBC_SHA1 { 0x00,0x88 }
#define CIPHER_SUITES_COUNT sizeof(mhd_gtls_cs_algorithms)/sizeof(mhd_gtls_cipher_suite_entry)-1
#define CIPHER_SUITES_COUNT sizeof(MHD_gtls_cs_algorithms)/sizeof(MHD_gtls_cipher_suite_entry)-1
static const mhd_gtls_cipher_suite_entry mhd_gtls_cs_algorithms[] = {
static const MHD_gtls_cipher_suite_entry MHD_gtls_cs_algorithms[] = {
/* ANON_DH */
GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_ARCFOUR_MD5,
MHD_GNUTLS_CIPHER_ARCFOUR_128,
@@ -758,8 +758,8 @@ static const mhd_gtls_cipher_suite_entry mhd_gtls_cs_algorithms[] = {
};
#define GNUTLS_CIPHER_SUITE_LOOP(b) \
const mhd_gtls_cipher_suite_entry *p; \
for(p = mhd_gtls_cs_algorithms; p->name != NULL; p++) { b ; }
const MHD_gtls_cipher_suite_entry *p; \
for(p = MHD_gtls_cs_algorithms; p->name != NULL; p++) { b ; }
#define GNUTLS_CIPHER_SUITE_ALG_LOOP(a) \
GNUTLS_CIPHER_SUITE_LOOP( if( (p->id.suite[0] == suite->suite[0]) && (p->id.suite[1] == suite->suite[1])) { a; break; } )
@@ -767,7 +767,7 @@ static const mhd_gtls_cipher_suite_entry mhd_gtls_cs_algorithms[] = {
/* Generic Functions */
int
mhd_gtls_mac_priority (mhd_gtls_session_t session,
MHD_gtls_mac_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_HashAlgorithm algorithm)
{ /* actually returns the priority */
unsigned int i;
@@ -780,14 +780,14 @@ mhd_gtls_mac_priority (mhd_gtls_session_t session,
}
/**
* MHD_gnutls_mac_get_name - Returns a string with the name of the specified mac algorithm
* MHD__gnutls_mac_get_name - Returns a string with the name of the specified mac algorithm
* @algorithm: is a MAC algorithm
*
* Returns: a string that contains the name of the specified MAC
* algorithm, or %NULL.
**/
const char *
MHD_gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm algorithm)
MHD__gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm algorithm)
{
const char *ret = NULL;
@@ -817,7 +817,7 @@ MHD_gtls_mac_get_id (const char *name)
}
/**
* MHD_gnutls_mac_get_key_size - Returns the length of the MAC's key size
* MHD__gnutls_mac_get_key_size - Returns the length of the MAC's key size
* @algorithm: is an encryption algorithm
*
* Returns: length (in bytes) of the given MAC key size, or 0 if the
@@ -825,7 +825,7 @@ MHD_gtls_mac_get_id (const char *name)
*
**/
size_t
MHD_gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm algorithm)
MHD__gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm algorithm)
{
size_t ret = 0;
@@ -849,11 +849,11 @@ MHD_gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm algorithm)
const enum MHD_GNUTLS_HashAlgorithm *
MHD_gtls_mac_list (void)
{
return mhd_gtls_supported_macs;
return MHD_gtls_supported_macs;
}
const char *
mhd_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm algorithm)
MHD_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm algorithm)
{
const char *ret = NULL;
@@ -864,7 +864,7 @@ mhd_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm algorithm)
}
enum MHD_GNUTLS_HashAlgorithm
mhd_gtls_x509_oid2mac_algorithm (const char *oid)
MHD_gtls_x509_oid2mac_algorithm (const char *oid)
{
enum MHD_GNUTLS_HashAlgorithm ret = 0;
@@ -880,7 +880,7 @@ mhd_gtls_x509_oid2mac_algorithm (const char *oid)
}
int
mhd_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm)
MHD_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm)
{
ssize_t ret = -1;
GNUTLS_HASH_ALG_LOOP (ret = p->id);
@@ -893,7 +893,7 @@ mhd_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm)
/* Compression Functions */
int
mhd_gtls_compression_priority (mhd_gtls_session_t session,
MHD_gtls_compression_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_CompressionMethod algorithm)
{ /* actually returns the priority */
unsigned int i;
@@ -907,7 +907,7 @@ mhd_gtls_compression_priority (mhd_gtls_session_t session,
}
/**
* MHD_gnutls_compression_get_name - Returns a string with the name of the specified compression algorithm
* MHD__gnutls_compression_get_name - Returns a string with the name of the specified compression algorithm
* @algorithm: is a Compression algorithm
*
* Returns: a pointer to a string that contains the name of the
@@ -953,7 +953,7 @@ MHD_gtls_compression_get_id (const char *name)
*
* Get a list of compression methods. Note that to be able to use LZO
* compression, you must link to libgnutls-extra and call
* gnutls_global_init_extra().
* MHD_gnutls_global_init_extra().
*
* Returns: a zero-terminated list of %enum MHD_GNUTLS_CompressionMethod
* integers indicating the available compression methods.
@@ -961,12 +961,12 @@ MHD_gtls_compression_get_id (const char *name)
const enum MHD_GNUTLS_CompressionMethod *
MHD_gtls_compression_list (void)
{
return mhd_gtls_supported_compressions;
return MHD_gtls_supported_compressions;
}
/* return the tls number of the specified algorithm */
int
mhd_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod algorithm)
MHD_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod algorithm)
{
int ret = -1;
@@ -977,7 +977,7 @@ mhd_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod algorithm)
}
int
mhd_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod algorithm)
MHD_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod algorithm)
{
int ret = -1;
/* avoid prefix */
@@ -986,7 +986,7 @@ mhd_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod algorithm)
}
int
mhd_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
MHD_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
algorithm)
{
int ret = -1;
@@ -996,7 +996,7 @@ mhd_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
}
int
mhd_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
MHD_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
algorithm)
{
int ret = -1;
@@ -1009,7 +1009,7 @@ mhd_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
* method num
*/
enum MHD_GNUTLS_CompressionMethod
mhd_gtls_compression_get_id (int num)
MHD_gtls_compression_get_id_from_int (int num)
{
enum MHD_GNUTLS_CompressionMethod ret = -1;
@@ -1020,7 +1020,7 @@ mhd_gtls_compression_get_id (int num)
}
int
mhd_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm)
MHD_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm)
{
ssize_t ret = -1;
GNUTLS_COMPRESSION_ALG_LOOP (ret = p->id);
@@ -1033,7 +1033,7 @@ mhd_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm)
/* CIPHER functions */
int
mhd_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
MHD_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
{
size_t ret = 0;
GNUTLS_ALG_LOOP (ret = p->blocksize);
@@ -1043,7 +1043,7 @@ mhd_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
/* returns the priority */
int
mhd_gtls_cipher_priority (mhd_gtls_session_t session,
MHD_gtls_cipher_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_CipherAlgorithm algorithm)
{
unsigned int i;
@@ -1056,7 +1056,7 @@ mhd_gtls_cipher_priority (mhd_gtls_session_t session,
}
int
mhd_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm)
MHD_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm)
{
size_t ret = 0;
@@ -1066,14 +1066,14 @@ mhd_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm)
}
/**
* MHD_gnutls_cipher_get_key_size - Returns the length of the cipher's key size
* MHD__gnutls_cipher_get_key_size - Returns the length of the cipher's key size
* @algorithm: is an encryption algorithm
*
* Returns: length (in bytes) of the given cipher's key size, o 0 if
* the given cipher is invalid.
**/
size_t
MHD_gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
MHD__gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
{ /* In bytes */
size_t ret = 0;
GNUTLS_ALG_LOOP (ret = p->keysize);
@@ -1082,7 +1082,7 @@ MHD_gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
}
int
mhd_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
MHD_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
{ /* In bytes */
size_t ret = 0;
GNUTLS_ALG_LOOP (ret = p->iv);
@@ -1091,7 +1091,7 @@ mhd_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
}
int
mhd_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm algorithm)
MHD_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm algorithm)
{ /* In bytes */
size_t ret = 0;
GNUTLS_ALG_LOOP (ret = p->export_flag);
@@ -1100,14 +1100,14 @@ mhd_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm algorithm)
}
/**
* MHD_gnutls_cipher_get_name - Returns a string with the name of the specified cipher algorithm
* MHD__gnutls_cipher_get_name - Returns a string with the name of the specified cipher algorithm
* @algorithm: is an encryption algorithm
*
* Returns: a pointer to a string that contains the name of the
* specified cipher, or %NULL.
**/
const char *
MHD_gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm algorithm)
MHD__gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm algorithm)
{
const char *ret = NULL;
@@ -1153,11 +1153,11 @@ MHD_gtls_cipher_get_id (const char *name)
const enum MHD_GNUTLS_CipherAlgorithm *
MHD_gtls_cipher_list (void)
{
return mhd_gtls_supported_ciphers;
return MHD_gtls_supported_ciphers;
}
int
mhd_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm)
MHD_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm)
{
ssize_t ret = -1;
GNUTLS_ALG_LOOP (ret = p->id);
@@ -1169,17 +1169,17 @@ mhd_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm)
}
/* Key EXCHANGE functions */
mhd_gtls_mod_auth_st *
mhd_gtls_kx_auth_struct (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
MHD_gtls_mod_auth_st *
MHD_gtls_kx_auth_struct (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
{
mhd_gtls_mod_auth_st *ret = NULL;
MHD_gtls_mod_auth_st *ret = NULL;
GNUTLS_KX_ALG_LOOP (ret = p->auth_struct);
return ret;
}
int
mhd_gtls_kx_priority (mhd_gtls_session_t session,
MHD_gtls_kx_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
{
unsigned int i;
@@ -1192,14 +1192,14 @@ mhd_gtls_kx_priority (mhd_gtls_session_t session,
}
/**
* MHD_gnutls_kx_get_name - Returns a string with the name of the specified key exchange algorithm
* MHD__gnutls_kx_get_name - Returns a string with the name of the specified key exchange algorithm
* @algorithm: is a key exchange algorithm
*
* Returns: a pointer to a string that contains the name of the
* specified key exchange algorithm, or %NULL.
**/
const char *
MHD_gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
MHD__gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
{
const char *ret = NULL;
@@ -1240,11 +1240,11 @@ MHD_gtls_kx_get_id (const char *name)
const enum MHD_GNUTLS_KeyExchangeAlgorithm *
MHD_gtls_kx_list (void)
{
return mhd_gtls_supported_kxs;
return MHD_gtls_supported_kxs;
}
int
mhd_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
MHD_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
{
ssize_t ret = -1;
GNUTLS_KX_ALG_LOOP (ret = p->algorithm);
@@ -1256,7 +1256,7 @@ mhd_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
}
int
mhd_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
MHD_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
{
ssize_t ret = 0;
GNUTLS_KX_ALG_LOOP (ret = p->needs_rsa_params);
@@ -1264,7 +1264,7 @@ mhd_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
}
int
mhd_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
MHD_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
{
ssize_t ret = 0;
GNUTLS_KX_ALG_LOOP (ret = p->needs_dh_params);
@@ -1273,14 +1273,14 @@ mhd_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
/* Version */
int
mhd_gtls_version_priority (mhd_gtls_session_t session,
MHD_gtls_version_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_Protocol version)
{ /* actually returns the priority */
unsigned int i;
if (session->internals.priorities.protocol.priority == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return -1;
}
@@ -1293,7 +1293,7 @@ mhd_gtls_version_priority (mhd_gtls_session_t session,
}
enum MHD_GNUTLS_Protocol
mhd_gtls_version_lowest (mhd_gtls_session_t session)
MHD_gtls_version_lowest (MHD_gtls_session_t session)
{ /* returns the lowest version supported */
unsigned int i, min = 0xff;
@@ -1316,7 +1316,7 @@ mhd_gtls_version_lowest (mhd_gtls_session_t session)
}
enum MHD_GNUTLS_Protocol
mhd_gtls_version_max (mhd_gtls_session_t session)
MHD_gtls_version_max (MHD_gtls_session_t session)
{ /* returns the maximum version supported */
unsigned int i, max = 0x00;
@@ -1339,14 +1339,14 @@ mhd_gtls_version_max (mhd_gtls_session_t session)
}
/**
* MHD_gnutls_protocol_get_name - Returns a string with the name of the specified SSL/TLS version
* MHD__gnutls_protocol_get_name - Returns a string with the name of the specified SSL/TLS version
* @version: is a (gnutls) version number
*
* Returns: a string that contains the name of the specified TLS
* version (e.g., "TLS 1.0"), or %NULL.
**/
const char *
MHD_gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version)
MHD__gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version)
{
const char *ret = NULL;
@@ -1387,11 +1387,11 @@ MHD_gtls_protocol_get_id (const char *name)
const enum MHD_GNUTLS_Protocol *
MHD_gtls_protocol_list (void)
{
return mhd_gtls_supported_protocols;
return MHD_gtls_supported_protocols;
}
int
mhd_gtls_version_get_minor (enum MHD_GNUTLS_Protocol version)
MHD_gtls_version_get_minor (enum MHD_GNUTLS_Protocol version)
{
int ret = -1;
@@ -1400,7 +1400,7 @@ mhd_gtls_version_get_minor (enum MHD_GNUTLS_Protocol version)
}
enum MHD_GNUTLS_Protocol
mhd_gtls_version_get (int major, int minor)
MHD_gtls_version_get (int major, int minor)
{
int ret = -1;
@@ -1411,7 +1411,7 @@ mhd_gtls_version_get (int major, int minor)
}
int
mhd_gtls_version_get_major (enum MHD_GNUTLS_Protocol version)
MHD_gtls_version_get_major (enum MHD_GNUTLS_Protocol version)
{
int ret = -1;
@@ -1422,7 +1422,7 @@ mhd_gtls_version_get_major (enum MHD_GNUTLS_Protocol version)
/* Version Functions */
int
mhd_gtls_version_is_supported (mhd_gtls_session_t session,
MHD_gtls_version_is_supported (MHD_gtls_session_t session,
const enum MHD_GNUTLS_Protocol version)
{
int ret = 0;
@@ -1431,7 +1431,7 @@ mhd_gtls_version_is_supported (mhd_gtls_session_t session,
if (ret == 0)
return 0;
if (mhd_gtls_version_priority (session, version) < 0)
if (MHD_gtls_version_priority (session, version) < 0)
return 0; /* disabled by the user */
else
return 1;
@@ -1439,7 +1439,7 @@ mhd_gtls_version_is_supported (mhd_gtls_session_t session,
/* Type to KX mappings */
enum MHD_GNUTLS_KeyExchangeAlgorithm
mhd_gtls_map_kx_get_kx (enum MHD_GNUTLS_CredentialsType type, int server)
MHD_gtls_map_kx_get_kx (enum MHD_GNUTLS_CredentialsType type, int server)
{
enum MHD_GNUTLS_KeyExchangeAlgorithm ret = -1;
@@ -1455,7 +1455,7 @@ mhd_gtls_map_kx_get_kx (enum MHD_GNUTLS_CredentialsType type, int server)
}
enum MHD_GNUTLS_CredentialsType
mhd_gtls_map_kx_get_cred (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm,
MHD_gtls_map_kx_get_cred (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm,
int server)
{
enum MHD_GNUTLS_CredentialsType ret = -1;
@@ -1475,7 +1475,7 @@ mhd_gtls_map_kx_get_cred (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm,
/* Cipher Suite's functions */
enum MHD_GNUTLS_CipherAlgorithm
mhd_gtls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
MHD_gtls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
{
int ret = 0;
GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->block_algorithm);
@@ -1483,7 +1483,7 @@ mhd_gtls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
}
enum MHD_GNUTLS_Protocol
mhd_gtls_cipher_suite_get_version (const cipher_suite_st * suite)
MHD_gtls_cipher_suite_get_version (const cipher_suite_st * suite)
{
int ret = 0;
GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->version);
@@ -1491,7 +1491,7 @@ mhd_gtls_cipher_suite_get_version (const cipher_suite_st * suite)
}
enum MHD_GNUTLS_KeyExchangeAlgorithm
mhd_gtls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
MHD_gtls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
{
int ret = 0;
@@ -1501,7 +1501,7 @@ mhd_gtls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
}
enum MHD_GNUTLS_HashAlgorithm
mhd_gtls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
MHD_gtls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
{ /* In bytes */
int ret = 0;
GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->mac_algorithm);
@@ -1510,7 +1510,7 @@ mhd_gtls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
}
const char *
mhd_gtls_cipher_suite_get_name (cipher_suite_st * suite)
MHD_gtls_cipher_suite_get_name (cipher_suite_st * suite)
{
const char *ret = NULL;
@@ -1521,7 +1521,7 @@ mhd_gtls_cipher_suite_get_name (cipher_suite_st * suite)
}
static inline int
_gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
MHD__gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
{
size_t ret;
const char *name = NULL;
@@ -1541,11 +1541,11 @@ _gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
#define MAX_ELEM_SIZE 4
static inline int
_gnutls_partition (mhd_gtls_session_t session,
MHD__gnutls_partition (MHD_gtls_session_t session,
void *_base,
size_t nmemb,
size_t size,
int (*compar) (mhd_gtls_session_t,
int (*compar) (MHD_gtls_session_t,
const void *, const void *))
{
uint8_t *base = _base;
@@ -1589,11 +1589,11 @@ _gnutls_partition (mhd_gtls_session_t session,
}
static void
_gnutls_qsort (mhd_gtls_session_t session,
MHD__gnutls_qsort (MHD_gtls_session_t session,
void *_base,
size_t nmemb,
size_t size,
int (*compar) (mhd_gtls_session_t, const void *, const void *))
int (*compar) (MHD_gtls_session_t, const void *, const void *))
{
unsigned int pivot;
char *base = _base;
@@ -1602,19 +1602,19 @@ _gnutls_qsort (mhd_gtls_session_t session,
#ifdef DEBUG
if (size > MAX_ELEM_SIZE)
{
gnutls_assert ();
_gnutls_debug_log ("QSORT BUG\n");
MHD_gnutls_assert ();
MHD__gnutls_debug_log ("QSORT BUG\n");
exit (1);
}
#endif
if (snmemb <= 1)
return;
pivot = _gnutls_partition (session, _base, nmemb, size, compar);
pivot = MHD__gnutls_partition (session, _base, nmemb, size, compar);
_gnutls_qsort (session, base, pivot < nmemb ? pivot + 1
MHD__gnutls_qsort (session, base, pivot < nmemb ? pivot + 1
: pivot, size, compar);
_gnutls_qsort (session, &base[(pivot + 1) * size], nmemb - pivot - 1, size,
MHD__gnutls_qsort (session, &base[(pivot + 1) * size], nmemb - pivot - 1, size,
compar);
}
@@ -1622,28 +1622,28 @@ _gnutls_qsort (mhd_gtls_session_t session,
* For use with qsort
*/
static int
_gnutls_compare_algo (mhd_gtls_session_t session,
MHD__gnutls_compare_algo (MHD_gtls_session_t session,
const void *i_A1, const void *i_A2)
{
enum MHD_GNUTLS_KeyExchangeAlgorithm kA1 =
mhd_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A1);
MHD_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A1);
enum MHD_GNUTLS_KeyExchangeAlgorithm kA2 =
mhd_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A2);
MHD_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A2);
enum MHD_GNUTLS_CipherAlgorithm cA1 =
mhd_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A1);
MHD_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A1);
enum MHD_GNUTLS_CipherAlgorithm cA2 =
mhd_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A2);
MHD_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A2);
enum MHD_GNUTLS_HashAlgorithm mA1 =
mhd_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A1);
MHD_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A1);
enum MHD_GNUTLS_HashAlgorithm mA2 =
mhd_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A2);
MHD_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A2);
int p1 = (mhd_gtls_kx_priority (session, kA1) + 1) * 64;
int p2 = (mhd_gtls_kx_priority (session, kA2) + 1) * 64;
p1 += (mhd_gtls_cipher_priority (session, cA1) + 1) * 8;
p2 += (mhd_gtls_cipher_priority (session, cA2) + 1) * 8;
p1 += mhd_gtls_mac_priority (session, mA1);
p2 += mhd_gtls_mac_priority (session, mA2);
int p1 = (MHD_gtls_kx_priority (session, kA1) + 1) * 64;
int p2 = (MHD_gtls_kx_priority (session, kA2) + 1) * 64;
p1 += (MHD_gtls_cipher_priority (session, cA1) + 1) * 8;
p2 += (MHD_gtls_cipher_priority (session, cA2) + 1) * 8;
p1 += MHD_gtls_mac_priority (session, mA1);
p2 += MHD_gtls_mac_priority (session, mA2);
if (p1 > p2)
{
@@ -1661,8 +1661,8 @@ _gnutls_compare_algo (mhd_gtls_session_t session,
#ifdef SORT_DEBUG
static void
_gnutls_bsort (mhd_gtls_session_t session, void *_base, size_t nmemb,
size_t size, int (*compar) (mhd_gtls_session_t, const void *,
MHD__gnutls_bsort (MHD_gtls_session_t session, void *_base, size_t nmemb,
size_t size, int (*compar) (MHD_gtls_session_t, const void *,
const void *))
{
unsigned int i, j;
@@ -1685,7 +1685,7 @@ _gnutls_bsort (mhd_gtls_session_t session, void *_base, size_t nmemb,
#endif
int
mhd_gtls_supported_ciphersuites_sorted (mhd_gtls_session_t session,
MHD_gtls_supported_ciphersuites_sorted (MHD_gtls_session_t session,
cipher_suite_st ** ciphers)
{
@@ -1694,34 +1694,34 @@ mhd_gtls_supported_ciphersuites_sorted (mhd_gtls_session_t session,
#endif
int count;
count = mhd_gtls_supported_ciphersuites (session, ciphers);
count = MHD_gtls_supported_ciphersuites (session, ciphers);
if (count <= 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return count;
}
#ifdef SORT_DEBUG
_gnutls_debug_log ("Unsorted: \n");
MHD__gnutls_debug_log ("Unsorted: \n");
for (i = 0; i < count; i++)
_gnutls_debug_log ("\t%d: %s\n", i,
mhd_gtls_cipher_suite_get_name ((*ciphers)[i]));
MHD__gnutls_debug_log ("\t%d: %s\n", i,
MHD_gtls_cipher_suite_get_name ((*ciphers)[i]));
#endif
_gnutls_qsort (session, *ciphers, count, sizeof (cipher_suite_st),
_gnutls_compare_algo);
MHD__gnutls_qsort (session, *ciphers, count, sizeof (cipher_suite_st),
MHD__gnutls_compare_algo);
#ifdef SORT_DEBUG
_gnutls_debug_log ("Sorted: \n");
MHD__gnutls_debug_log ("Sorted: \n");
for (i = 0; i < count; i++)
_gnutls_debug_log ("\t%d: %s\n", i,
mhd_gtls_cipher_suite_get_name ((*ciphers)[i]));
MHD__gnutls_debug_log ("\t%d: %s\n", i,
MHD_gtls_cipher_suite_get_name ((*ciphers)[i]));
#endif
return count;
}
int
mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
MHD_gtls_supported_ciphersuites (MHD_gtls_session_t session,
cipher_suite_st ** _ciphers)
{
@@ -1736,22 +1736,22 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
return 0;
}
tmp_ciphers = gnutls_alloca (count * sizeof (cipher_suite_st));
tmp_ciphers = MHD_gnutls_alloca (count * sizeof (cipher_suite_st));
if (tmp_ciphers == NULL)
return GNUTLS_E_MEMORY_ERROR;
ciphers = gnutls_malloc (count * sizeof (cipher_suite_st));
ciphers = MHD_gnutls_malloc (count * sizeof (cipher_suite_st));
if (ciphers == NULL)
{
gnutls_afree (tmp_ciphers);
MHD_gnutls_afree (tmp_ciphers);
return GNUTLS_E_MEMORY_ERROR;
}
version = MHD_gnutls_protocol_get_version (session);
version = MHD__gnutls_protocol_get_version (session);
for (i = 0; i < count; i++)
{
memcpy (&tmp_ciphers[i], &mhd_gtls_cs_algorithms[i].id,
memcpy (&tmp_ciphers[i], &MHD_gtls_cs_algorithms[i].id,
sizeof (cipher_suite_st));
}
@@ -1766,19 +1766,19 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
/* remove cipher suites which do not support the
* protocol version used.
*/
if (mhd_gtls_cipher_suite_get_version (&tmp_ciphers[i]) > version)
if (MHD_gtls_cipher_suite_get_version (&tmp_ciphers[i]) > version)
continue;
if (mhd_gtls_kx_priority (session,
mhd_gtls_cipher_suite_get_kx_algo
if (MHD_gtls_kx_priority (session,
MHD_gtls_cipher_suite_get_kx_algo
(&tmp_ciphers[i])) < 0)
continue;
if (mhd_gtls_mac_priority (session,
mhd_gtls_cipher_suite_get_mac_algo
if (MHD_gtls_mac_priority (session,
MHD_gtls_cipher_suite_get_mac_algo
(&tmp_ciphers[i])) < 0)
continue;
if (mhd_gtls_cipher_priority (session,
mhd_gtls_cipher_suite_get_cipher_algo
if (MHD_gtls_cipher_priority (session,
MHD_gtls_cipher_suite_get_cipher_algo
(&tmp_ciphers[i])) < 0)
continue;
@@ -1792,27 +1792,27 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
if (ret_count > 0 && ret_count != count)
{
ciphers =
mhd_gtls_realloc_fast (ciphers, ret_count * sizeof (cipher_suite_st));
MHD_gtls_realloc_fast (ciphers, ret_count * sizeof (cipher_suite_st));
}
else
{
if (ret_count != count)
{
gnutls_free (ciphers);
MHD_gnutls_free (ciphers);
ciphers = NULL;
}
}
#endif
gnutls_afree (tmp_ciphers);
MHD_gnutls_afree (tmp_ciphers);
/* This function can no longer return 0 cipher suites.
* It returns an error code instead.
*/
if (ret_count == 0)
{
gnutls_assert ();
gnutls_free (ciphers);
MHD_gnutls_assert ();
MHD_gnutls_free (ciphers);
return GNUTLS_E_NO_CIPHER_SUITES;
}
*_ciphers = ciphers;
@@ -1827,19 +1827,19 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
*/
#define SUPPORTED_COMPRESSION_METHODS session->internals.priorities.compression.num_algorithms
int
mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
MHD_gtls_supported_compression_methods (MHD_gtls_session_t session,
uint8_t ** comp)
{
unsigned int i, j;
*comp = gnutls_malloc (sizeof (uint8_t) * SUPPORTED_COMPRESSION_METHODS);
*comp = MHD_gnutls_malloc (sizeof (uint8_t) * SUPPORTED_COMPRESSION_METHODS);
if (*comp == NULL)
return GNUTLS_E_MEMORY_ERROR;
for (i = j = 0; i < SUPPORTED_COMPRESSION_METHODS; i++)
{
int tmp =
mhd_gtls_compression_get_num (session->internals.priorities.
MHD_gtls_compression_get_num (session->internals.priorities.
compression.priority[i]);
/* remove private compression algorithms, if requested.
@@ -1847,7 +1847,7 @@ mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
if (tmp == -1 || (tmp >= MIN_PRIVATE_COMP_ALGO
&& session->internals.enable_private == 0))
{
gnutls_assert ();
MHD_gnutls_assert ();
continue;
}
@@ -1857,8 +1857,8 @@ mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
if (j == 0)
{
gnutls_assert ();
gnutls_free (*comp);
MHD_gnutls_assert ();
MHD_gnutls_free (*comp);
*comp = NULL;
return GNUTLS_E_NO_COMPRESSION_ALGORITHMS;
}
@@ -1866,14 +1866,14 @@ mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
}
/**
* MHD_gnutls_certificate_type_get_name - Returns a string with the name of the specified certificate type
* MHD__gnutls_certificate_type_get_name - Returns a string with the name of the specified certificate type
* @type: is a certificate type
*
* Returns: a string (or %NULL) that contains the name of the
* specified certificate type.
**/
const char *
MHD_gnutls_certificate_type_get_name (enum MHD_GNUTLS_CertificateType type)
MHD__gnutls_certificate_type_get_name (enum MHD_GNUTLS_CertificateType type)
{
const char *ret = NULL;
@@ -1902,7 +1902,7 @@ MHD_gtls_certificate_type_get_id (const char *name)
}
static const enum MHD_GNUTLS_CertificateType
mhd_gtls_supported_certificate_types[] =
MHD_gtls_supported_certificate_types[] =
{ MHD_GNUTLS_CRT_X509,
0
};
@@ -1919,14 +1919,14 @@ static const enum MHD_GNUTLS_CertificateType
const enum MHD_GNUTLS_CertificateType *
MHD_gtls_certificate_type_list (void)
{
return mhd_gtls_supported_certificate_types;
return MHD_gtls_supported_certificate_types;
}
/* returns the enum MHD_GNUTLS_PublicKeyAlgorithm which is compatible with
* the given enum MHD_GNUTLS_KeyExchangeAlgorithm.
*/
enum MHD_GNUTLS_PublicKeyAlgorithm
mhd_gtls_map_pk_get_pk (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
MHD_gtls_map_pk_get_pk (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
{
enum MHD_GNUTLS_PublicKeyAlgorithm ret = -1;
@@ -1939,7 +1939,7 @@ mhd_gtls_map_pk_get_pk (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
* ex. GNUTLS_KX_RSA requires a certificate able to encrypt... so returns CIPHER_ENCRYPT.
*/
enum encipher_type
mhd_gtls_kx_encipher_type (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
MHD_gtls_kx_encipher_type (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
{
int ret = CIPHER_IGN;
GNUTLS_PK_MAP_ALG_LOOP (ret = p->encipher_type) return ret;
@@ -1948,17 +1948,17 @@ mhd_gtls_kx_encipher_type (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
/* signature algorithms;
*/
struct gnutls_sign_entry
struct MHD_gnutls_sign_entry
{
const char *name;
const char *oid;
gnutls_sign_algorithm_t id;
MHD_gnutls_sign_algorithm_t id;
enum MHD_GNUTLS_PublicKeyAlgorithm pk;
enum MHD_GNUTLS_HashAlgorithm mac;
};
typedef struct gnutls_sign_entry gnutls_sign_entry;
typedef struct MHD_gnutls_sign_entry MHD_gnutls_sign_entry;
static const gnutls_sign_entry mhd_gtls_sign_algorithms[] = {
static const MHD_gnutls_sign_entry MHD_gtls_sign_algorithms[] = {
{"RSA-SHA",
SIG_RSA_SHA1_OID,
GNUTLS_SIGN_RSA_SHA1,
@@ -1993,17 +1993,17 @@ static const gnutls_sign_entry mhd_gtls_sign_algorithms[] = {
#define GNUTLS_SIGN_LOOP(b) \
do { \
const gnutls_sign_entry *p; \
for(p = mhd_gtls_sign_algorithms; p->name != NULL; p++) { b ; } \
const MHD_gnutls_sign_entry *p; \
for(p = MHD_gtls_sign_algorithms; p->name != NULL; p++) { b ; } \
} while (0)
#define GNUTLS_SIGN_ALG_LOOP(a) \
GNUTLS_SIGN_LOOP( if(p->id && p->id == sign) { a; break; } )
gnutls_sign_algorithm_t
mhd_gtls_x509_oid2sign_algorithm (const char *oid)
MHD_gnutls_sign_algorithm_t
MHD_gtls_x509_oid2sign_algorithm (const char *oid)
{
gnutls_sign_algorithm_t ret = 0;
MHD_gnutls_sign_algorithm_t ret = 0;
GNUTLS_SIGN_LOOP (if (strcmp (oid, p->oid) == 0)
{
@@ -2012,17 +2012,17 @@ mhd_gtls_x509_oid2sign_algorithm (const char *oid)
if (ret == 0)
{
_gnutls_x509_log ("Unknown SIGN OID: '%s'\n", oid);
MHD__gnutls_x509_log ("Unknown SIGN OID: '%s'\n", oid);
return GNUTLS_SIGN_UNKNOWN;
}
return ret;
}
gnutls_sign_algorithm_t
mhd_gtls_x509_pk_to_sign (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
MHD_gnutls_sign_algorithm_t
MHD_gtls_x509_pk_to_sign (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
enum MHD_GNUTLS_HashAlgorithm mac)
{
gnutls_sign_algorithm_t ret = 0;
MHD_gnutls_sign_algorithm_t ret = 0;
GNUTLS_SIGN_LOOP (if (pk == p->pk && mac == p->mac)
{
@@ -2035,13 +2035,13 @@ mhd_gtls_x509_pk_to_sign (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
}
const char *
mhd_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
MHD_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
enum MHD_GNUTLS_HashAlgorithm mac)
{
gnutls_sign_algorithm_t sign;
MHD_gnutls_sign_algorithm_t sign;
const char *ret = NULL;
sign = mhd_gtls_x509_pk_to_sign (pk, mac);
sign = MHD_gtls_x509_pk_to_sign (pk, mac);
if (sign == GNUTLS_SIGN_UNKNOWN)
return NULL;
@@ -2051,15 +2051,15 @@ mhd_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
/* pk algorithms;
*/
struct gnutls_pk_entry
struct MHD_gnutls_pk_entry
{
const char *name;
const char *oid;
enum MHD_GNUTLS_PublicKeyAlgorithm id;
};
typedef struct gnutls_pk_entry gnutls_pk_entry;
typedef struct MHD_gnutls_pk_entry MHD_gnutls_pk_entry;
static const gnutls_pk_entry mhd_gtls_pk_algorithms[] = {
static const MHD_gnutls_pk_entry MHD_gtls_pk_algorithms[] = {
{"RSA",
PK_PKIX1_RSA_OID,
MHD_GNUTLS_PK_RSA},
@@ -2075,12 +2075,12 @@ static const gnutls_pk_entry mhd_gtls_pk_algorithms[] = {
};
enum MHD_GNUTLS_PublicKeyAlgorithm
mhd_gtls_x509_oid2pk_algorithm (const char *oid)
MHD_gtls_x509_oid2pk_algorithm (const char *oid)
{
enum MHD_GNUTLS_PublicKeyAlgorithm ret = MHD_GNUTLS_PK_UNKNOWN;
const gnutls_pk_entry *p;
const MHD_gnutls_pk_entry *p;
for (p = mhd_gtls_pk_algorithms; p->name != NULL; p++)
for (p = MHD_gtls_pk_algorithms; p->name != NULL; p++)
if (strcmp (p->oid, oid) == 0)
{
ret = p->id;
@@ -2091,12 +2091,12 @@ mhd_gtls_x509_oid2pk_algorithm (const char *oid)
}
const char *
mhd_gtls_x509_pk_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm algorithm)
MHD_gtls_x509_pk_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm algorithm)
{
const char *ret = NULL;
const gnutls_pk_entry *p;
const MHD_gnutls_pk_entry *p;
for (p = mhd_gtls_pk_algorithms; p->name != NULL; p++)
for (p = MHD_gtls_pk_algorithms; p->name != NULL; p++)
if (p->id == algorithm)
{
ret = p->oid;
src/daemon/https/tls/gnutls_algorithms.h
+49 -49
View File
@@ -28,105 +28,105 @@
#include "gnutls_auth.h"
/* Functions for version handling. */
enum MHD_GNUTLS_Protocol mhd_gtls_version_lowest (mhd_gtls_session_t session);
enum MHD_GNUTLS_Protocol mhd_gtls_version_max (mhd_gtls_session_t session);
int mhd_gtls_version_priority (mhd_gtls_session_t session,
enum MHD_GNUTLS_Protocol MHD_gtls_version_lowest (MHD_gtls_session_t session);
enum MHD_GNUTLS_Protocol MHD_gtls_version_max (MHD_gtls_session_t session);
int MHD_gtls_version_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_Protocol version);
int mhd_gtls_version_is_supported (mhd_gtls_session_t session,
int MHD_gtls_version_is_supported (MHD_gtls_session_t session,
const enum MHD_GNUTLS_Protocol version);
int mhd_gtls_version_get_major (enum MHD_GNUTLS_Protocol ver);
int mhd_gtls_version_get_minor (enum MHD_GNUTLS_Protocol ver);
enum MHD_GNUTLS_Protocol mhd_gtls_version_get (int major, int minor);
int MHD_gtls_version_get_major (enum MHD_GNUTLS_Protocol ver);
int MHD_gtls_version_get_minor (enum MHD_GNUTLS_Protocol ver);
enum MHD_GNUTLS_Protocol MHD_gtls_version_get (int major, int minor);
/* Functions for MACs. */
int mhd_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm);
enum MHD_GNUTLS_HashAlgorithm mhd_gtls_x509_oid2mac_algorithm (const char
int MHD_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm);
enum MHD_GNUTLS_HashAlgorithm MHD_gtls_x509_oid2mac_algorithm (const char
*oid);
const char *mhd_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm mac);
const char *MHD_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm mac);
/* Functions for cipher suites. */
int mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
int MHD_gtls_supported_ciphersuites (MHD_gtls_session_t session,
cipher_suite_st ** ciphers);
int mhd_gtls_supported_ciphersuites_sorted (mhd_gtls_session_t session,
int MHD_gtls_supported_ciphersuites_sorted (MHD_gtls_session_t session,
cipher_suite_st ** ciphers);
int mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
int MHD_gtls_supported_compression_methods (MHD_gtls_session_t session,
uint8_t ** comp);
const char *mhd_gtls_cipher_suite_get_name (cipher_suite_st * algorithm);
enum MHD_GNUTLS_CipherAlgorithm mhd_gtls_cipher_suite_get_cipher_algo (const
const char *MHD_gtls_cipher_suite_get_name (cipher_suite_st * algorithm);
enum MHD_GNUTLS_CipherAlgorithm MHD_gtls_cipher_suite_get_cipher_algo (const
cipher_suite_st
*
algorithm);
enum MHD_GNUTLS_KeyExchangeAlgorithm mhd_gtls_cipher_suite_get_kx_algo (const
enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gtls_cipher_suite_get_kx_algo (const
cipher_suite_st
*
algorithm);
enum MHD_GNUTLS_HashAlgorithm mhd_gtls_cipher_suite_get_mac_algo (const
enum MHD_GNUTLS_HashAlgorithm MHD_gtls_cipher_suite_get_mac_algo (const
cipher_suite_st
*
algorithm);
enum MHD_GNUTLS_Protocol mhd_gtls_cipher_suite_get_version (const
enum MHD_GNUTLS_Protocol MHD_gtls_cipher_suite_get_version (const
cipher_suite_st *
algorithm);
cipher_suite_st mhd_gtls_cipher_suite_get_suite_name (cipher_suite_st *
cipher_suite_st MHD_gtls_cipher_suite_get_suite_name (cipher_suite_st *
algorithm);
/* Functions for ciphers. */
int mhd_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm
int MHD_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm
algorithm);
int mhd_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm);
int mhd_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm);
int mhd_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm);
int mhd_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm
int MHD_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm);
int MHD_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm);
int MHD_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm);
int MHD_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm
algorithm);
/* Functions for key exchange. */
int mhd_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm
int MHD_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm
algorithm);
int mhd_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm
int MHD_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm
algorithm);
mhd_gtls_mod_auth_st *mhd_gtls_kx_auth_struct (enum
MHD_gtls_mod_auth_st *MHD_gtls_kx_auth_struct (enum
MHD_GNUTLS_KeyExchangeAlgorithm
algorithm);
int mhd_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm);
int MHD_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm);
/* Functions for compression. */
int mhd_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm);
int mhd_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod
int MHD_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm);
int MHD_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod
algorithm);
enum MHD_GNUTLS_CompressionMethod mhd_gtls_compression_get_id (int num);
int mhd_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get_id_from_int (int num);
int MHD_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
algorithm);
int mhd_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
int MHD_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
algorithm);
int mhd_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod
int MHD_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod
algorithm);
/* Type to KX mappings. */
enum MHD_GNUTLS_KeyExchangeAlgorithm mhd_gtls_map_kx_get_kx (enum
enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gtls_map_kx_get_kx (enum
MHD_GNUTLS_CredentialsType
type,
int server);
enum MHD_GNUTLS_CredentialsType mhd_gtls_map_kx_get_cred (enum
enum MHD_GNUTLS_CredentialsType MHD_gtls_map_kx_get_cred (enum
MHD_GNUTLS_KeyExchangeAlgorithm
algorithm,
int server);
/* KX to PK mapping. */
enum MHD_GNUTLS_PublicKeyAlgorithm mhd_gtls_map_pk_get_pk (enum
enum MHD_GNUTLS_PublicKeyAlgorithm MHD_gtls_map_pk_get_pk (enum
MHD_GNUTLS_KeyExchangeAlgorithm
kx_algorithm);
enum MHD_GNUTLS_PublicKeyAlgorithm mhd_gtls_x509_oid2pk_algorithm (const char
enum MHD_GNUTLS_PublicKeyAlgorithm MHD_gtls_x509_oid2pk_algorithm (const char
*oid);
const char *mhd_gtls_x509_pk_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk);
const char *MHD_gtls_x509_pk_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk);
enum encipher_type
{ CIPHER_ENCRYPT = 0, CIPHER_SIGN = 1, CIPHER_IGN };
enum encipher_type mhd_gtls_kx_encipher_type (enum
enum encipher_type MHD_gtls_kx_encipher_type (enum
MHD_GNUTLS_KeyExchangeAlgorithm
algorithm);
struct mhd_gtls_compression_entry
struct MHD_gtls_compression_entry
{
const char *name;
enum MHD_GNUTLS_CompressionMethod id;
@@ -137,26 +137,26 @@ struct mhd_gtls_compression_entry
int mem_level;
int comp_level;
};
typedef struct mhd_gtls_compression_entry gnutls_compression_entry;
typedef struct MHD_gtls_compression_entry MHD_gnutls_compression_entry;
/* Functions for sign algorithms. */
gnutls_sign_algorithm_t mhd_gtls_x509_oid2sign_algorithm (const char *oid);
gnutls_sign_algorithm_t mhd_gtls_x509_pk_to_sign (enum
MHD_gnutls_sign_algorithm_t MHD_gtls_x509_oid2sign_algorithm (const char *oid);
MHD_gnutls_sign_algorithm_t MHD_gtls_x509_pk_to_sign (enum
MHD_GNUTLS_PublicKeyAlgorithm
pk,
enum
MHD_GNUTLS_HashAlgorithm
mac);
const char *mhd_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm,
const char *MHD_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm,
enum MHD_GNUTLS_HashAlgorithm mac);
int mhd_gtls_mac_priority (mhd_gtls_session_t session,
int MHD_gtls_mac_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_HashAlgorithm algorithm);
int mhd_gtls_cipher_priority (mhd_gtls_session_t session,
int MHD_gtls_cipher_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_CipherAlgorithm algorithm);
int mhd_gtls_kx_priority (mhd_gtls_session_t session,
int MHD_gtls_kx_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm);
int mhd_gtls_compression_priority (mhd_gtls_session_t session,
int MHD_gtls_compression_priority (MHD_gtls_session_t session,
enum MHD_GNUTLS_CompressionMethod
algorithm);
src/daemon/https/tls/gnutls_anon_cred.c
+24 -24
View File
@@ -36,23 +36,23 @@
static const int anon_dummy;
/**
* MHD_gnutls_anon_free_server_credentials - Used to free an allocated mhd_gtls_anon_server_credentials_t structure
* @sc: is an #mhd_gtls_anon_server_credentials_t structure.
* MHD__gnutls_anon_free_server_credentials - Used to free an allocated MHD_gtls_anon_server_credentials_t structure
* @sc: is an #MHD_gtls_anon_server_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus this
* helper function is provided in order to free (deallocate) it.
**/
void
MHD_gnutls_anon_free_server_credentials (mhd_gtls_anon_server_credentials_t
MHD__gnutls_anon_free_server_credentials (MHD_gtls_anon_server_credentials_t
sc)
{
gnutls_free (sc);
MHD_gnutls_free (sc);
}
/**
* MHD_gnutls_anon_allocate_server_credentials - Used to allocate an mhd_gtls_anon_server_credentials_t structure
* @sc: is a pointer to an #mhd_gtls_anon_server_credentials_t structure.
* MHD__gnutls_anon_allocate_server_credentials - Used to allocate an MHD_gtls_anon_server_credentials_t structure
* @sc: is a pointer to an #MHD_gtls_anon_server_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus this
* helper function is provided in order to allocate it.
@@ -60,10 +60,10 @@ MHD_gnutls_anon_free_server_credentials (mhd_gtls_anon_server_credentials_t
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
MHD_gnutls_anon_allocate_server_credentials
(mhd_gtls_anon_server_credentials_t * sc)
MHD__gnutls_anon_allocate_server_credentials
(MHD_gtls_anon_server_credentials_t * sc)
{
*sc = gnutls_calloc (1, sizeof (mhd_anon_server_credentials_st));
*sc = MHD_gnutls_calloc (1, sizeof (mhd_anon_server_credentials_st));
if (*sc == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -72,21 +72,21 @@ int
/**
* MHD_gnutls_anon_free_client_credentials - Used to free an allocated mhd_gtls_anon_client_credentials_t structure
* @sc: is an #mhd_gtls_anon_client_credentials_t structure.
* MHD__gnutls_anon_free_client_credentials - Used to free an allocated MHD_gtls_anon_client_credentials_t structure
* @sc: is an #MHD_gtls_anon_client_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus this
* helper function is provided in order to free (deallocate) it.
**/
void
MHD_gnutls_anon_free_client_credentials (mhd_gtls_anon_client_credentials_t
MHD__gnutls_anon_free_client_credentials (MHD_gtls_anon_client_credentials_t
sc)
{
}
/**
* MHD_gnutls_anon_allocate_client_credentials - Used to allocate a credentials structure
* @sc: is a pointer to an #mhd_gtls_anon_client_credentials_t structure.
* MHD__gnutls_anon_allocate_client_credentials - Used to allocate a credentials structure
* @sc: is a pointer to an #MHD_gtls_anon_client_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus
* this helper function is provided in order to allocate it.
@@ -94,8 +94,8 @@ MHD_gnutls_anon_free_client_credentials (mhd_gtls_anon_client_credentials_t
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
MHD_gnutls_anon_allocate_client_credentials
(mhd_gtls_anon_client_credentials_t * sc)
MHD__gnutls_anon_allocate_client_credentials
(MHD_gtls_anon_client_credentials_t * sc)
{
/* anon_dummy is only there for *sc not to be null.
* it is not used at all;
@@ -106,8 +106,8 @@ int
}
/**
* MHD_gnutls_anon_set_server_dh_params - This function will set the DH parameters for a server to use
* @res: is a mhd_gtls_anon_server_credentials_t structure
* MHD__gnutls_anon_set_server_dh_params - This function will set the DH parameters for a server to use
* @res: is a MHD_gtls_anon_server_credentials_t structure
* @dh_params: is a structure that holds diffie hellman parameters.
*
* This function will set the diffie hellman parameters for an
@@ -115,15 +115,15 @@ int
* Anonymous Diffie Hellman cipher suites.
**/
void
MHD_gnutls_anon_set_server_dh_params (mhd_gtls_anon_server_credentials_t res,
mhd_gtls_dh_params_t dh_params)
MHD__gnutls_anon_set_server_dh_params (MHD_gtls_anon_server_credentials_t res,
MHD_gtls_dh_params_t dh_params)
{
res->dh_params = dh_params;
}
/**
* MHD_gnutls_anon_set_server_params_function - This function will set the DH parameters callback
* @res: is a mhd_gtls_cert_credentials_t structure
* MHD__gnutls_anon_set_server_params_function - This function will set the DH parameters callback
* @res: is a MHD_gtls_cert_credentials_t structure
* @func: is the function to be called
*
* This function will set a callback in order for the server to get
@@ -131,9 +131,9 @@ MHD_gnutls_anon_set_server_dh_params (mhd_gtls_anon_server_credentials_t res,
* callback should return zero on success.
**/
void
MHD_gnutls_anon_set_server_params_function (mhd_gtls_anon_server_credentials_t
MHD__gnutls_anon_set_server_params_function (MHD_gtls_anon_server_credentials_t
res,
gnutls_params_function * func)
MHD_gnutls_params_function * func)
{
res->params_func = func;
}
src/daemon/https/tls/gnutls_asn1_tab.c
+1 -1
View File
@@ -4,7 +4,7 @@
#include <libtasn1.h>
const ASN1_ARRAY_TYPE gnutls_asn1_tab[] = {
const ASN1_ARRAY_TYPE MHD_gnutlsMHD__asn1_tab[] = {
{"GNUTLS", 536872976, 0},
{0, 1073741836, 0},
{"RSAPublicKey", 1610612741, 0},
src/daemon/https/tls/gnutls_auth.c
+52 -52
View File
@@ -37,14 +37,14 @@
*/
/**
* MHD_gnutls_credentials_clear - Clears all the credentials previously set
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_credentials_clear - Clears all the credentials previously set
* @session: is a #MHD_gtls_session_t structure.
*
* Clears all the credentials previously set in this session.
*
**/
void
MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
MHD__gnutls_credentials_clear (MHD_gtls_session_t session)
{
if (session->key && session->key->cred)
{ /* beginning of the list */
@@ -53,7 +53,7 @@ MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
while (ccred != NULL)
{
ncred = ccred->next;
gnutls_free (ccred);
MHD_gnutls_free (ccred);
ccred = ncred;
}
session->key->cred = NULL;
@@ -65,8 +65,8 @@ MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
* { algorithm, credentials, pointer to next }
*/
/**
* MHD_gnutls_credentials_set - Sets the needed credentials for the specified authentication algorithm.
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_credentials_set - Sets the needed credentials for the specified authentication algorithm.
* @session: is a #MHD_gtls_session_t structure.
* @type: is the type of the credentials
* @cred: is a pointer to a structure.
*
@@ -77,20 +77,20 @@ MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
* [ In order to minimize memory usage, and share credentials between
* several threads gnutls keeps a pointer to cred, and not the whole cred
* structure. Thus you will have to keep the structure allocated until
* you call MHD_gnutls_deinit(). ]
* you call MHD__gnutls_deinit(). ]
*
* For GNUTLS_CRD_ANON cred should be mhd_gtls_anon_client_credentials_t in case of a client.
* In case of a server it should be mhd_gtls_anon_server_credentials_t.
* For GNUTLS_CRD_ANON cred should be MHD_gtls_anon_client_credentials_t in case of a client.
* In case of a server it should be MHD_gtls_anon_server_credentials_t.
*
* For GNUTLS_CRD_SRP cred should be gnutls_srp_client_credentials_t
* in case of a client, and gnutls_srp_server_credentials_t, in case
* For GNUTLS_CRD_SRP cred should be MHD_gnutls_srp_client_credentials_t
* in case of a client, and MHD_gnutls_srp_server_credentials_t, in case
* of a server.
*
* For GNUTLS_CRD_CERTIFICATE cred should be mhd_gtls_cert_credentials_t.
* For GNUTLS_CRD_CERTIFICATE cred should be MHD_gtls_cert_credentials_t.
*
**/
int
MHD_gnutls_credentials_set (mhd_gtls_session_t session,
MHD__gnutls_credentials_set (MHD_gtls_session_t session,
enum MHD_GNUTLS_CredentialsType type, void *cred)
{
auth_cred_st *ccred = NULL, *pcred = NULL;
@@ -99,7 +99,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
if (session->key->cred == NULL)
{ /* beginning of the list */
session->key->cred = gnutls_malloc (sizeof (auth_cred_st));
session->key->cred = MHD_gnutls_malloc (sizeof (auth_cred_st));
if (session->key->cred == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -127,7 +127,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
if (exists == 0)
{ /* new entry */
pcred->next = gnutls_malloc (sizeof (auth_cred_st));
pcred->next = MHD_gnutls_malloc (sizeof (auth_cred_st));
if (pcred->next == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -141,7 +141,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
}
else
{ /* modify existing entry */
gnutls_free (ccred->credentials);
MHD_gnutls_free (ccred->credentials);
ccred->credentials = cred;
}
}
@@ -151,7 +151,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
/**
* MHD_gtls_auth_get_type - Returns the type of credentials for the current authentication schema.
* @session: is a #mhd_gtls_session_t structure.
* @session: is a #MHD_gtls_session_t structure.
*
* Returns type of credentials for the current authentication schema.
* The returned information is to be used to distinguish the function used
@@ -161,7 +161,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
* the same function are to be used to access the authentication data.
**/
enum MHD_GNUTLS_CredentialsType
MHD_gtls_auth_get_type (mhd_gtls_session_t session)
MHD_gtls_auth_get_type (MHD_gtls_session_t session)
{
/* This is not the credentials we must set, but the authentication data
* we get by the peer, so it should be reversed.
@@ -169,14 +169,14 @@ MHD_gtls_auth_get_type (mhd_gtls_session_t session)
int server = session->security_parameters.entity == GNUTLS_SERVER ? 0 : 1;
return
mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite), server);
}
/**
* MHD_gtls_auth_server_get_type - Returns the type of credentials for the server authentication schema.
* @session: is a #mhd_gtls_session_t structure.
* @session: is a #MHD_gtls_session_t structure.
*
* Returns the type of credentials that were used for server authentication.
* The returned information is to be used to distinguish the function used
@@ -184,17 +184,17 @@ MHD_gtls_auth_get_type (mhd_gtls_session_t session)
*
**/
enum MHD_GNUTLS_CredentialsType
MHD_gtls_auth_server_get_type (mhd_gtls_session_t session)
MHD_gtls_auth_server_get_type (MHD_gtls_session_t session)
{
return
mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite), 1);
}
/**
* MHD_gtls_auth_client_get_type - Returns the type of credentials for the client authentication schema.
* @session: is a #mhd_gtls_session_t structure.
* @session: is a #MHD_gtls_session_t structure.
*
* Returns the type of credentials that were used for client authentication.
* The returned information is to be used to distinguish the function used
@@ -202,10 +202,10 @@ MHD_gtls_auth_server_get_type (mhd_gtls_session_t session)
*
**/
enum MHD_GNUTLS_CredentialsType
MHD_gtls_auth_client_get_type (mhd_gtls_session_t session)
MHD_gtls_auth_client_get_type (MHD_gtls_session_t session)
{
return
mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite), 0);
}
@@ -216,17 +216,17 @@ MHD_gtls_auth_client_get_type (mhd_gtls_session_t session)
* free that!!!
*/
const void *
mhd_gtls_get_kx_cred (mhd_gtls_session_t session,
MHD_gtls_get_kx_cred (MHD_gtls_session_t session,
enum MHD_GNUTLS_KeyExchangeAlgorithm algo, int *err)
{
int server = session->security_parameters.entity == GNUTLS_SERVER ? 1 : 0;
return mhd_gtls_get_cred (session->key,
mhd_gtls_map_kx_get_cred (algo, server), err);
return MHD_gtls_get_cred (session->key,
MHD_gtls_map_kx_get_cred (algo, server), err);
}
const void *
mhd_gtls_get_cred (mhd_gtls_key_st key, enum MHD_GNUTLS_CredentialsType type,
MHD_gtls_get_cred (MHD_gtls_key_st key, enum MHD_GNUTLS_CredentialsType type,
int *err)
{
const void *retval = NULL;
@@ -258,10 +258,10 @@ out:
}
/*-
* mhd_gtls_get_auth_info - Returns a pointer to authentication information.
* @session: is a #mhd_gtls_session_t structure.
* MHD_gtls_get_auth_info - Returns a pointer to authentication information.
* @session: is a #MHD_gtls_session_t structure.
*
* This function must be called after a succesful MHD_gnutls_handshake().
* This function must be called after a succesful MHD__gnutls_handshake().
* Returns a pointer to authentication information. That information
* is data obtained by the handshake protocol, the key exchange algorithm,
* and the TLS extensions messages.
@@ -271,28 +271,28 @@ out:
* In case of GNUTLS_CRD_SRP returns a type of &srp_(server/client)_auth_info_t;
-*/
void *
mhd_gtls_get_auth_info (mhd_gtls_session_t session)
MHD_gtls_get_auth_info (MHD_gtls_session_t session)
{
return session->key->auth_info;
}
/*-
* mhd_gtls_free_auth_info - Frees the auth info structure
* @session: is a #mhd_gtls_session_t structure.
* MHD_gtls_free_auth_info - Frees the auth info structure
* @session: is a #MHD_gtls_session_t structure.
*
* This function frees the auth info structure and sets it to
* null. It must be called since some structures contain malloced
* elements.
-*/
void
mhd_gtls_free_auth_info (mhd_gtls_session_t session)
MHD_gtls_free_auth_info (MHD_gtls_session_t session)
{
mhd_gtls_dh_info_st *dh_info;
MHD_gtls_dh_info_st *dh_info;
rsa_info_st *rsa_info;
if (session == NULL || session->key == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return;
}
@@ -302,19 +302,19 @@ mhd_gtls_free_auth_info (mhd_gtls_session_t session)
break;
case MHD_GNUTLS_CRD_ANON:
{
mhd_anon_auth_info_t info = mhd_gtls_get_auth_info (session);
mhd_anon_auth_info_t info = MHD_gtls_get_auth_info (session);
if (info == NULL)
break;
dh_info = &info->dh;
mhd_gtls_free_dh_info (dh_info);
MHD_gtls_free_dh_info (dh_info);
}
break;
case MHD_GNUTLS_CRD_CERTIFICATE:
{
unsigned int i;
cert_auth_info_t info = mhd_gtls_get_auth_info (session);
cert_auth_info_t info = MHD_gtls_get_auth_info (session);
if (info == NULL)
break;
@@ -323,15 +323,15 @@ mhd_gtls_free_auth_info (mhd_gtls_session_t session)
rsa_info = &info->rsa_export;
for (i = 0; i < info->ncerts; i++)
{
_gnutls_free_datum (&info->raw_certificate_list[i]);
MHD__gnutls_free_datum (&info->raw_certificate_list[i]);
}
gnutls_free (info->raw_certificate_list);
MHD_gnutls_free (info->raw_certificate_list);
info->raw_certificate_list = NULL;
info->ncerts = 0;
mhd_gtls_free_dh_info (dh_info);
mhd_gtls_free_rsa_info (rsa_info);
MHD_gtls_free_dh_info (dh_info);
MHD_gtls_free_rsa_info (rsa_info);
}
@@ -341,7 +341,7 @@ mhd_gtls_free_auth_info (mhd_gtls_session_t session)
}
gnutls_free (session->key->auth_info);
MHD_gnutls_free (session->key->auth_info);
session->key->auth_info = NULL;
session->key->auth_info_size = 0;
session->key->auth_info_type = 0;
@@ -354,16 +354,16 @@ mhd_gtls_free_auth_info (mhd_gtls_session_t session)
* info structure to a different type.
*/
int
mhd_gtls_auth_info_set (mhd_gtls_session_t session,
MHD_gtls_auth_info_set (MHD_gtls_session_t session,
enum MHD_GNUTLS_CredentialsType type, int size,
int allow_change)
{
if (session->key->auth_info == NULL)
{
session->key->auth_info = gnutls_calloc (1, size);
session->key->auth_info = MHD_gnutls_calloc (1, size);
if (session->key->auth_info == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
session->key->auth_info_type = type;
@@ -382,7 +382,7 @@ mhd_gtls_auth_info_set (mhd_gtls_session_t session,
if (MHD_gtls_auth_get_type (session) !=
session->key->auth_info_type)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
}
@@ -398,12 +398,12 @@ mhd_gtls_auth_info_set (mhd_gtls_session_t session,
session->key->auth_info_type)
{
mhd_gtls_free_auth_info (session);
MHD_gtls_free_auth_info (session);
session->key->auth_info = calloc (1, size);
if (session->key->auth_info == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
src/daemon/https/tls/gnutls_auth.h
+14 -14
View File
@@ -25,27 +25,27 @@
#ifndef GNUTLS_AUTH_H
#define GNUTLS_AUTH_H
typedef struct mhd_gtls_mod_auth_st_int
typedef struct MHD_gtls_mod_auth_st_int
{
const char *name; /* null terminated */
int (*mhd_gtls_gen_server_certificate) (mhd_gtls_session_t, opaque **);
int (*mhd_gtls_gen_client_certificate) (mhd_gtls_session_t, opaque **);
int (*mhd_gtls_gen_server_kx) (mhd_gtls_session_t, opaque **);
int (*mhd_gtls_gen_client_kx) (mhd_gtls_session_t, opaque **); /* used in SRP */
int (*mhd_gtls_gen_client_cert_vrfy) (mhd_gtls_session_t, opaque **);
int (*mhd_gtls_gen_server_certificate_request) (mhd_gtls_session_t,
int (*MHD_gtls_gen_server_certificate) (MHD_gtls_session_t, opaque **);
int (*MHD_gtls_gen_client_certificate) (MHD_gtls_session_t, opaque **);
int (*MHD_gtls_gen_server_kx) (MHD_gtls_session_t, opaque **);
int (*MHD_gtls_gen_client_kx) (MHD_gtls_session_t, opaque **); /* used in SRP */
int (*MHD_gtls_gen_client_cert_vrfy) (MHD_gtls_session_t, opaque **);
int (*MHD_gtls_gen_server_certificate_request) (MHD_gtls_session_t,
opaque **);
int (*mhd_gtls_process_server_certificate) (mhd_gtls_session_t, opaque *,
int (*MHD_gtls_process_server_certificate) (MHD_gtls_session_t, opaque *,
size_t);
int (*mhd_gtls_process_client_certificate) (mhd_gtls_session_t, opaque *,
int (*MHD_gtls_process_client_certificate) (MHD_gtls_session_t, opaque *,
size_t);
int (*mhd_gtls_process_server_kx) (mhd_gtls_session_t, opaque *, size_t);
int (*mhd_gtls_process_client_kx) (mhd_gtls_session_t, opaque *, size_t);
int (*mhd_gtls_process_client_cert_vrfy) (mhd_gtls_session_t, opaque *,
int (*MHD_gtls_process_server_kx) (MHD_gtls_session_t, opaque *, size_t);
int (*MHD_gtls_process_client_kx) (MHD_gtls_session_t, opaque *, size_t);
int (*MHD_gtls_process_client_cert_vrfy) (MHD_gtls_session_t, opaque *,
size_t);
int (*mhd_gtls_process_server_certificate_request) (mhd_gtls_session_t,
int (*MHD_gtls_process_server_certificate_request) (MHD_gtls_session_t,
opaque *, size_t);
} mhd_gtls_mod_auth_st;
} MHD_gtls_mod_auth_st;
#endif
src/daemon/https/tls/gnutls_auth_int.h
+4 -4
View File
@@ -22,12 +22,12 @@
*
*/
const void *mhd_gtls_get_cred (mhd_gtls_key_st key,
const void *MHD_gtls_get_cred (MHD_gtls_key_st key,
enum MHD_GNUTLS_CredentialsType kx, int *err);
const void *mhd_gtls_get_kx_cred (mhd_gtls_session_t session,
const void *MHD_gtls_get_kx_cred (MHD_gtls_session_t session,
enum MHD_GNUTLS_KeyExchangeAlgorithm algo,
int *err);
void *mhd_gtls_get_auth_info (mhd_gtls_session_t session);
int mhd_gtls_auth_info_set (mhd_gtls_session_t session,
void *MHD_gtls_get_auth_info (MHD_gtls_session_t session);
int MHD_gtls_auth_info_set (MHD_gtls_session_t session,
enum MHD_GNUTLS_CredentialsType type, int size,
int allow_change);
src/daemon/https/tls/gnutls_buffers.c
+151 -151
View File
@@ -30,20 +30,20 @@
* RECORD LAYER:
* 1. uses a buffer to hold data (application/handshake),
* we got but they were not requested, yet.
* (see gnutls_record_buffer_put(), gnutls_record_buffer_get_size() etc.)
* (see MHD_gnutls_record_buffer_put(), MHD_gnutls_record_buffer_get_size() etc.)
*
* 2. uses a buffer to hold data that were incomplete (ie the read/write
* was interrupted)
* (see mhd_gtls_io_read_buffered(), mhd_gtls_io_write_buffered() etc.)
* (see MHD_gtls_io_read_buffered(), MHD_gtls_io_write_buffered() etc.)
*
* HANDSHAKE LAYER:
* 1. Uses a buffer to hold data that was not sent or received
* complete. (E.g. sent 10 bytes of a handshake packet that is 20 bytes
* long).
* (see _gnutls_handshake_send_int(), _gnutls_handshake_recv_int())
* (see MHD__gnutls_handshake_send_int(), MHD__gnutls_handshake_recv_int())
*
* 2. Uses buffer to hold the last received handshake message.
* (see mhd_gtls_handshake_buffer_put() etc.)
* (see MHD_gtls_handshake_buffer_put() etc.)
*
*/
@@ -68,8 +68,8 @@
#endif
/**
* MHD_gnutls_transport_set_errno:
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_transport_set_errno:
* @session: is a #MHD_gtls_session_t structure.
* @err: error value to store in session-specific errno variable.
*
* Store @err in the session-specific errno variable. Useful values
@@ -77,24 +77,24 @@
* treated as real errors in the push/pull function.
*
* This function is useful in replacement push/pull functions set by
* MHD_gnutls_transport_set_push_function and
* gnutls_transport_set_pullpush_function under Windows, where the
* MHD__gnutls_transport_set_push_function and
* MHD_gnutls_transport_set_pullpush_function under Windows, where the
* replacement push/pull may not have access to the same @errno
* variable that is used by GnuTLS (e.g., the application is linked to
* msvcr71.dll and gnutls is linked to msvcrt.dll).
*
* If you don't have the @session variable easily accessible from the
* push/pull function, and don't worry about thread conflicts, you can
* also use MHD_gnutls_transport_set_global_errno().
* also use MHD__gnutls_transport_set_global_errno().
**/
void
MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err)
MHD__gnutls_transport_set_errno (MHD_gtls_session_t session, int err)
{
session->internals.errnum = err;
}
/**
* MHD_gnutls_transport_set_global_errno:
* MHD__gnutls_transport_set_global_errno:
* @err: error value to store in global errno variable.
*
* Store @err in the global errno variable. Useful values for @err is
@@ -102,8 +102,8 @@ MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err)
* errors in the push/pull function.
*
* This function is useful in replacement push/pull functions set by
* MHD_gnutls_transport_set_push_function and
* gnutls_transport_set_pullpush_function under Windows, where the
* MHD__gnutls_transport_set_push_function and
* MHD_gnutls_transport_set_pullpush_function under Windows, where the
* replacement push/pull may not have access to the same @errno
* variable that is used by GnuTLS (e.g., the application is linked to
* msvcr71.dll and gnutls is linked to msvcrt.dll).
@@ -111,10 +111,10 @@ MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err)
* Whether this function is thread safe or not depends on whether the
* global variable errno is thread safe, some system libraries make it
* a thread-local variable. When feasible, using the guaranteed
* thread-safe MHD_gnutls_transport_set_errno() may be better.
* thread-safe MHD__gnutls_transport_set_errno() may be better.
**/
void
MHD_gnutls_transport_set_global_errno (int err)
MHD__gnutls_transport_set_global_errno (int err)
{
errno = err;
}
@@ -123,11 +123,11 @@ MHD_gnutls_transport_set_global_errno (int err)
* HANDSHAKE DATA.
*/
int
mhd_gnutls_record_buffer_put (content_type_t type,
mhd_gtls_session_t session, opaque * data,
MHD_gnutls_record_buffer_put (content_type_t type,
MHD_gtls_session_t session, opaque * data,
size_t length)
{
mhd_gtls_buffer *buf;
MHD_gtls_buffer *buf;
if (length == 0)
return 0;
@@ -136,30 +136,30 @@ mhd_gnutls_record_buffer_put (content_type_t type,
{
case GNUTLS_APPLICATION_DATA:
buf = &session->internals.application_data_buffer;
_gnutls_buffers_log ("BUF[REC]: Inserted %d bytes of Data(%d)\n",
MHD__gnutls_buffers_log ("BUF[REC]: Inserted %d bytes of Data(%d)\n",
length, type);
break;
case GNUTLS_HANDSHAKE:
buf = &session->internals.handshake_data_buffer;
_gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data(%d)\n",
MHD__gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data(%d)\n",
length, type);
break;
case GNUTLS_INNER_APPLICATION:
buf = &session->internals.ia_data_buffer;
_gnutls_buffers_log ("BUF[IA]: Inserted %d bytes of Data(%d)\n", length,
MHD__gnutls_buffers_log ("BUF[IA]: Inserted %d bytes of Data(%d)\n", length,
type);
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
if (mhd_gtls_buffer_append (buf, data, length) < 0)
if (MHD_gtls_buffer_append (buf, data, length) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -167,8 +167,8 @@ mhd_gnutls_record_buffer_put (content_type_t type,
}
int
mhd_gnutls_record_buffer_get_size (content_type_t type,
mhd_gtls_session_t session)
MHD_gnutls_record_buffer_get_size (content_type_t type,
MHD_gtls_session_t session)
{
switch (type)
{
@@ -188,7 +188,7 @@ mhd_gnutls_record_buffer_get_size (content_type_t type,
/**
* MHD_gtls_record_check_pending - checks if there are any data to receive in gnutls buffers.
* @session: is a #mhd_gtls_session_t structure.
* @session: is a #MHD_gtls_session_t structure.
*
* This function checks if there are any data to receive
* in the gnutls buffers. Returns the size of that data or 0.
@@ -198,18 +198,18 @@ mhd_gnutls_record_buffer_get_size (content_type_t type,
* to work).
**/
size_t
MHD_gtls_record_check_pending (mhd_gtls_session_t session)
MHD_gtls_record_check_pending (MHD_gtls_session_t session)
{
return mhd_gnutls_record_buffer_get_size (GNUTLS_APPLICATION_DATA, session);
return MHD_gnutls_record_buffer_get_size (GNUTLS_APPLICATION_DATA, session);
}
int
mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
MHD_gtls_record_buffer_get (content_type_t type, MHD_gtls_session_t session,
opaque * data, size_t length)
{
if (length == 0 || data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
@@ -222,7 +222,7 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
length = session->internals.application_data_buffer.length;
}
_gnutls_buffers_log ("BUFFER[REC][AD]: Read %d bytes of Data(%d)\n",
MHD__gnutls_buffers_log ("BUFFER[REC][AD]: Read %d bytes of Data(%d)\n",
length, type);
session->internals.application_data_buffer.length -= length;
@@ -245,7 +245,7 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
length = session->internals.handshake_data_buffer.length;
}
_gnutls_buffers_log ("BUF[REC][HD]: Read %d bytes of Data(%d)\n",
MHD__gnutls_buffers_log ("BUF[REC][HD]: Read %d bytes of Data(%d)\n",
length, type);
session->internals.handshake_data_buffer.length -= length;
@@ -262,7 +262,7 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
if (length > session->internals.ia_data_buffer.length)
length = session->internals.ia_data_buffer.length;
_gnutls_buffers_log ("BUF[REC][IA]: Read %d bytes of Data(%d)\n",
MHD__gnutls_buffers_log ("BUF[REC][IA]: Read %d bytes of Data(%d)\n",
length, type);
session->internals.ia_data_buffer.length -= length;
@@ -276,7 +276,7 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
@@ -284,19 +284,19 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
}
/* This function is like read. But it does not return -1 on error.
* It does return gnutls_errno instead.
* It does return MHD_gnutls_errno instead.
*
* Flags are only used if the default recv() function is being used.
*/
static ssize_t
_gnutls_read (mhd_gtls_session_t session, void *iptr,
MHD__gnutls_read (MHD_gtls_session_t session, void *iptr,
size_t sizeOfPtr, int flags)
{
size_t left;
ssize_t i = 0;
char *ptr = iptr;
unsigned j, x, sum = 0;
gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
MHD_gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
session->internals.direction = 0;
@@ -304,7 +304,7 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
while (left > 0)
{
session->internals.errnum = 0;
if (session->internals._gnutls_pull_func == NULL)
if (session->internals.MHD__gnutls_pull_func == NULL)
{
i =
recv (GNUTLS_POINTER_TO_INT (fd), &ptr[sizeOfPtr - left], left,
@@ -332,7 +332,7 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
#endif
}
else
i = session->internals._gnutls_pull_func (fd,
i = session->internals.MHD__gnutls_pull_func (fd,
&ptr[sizeOfPtr - left],
left);
@@ -341,7 +341,7 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
int err = session->internals.errnum ? session->internals.errnum
: errno;
_gnutls_read_log ("READ: %d returned from %d, errno=%d gerrno=%d\n",
MHD__gnutls_read_log ("READ: %d returned from %d, errno=%d gerrno=%d\n",
i, fd, errno, session->internals.errnum);
if (err == EAGAIN || err == EINTR)
@@ -349,12 +349,12 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
if (sizeOfPtr - left > 0)
{
_gnutls_read_log ("READ: returning %d bytes from %d\n",
MHD__gnutls_read_log ("READ: returning %d bytes from %d\n",
sizeOfPtr - left, fd);
goto finish;
}
gnutls_assert ();
MHD_gnutls_assert ();
if (err == EAGAIN)
return GNUTLS_E_AGAIN;
@@ -362,14 +362,14 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PULL_ERROR;
}
}
else
{
_gnutls_read_log ("READ: Got %d bytes from %d\n", i, fd);
MHD__gnutls_read_log ("READ: Got %d bytes from %d\n", i, fd);
if (i == 0)
break; /* EOF */
@@ -381,12 +381,12 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
finish:
if (_gnutls_log_level >= 7)
if (MHD__gnutls_log_level >= 7)
{
char line[128];
char tmp[16];
_gnutls_read_log ("READ: read %d bytes from %d\n", (sizeOfPtr - left),
MHD__gnutls_read_log ("READ: read %d bytes from %d\n", (sizeOfPtr - left),
fd);
for (x = 0; x < ((sizeOfPtr - left) / 16) + 1; x++)
@@ -394,17 +394,17 @@ finish:
line[0] = 0;
sprintf (tmp, "%.4x - ", x);
mhd_gtls_str_cat (line, sizeof (line), tmp);
MHD_gtls_str_cat (line, sizeof (line), tmp);
for (j = 0; j < 16; j++)
{
if (sum < (sizeOfPtr - left))
{
sprintf (tmp, "%.2x ", ((unsigned char *) ptr)[sum++]);
mhd_gtls_str_cat (line, sizeof (line), tmp);
MHD_gtls_str_cat (line, sizeof (line), tmp);
}
}
_gnutls_read_log ("%s\n", line);
MHD__gnutls_read_log ("%s\n", line);
}
}
@@ -417,7 +417,7 @@ finish:
* Clears the peeked data (read with MSG_PEEK).
*/
int
mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
MHD_gtls_io_clear_peeked_data (MHD_gtls_session_t session)
{
char *peekdata;
int ret, sum;
@@ -425,10 +425,10 @@ mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
if (session->internals.have_peeked_data == 0 || RCVLOWAT == 0)
return 0;
peekdata = gnutls_alloca (RCVLOWAT);
peekdata = MHD_gnutls_alloca (RCVLOWAT);
if (peekdata == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -436,18 +436,18 @@ mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
sum = 0;
do
{ /* we need this to finish now */
ret = _gnutls_read (session, peekdata, RCVLOWAT - sum, 0);
ret = MHD__gnutls_read (session, peekdata, RCVLOWAT - sum, 0);
if (ret > 0)
sum += ret;
}
while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN || sum
< RCVLOWAT);
gnutls_afree (peekdata);
MHD_gnutls_afree (peekdata);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -457,13 +457,13 @@ mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
}
void
mhd_gtls_io_clear_read_buffer (mhd_gtls_session_t session)
MHD_gtls_io_clear_read_buffer (MHD_gtls_session_t session)
{
session->internals.record_recv_buffer.length = 0;
}
/* This function is like recv(with MSG_PEEK). But it does not return -1 on error.
* It does return gnutls_errno instead.
* It does return MHD_gnutls_errno instead.
* This function reads data from the socket and keeps them in a buffer, of up to
* MAX_RECV_SIZE.
*
@@ -472,7 +472,7 @@ mhd_gtls_io_clear_read_buffer (mhd_gtls_session_t session)
*
*/
ssize_t
mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
MHD_gtls_io_read_buffered (MHD_gtls_session_t session, opaque ** iptr,
size_t sizeOfPtr, content_type_t recv_type)
{
ssize_t ret = 0, ret2 = 0;
@@ -486,14 +486,14 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
if (sizeOfPtr > MAX_RECV_SIZE || sizeOfPtr == 0)
{
gnutls_assert (); /* internal error */
MHD_gnutls_assert (); /* internal error */
return GNUTLS_E_INVALID_REQUEST;
}
/* If an external pull function is used, then do not leave
* any data into the kernel buffer.
*/
if (session->internals._gnutls_pull_func != NULL)
if (session->internals.MHD__gnutls_pull_func != NULL)
{
recvlowat = 0;
}
@@ -536,7 +536,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
if ((session->internals.record_recv_buffer.length + recvdata)
> MAX_RECV_SIZE)
{
gnutls_assert (); /* internal error */
MHD_gnutls_assert (); /* internal error */
return GNUTLS_E_INVALID_REQUEST;
}
@@ -544,11 +544,11 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
*/
alloc_size = recvdata + session->internals.record_recv_buffer.length;
session->internals.record_recv_buffer.data =
mhd_gtls_realloc_fast (session->internals.record_recv_buffer.data,
MHD_gtls_realloc_fast (session->internals.record_recv_buffer.data,
alloc_size);
if (session->internals.record_recv_buffer.data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -559,7 +559,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
/* READ DATA - but leave RCVLOWAT bytes in the kernel buffer. */
if (recvdata - recvlowat > 0)
{
ret = _gnutls_read (session, &buf[buf_pos], recvdata - recvlowat, 0);
ret = MHD__gnutls_read (session, &buf[buf_pos], recvdata - recvlowat, 0);
/* return immediately if we got an interrupt or eagain
* error.
@@ -574,9 +574,9 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
*/
if (ret > 0)
{
_gnutls_read_log ("RB: Have %d bytes into buffer. Adding %d bytes.\n",
MHD__gnutls_read_log ("RB: Have %d bytes into buffer. Adding %d bytes.\n",
session->internals.record_recv_buffer.length, ret);
_gnutls_read_log ("RB: Requested %d bytes\n", sizeOfPtr);
MHD__gnutls_read_log ("RB: Requested %d bytes\n", sizeOfPtr);
session->internals.record_recv_buffer.length += ret;
}
@@ -589,7 +589,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
*/
if (ret == (recvdata - recvlowat) && recvlowat > 0)
{
ret2 = _gnutls_read (session, &buf[buf_pos], recvlowat, MSG_PEEK);
ret2 = MHD__gnutls_read (session, &buf[buf_pos], recvlowat, MSG_PEEK);
if (ret2 < 0 && MHD_gtls_error_is_fatal (ret2) == 0)
{
@@ -598,8 +598,8 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
if (ret2 > 0)
{
_gnutls_read_log ("RB-PEEK: Read %d bytes in PEEK MODE.\n", ret2);
_gnutls_read_log
MHD__gnutls_read_log ("RB-PEEK: Read %d bytes in PEEK MODE.\n", ret2);
MHD__gnutls_read_log
("RB-PEEK: Have %d bytes into buffer. Adding %d bytes.\nRB: Requested %d bytes\n",
session->internals.record_recv_buffer.length, ret2, sizeOfPtr);
session->internals.have_peeked_data = 1;
@@ -610,7 +610,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
if (ret < 0 || ret2 < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* that's because they are initialized to 0 */
return MIN (ret, ret2);
}
@@ -619,13 +619,13 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
if (ret > 0 && ret < recvlowat)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_AGAIN;
}
if (ret == 0)
{ /* EOF */
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
@@ -634,7 +634,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
if ((ret > 0) && ((size_t) ret < sizeOfPtr))
{
/* Short Read */
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_AGAIN;
}
else
@@ -651,7 +651,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
#define MEMSUB(x,y) ((ssize_t)((ptrdiff_t)x-(ptrdiff_t)y))
inline static int
_gnutls_buffer_insert (mhd_gtls_buffer * buffer,
MHD__gnutls_buffer_insert (MHD_gtls_buffer * buffer,
const opaque * _data, size_t data_size)
{
@@ -662,7 +662,7 @@ _gnutls_buffer_insert (mhd_gtls_buffer * buffer,
*/
if (data_size > buffer->length)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* this shouldn't have happened */
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -680,9 +680,9 @@ _gnutls_buffer_insert (mhd_gtls_buffer * buffer,
}
if (mhd_gtls_buffer_append (buffer, _data, data_size) < 0)
if (MHD_gtls_buffer_append (buffer, _data, data_size) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -690,7 +690,7 @@ _gnutls_buffer_insert (mhd_gtls_buffer * buffer,
}
inline static int
_gnutls_buffer_get (mhd_gtls_buffer * buffer,
MHD__gnutls_buffer_get (MHD_gtls_buffer * buffer,
const opaque ** ptr, size_t * ptr_size)
{
*ptr_size = buffer->length;
@@ -700,9 +700,9 @@ _gnutls_buffer_get (mhd_gtls_buffer * buffer,
}
/* This function is like write. But it does not return -1 on error.
* It does return gnutls_errno instead.
* It does return MHD_gnutls_errno instead.
*
* In case of E_AGAIN and E_INTERRUPTED errors, you must call gnutls_write_flush(),
* In case of E_AGAIN and E_INTERRUPTED errors, you must call MHD_gnutls_write_flush(),
* until it returns ok (0).
*
* We need to push exactly the data in n, since we cannot send less
@@ -711,7 +711,7 @@ _gnutls_buffer_get (mhd_gtls_buffer * buffer,
*
*/
ssize_t
mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
MHD_gtls_io_write_buffered (MHD_gtls_session_t session,
const void *iptr, size_t n)
{
size_t left;
@@ -719,7 +719,7 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
ssize_t retval, i;
const opaque *ptr;
int ret;
gnutls_transport_ptr_t fd = session->internals.transport_send_ptr;
MHD_gnutls_transport_ptr_t fd = session->internals.transport_send_ptr;
/* to know where the procedure was interrupted.
*/
@@ -733,7 +733,7 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
*/
if (session->internals.record_send_buffer.length > 0 && iptr != NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
@@ -742,19 +742,19 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
if (iptr == NULL)
{
/* checking is handled above */
ret = _gnutls_buffer_get (&session->internals.record_send_buffer, &ptr,
ret = MHD__gnutls_buffer_get (&session->internals.record_send_buffer, &ptr,
&n);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
_gnutls_write_log ("WRITE: Restoring old write. (%d bytes to send)\n",
MHD__gnutls_write_log ("WRITE: Restoring old write. (%d bytes to send)\n",
n);
}
_gnutls_write_log ("WRITE: Will write %d bytes to %d.\n", n, fd);
MHD__gnutls_write_log ("WRITE: Will write %d bytes to %d.\n", n, fd);
i = 0;
left = n;
@@ -763,7 +763,7 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
session->internals.errnum = 0;
if (session->internals._gnutls_push_func == NULL)
if (session->internals.MHD__gnutls_push_func == NULL)
{
i = send (GNUTLS_POINTER_TO_INT (fd), &ptr[n - left], left, 0);
#if HAVE_WINSOCK
@@ -789,7 +789,7 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
#endif
}
else
i = session->internals._gnutls_push_func (fd, &ptr[n - left], left);
i = session->internals.MHD__gnutls_push_func (fd, &ptr[n - left], left);
if (i == -1)
{
@@ -801,15 +801,15 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
session->internals.record_send_buffer_prev_size += n - left;
retval =
_gnutls_buffer_insert (&session->internals.record_send_buffer,
MHD__gnutls_buffer_insert (&session->internals.record_send_buffer,
&ptr[n - left], left);
if (retval < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return retval;
}
_gnutls_write_log
MHD__gnutls_write_log
("WRITE: Interrupted. Stored %d bytes to buffer. Already sent %d bytes.\n",
left, n - left);
@@ -819,18 +819,18 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PUSH_ERROR;
}
}
left -= i;
if (_gnutls_log_level >= 7)
if (MHD__gnutls_log_level >= 7)
{
char line[128];
char tmp[16];
_gnutls_write_log
MHD__gnutls_write_log
("WRITE: wrote %d bytes to %d. Left %d bytes. Total %d bytes.\n",
i, fd, left, n);
for (x = 0; x < (unsigned) ((i) / 16) + 1; x++)
@@ -841,19 +841,19 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
break;
sprintf (tmp, "%.4x - ", x);
mhd_gtls_str_cat (line, sizeof (line), tmp);
MHD_gtls_str_cat (line, sizeof (line), tmp);
for (j = 0; j < 16; j++)
{
if (sum < n - left)
{
sprintf (tmp, "%.2x ", ((unsigned char *) ptr)[sum++]);
mhd_gtls_str_cat (line, sizeof (line), tmp);
MHD_gtls_str_cat (line, sizeof (line), tmp);
}
else
break;
}
_gnutls_write_log ("%s\n", line);
MHD__gnutls_write_log ("%s\n", line);
}
}
}
@@ -872,15 +872,15 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
* interrupted.
*/
ssize_t
mhd_gtls_io_write_flush (mhd_gtls_session_t session)
MHD_gtls_io_write_flush (MHD_gtls_session_t session)
{
ssize_t ret;
if (session->internals.record_send_buffer.length == 0)
return 0; /* done */
ret = mhd_gtls_io_write_buffered (session, NULL, 0);
_gnutls_write_log ("WRITE FLUSH: %d [buffer: %d]\n", ret,
ret = MHD_gtls_io_write_buffered (session, NULL, 0);
MHD__gnutls_write_log ("WRITE FLUSH: %d [buffer: %d]\n", ret,
session->internals.record_send_buffer.length);
return ret;
@@ -891,17 +891,17 @@ mhd_gtls_io_write_flush (mhd_gtls_session_t session)
* interrupted.
*/
ssize_t
mhd_gtls_handshake_io_write_flush (mhd_gtls_session_t session)
MHD_gtls_handshake_io_write_flush (MHD_gtls_session_t session)
{
ssize_t ret;
ret = mhd_gtls_handshake_io_send_int (session, 0, 0, NULL, 0);
ret = MHD_gtls_handshake_io_send_int (session, 0, 0, NULL, 0);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
_gnutls_write_log ("HANDSHAKE_FLUSH: written[1] %d bytes\n", ret);
MHD__gnutls_write_log ("HANDSHAKE_FLUSH: written[1] %d bytes\n", ret);
if (session->internals.handshake_send_buffer.length == 0)
{
@@ -916,9 +916,9 @@ mhd_gtls_handshake_io_write_flush (mhd_gtls_session_t session)
* protocol. Just makes sure that all data have been sent.
*/
ssize_t
mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
MHD_gtls_handshake_io_send_int (MHD_gtls_session_t session,
content_type_t type,
gnutls_handshake_description_t htype,
MHD_gnutls_handshake_description_t htype,
const void *iptr, size_t n)
{
size_t left;
@@ -933,12 +933,12 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
{
/* resuming previously interrupted write
*/
gnutls_assert ();
ret = _gnutls_buffer_get (&session->internals.handshake_send_buffer,
MHD_gnutls_assert ();
ret = MHD__gnutls_buffer_get (&session->internals.handshake_send_buffer,
&ptr, &n);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return retval;
}
@@ -948,7 +948,7 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
}
else if (session->internals.handshake_send_buffer.length > 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
#ifdef WRITE_DEBUG
@@ -956,65 +956,65 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
{
size_t sum = 0, x, j;
_gnutls_write_log ("HWRITE: will write %d bytes to %d.\n", n,
gnutls_transport_get_ptr (session));
MHD__gnutls_write_log ("HWRITE: will write %d bytes to %d.\n", n,
MHD_gnutls_transport_get_ptr (session));
for (x = 0; x < ((n) / 16) + 1; x++)
{
if (sum > n)
break;
_gnutls_write_log ("%.4x - ", x);
MHD__gnutls_write_log ("%.4x - ", x);
for (j = 0; j < 16; j++)
{
if (sum < n)
{
_gnutls_write_log ("%.2x ", ((unsigned char *) ptr)[sum++]);
MHD__gnutls_write_log ("%.2x ", ((unsigned char *) ptr)[sum++]);
}
else
break;
}
_gnutls_write_log ("\n");
MHD__gnutls_write_log ("\n");
}
_gnutls_write_log ("\n");
MHD__gnutls_write_log ("\n");
}
#endif
if (n == 0)
{ /* if we have no data to send */
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
else if (ptr == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
left = n;
while (left > 0)
{
ret = mhd_gtls_send_int (session, type, htype, &ptr[n - left], left);
ret = MHD_gtls_send_int (session, type, htype, &ptr[n - left], left);
if (ret <= 0)
{
if (ret == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
ret = GNUTLS_E_INTERNAL_ERROR;
}
if (left > 0 && (ret == GNUTLS_E_INTERRUPTED || ret
== GNUTLS_E_AGAIN))
{
gnutls_assert ();
MHD_gnutls_assert ();
retval =
_gnutls_buffer_insert (&session->internals.
MHD__gnutls_buffer_insert (&session->internals.
handshake_send_buffer, &ptr[n - left],
left);
if (retval < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return retval;
}
@@ -1030,7 +1030,7 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
session->internals.handshake_send_buffer.length = 0;
}
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
left -= ret;
@@ -1049,9 +1049,9 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
* protocol. Makes sure that we have received all data.
*/
ssize_t
mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
MHD_gtls_handshake_io_recv_int (MHD_gtls_session_t session,
content_type_t type,
gnutls_handshake_description_t htype,
MHD_gnutls_handshake_description_t htype,
void *iptr, size_t sizeOfPtr)
{
size_t left;
@@ -1064,7 +1064,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
if (sizeOfPtr == 0 || iptr == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
@@ -1075,7 +1075,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
{
/* if requested less data then return it.
*/
gnutls_assert ();
MHD_gnutls_assert ();
memcpy (iptr, session->internals.handshake_recv_buffer.data,
sizeOfPtr);
@@ -1087,7 +1087,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
return sizeOfPtr;
}
gnutls_assert ();
MHD_gnutls_assert ();
memcpy (iptr, session->internals.handshake_recv_buffer.data,
session->internals.handshake_recv_buffer.length);
@@ -1102,21 +1102,21 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
while (left > 0)
{
dsize = sizeOfPtr - left;
i = mhd_gtls_recv_int (session, type, htype, &ptr[dsize], left);
i = MHD_gtls_recv_int (session, type, htype, &ptr[dsize], left);
if (i < 0)
{
if (dsize > 0 && (i == GNUTLS_E_INTERRUPTED || i == GNUTLS_E_AGAIN))
{
gnutls_assert ();
MHD_gnutls_assert ();
session->internals.handshake_recv_buffer.data
=
mhd_gtls_realloc_fast (session->internals.
MHD_gtls_realloc_fast (session->internals.
handshake_recv_buffer.data, dsize);
if (session->internals.handshake_recv_buffer.data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -1131,7 +1131,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
else
session->internals.handshake_recv_buffer.length = 0;
gnutls_assert ();
MHD_gnutls_assert ();
return i;
}
@@ -1155,7 +1155,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
* and finished messages.
*/
int
mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
MHD_gtls_handshake_buffer_put (MHD_gtls_session_t session, opaque * data,
size_t length)
{
@@ -1172,16 +1172,16 @@ mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
internals.
max_handshake_data_buffer_size))
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
_gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data\n", length);
MHD__gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data\n", length);
if (mhd_gtls_buffer_append (&session->internals.handshake_hash_buffer, data,
if (MHD_gtls_buffer_append (&session->internals.handshake_hash_buffer, data,
length) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -1189,7 +1189,7 @@ mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
}
int
mhd_gtls_handshake_buffer_get_size (mhd_gtls_session_t session)
MHD_gtls_handshake_buffer_get_size (MHD_gtls_session_t session)
{
return session->internals.handshake_hash_buffer.length;
@@ -1199,7 +1199,7 @@ mhd_gtls_handshake_buffer_get_size (mhd_gtls_session_t session)
* and returns data from it (peek mode!)
*/
int
mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
MHD_gtls_handshake_buffer_peek (MHD_gtls_session_t session, opaque * data,
size_t length)
{
if (length > session->internals.handshake_hash_buffer.length)
@@ -1207,7 +1207,7 @@ mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
length = session->internals.handshake_hash_buffer.length;
}
_gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n", length);
MHD__gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n", length);
memcpy (data, session->internals.handshake_hash_buffer.data, length);
return length;
@@ -1217,13 +1217,13 @@ mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
* and returns data from it (peek mode!)
*/
int
mhd_gtls_handshake_buffer_get_ptr (mhd_gtls_session_t session,
MHD_gtls_handshake_buffer_get_ptr (MHD_gtls_session_t session,
opaque ** data_ptr, size_t * length)
{
if (length != NULL)
*length = session->internals.handshake_hash_buffer.length;
_gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n",
MHD__gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n",
session->internals.handshake_hash_buffer.length);
if (data_ptr != NULL)
@@ -1235,10 +1235,10 @@ mhd_gtls_handshake_buffer_get_ptr (mhd_gtls_session_t session,
/* Does not free the buffer
*/
int
mhd_gtls_handshake_buffer_empty (mhd_gtls_session_t session)
MHD_gtls_handshake_buffer_empty (MHD_gtls_session_t session)
{
_gnutls_buffers_log ("BUF[HSK]: Emptied buffer\n");
MHD__gnutls_buffers_log ("BUF[HSK]: Emptied buffer\n");
session->internals.handshake_hash_buffer.length = 0;
@@ -1246,9 +1246,9 @@ mhd_gtls_handshake_buffer_empty (mhd_gtls_session_t session)
}
int
mhd_gtls_handshake_buffer_clear (mhd_gtls_session_t session)
MHD_gtls_handshake_buffer_clear (MHD_gtls_session_t session)
{
_gnutls_buffers_log ("BUF[HSK]: Cleared Data from buffer\n");
mhd_gtls_buffer_clear (&session->internals.handshake_hash_buffer);
MHD__gnutls_buffers_log ("BUF[HSK]: Cleared Data from buffer\n");
MHD_gtls_buffer_clear (&session->internals.handshake_hash_buffer);
return 0;
}
src/daemon/https/tls/gnutls_buffers.h
+27 -27
View File
@@ -22,46 +22,46 @@
*
*/
int mhd_gnutls_record_buffer_put (content_type_t type,
mhd_gtls_session_t session, opaque * data,
int MHD_gnutls_record_buffer_put (content_type_t type,
MHD_gtls_session_t session, opaque * data,
size_t length);
int mhd_gnutls_record_buffer_get_size (content_type_t type,
mhd_gtls_session_t session);
int mhd_gtls_record_buffer_get (content_type_t type,
mhd_gtls_session_t session, opaque * data,
int MHD_gnutls_record_buffer_get_size (content_type_t type,
MHD_gtls_session_t session);
int MHD_gtls_record_buffer_get (content_type_t type,
MHD_gtls_session_t session, opaque * data,
size_t length);
ssize_t mhd_gtls_io_read_buffered (mhd_gtls_session_t, opaque ** iptr,
ssize_t MHD_gtls_io_read_buffered (MHD_gtls_session_t, opaque ** iptr,
size_t n, content_type_t);
void mhd_gtls_io_clear_read_buffer (mhd_gtls_session_t);
int mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session);
void MHD_gtls_io_clear_read_buffer (MHD_gtls_session_t);
int MHD_gtls_io_clear_peeked_data (MHD_gtls_session_t session);
ssize_t mhd_gtls_io_write_buffered (mhd_gtls_session_t, const void *iptr,
ssize_t MHD_gtls_io_write_buffered (MHD_gtls_session_t, const void *iptr,
size_t n);
ssize_t mhd_gtls_io_write_buffered2 (mhd_gtls_session_t, const void *iptr,
ssize_t MHD_gtls_io_write_buffered2 (MHD_gtls_session_t, const void *iptr,
size_t n, const void *iptr2, size_t n2);
int mhd_gtls_handshake_buffer_get_size (mhd_gtls_session_t session);
int mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
int MHD_gtls_handshake_buffer_get_size (MHD_gtls_session_t session);
int MHD_gtls_handshake_buffer_peek (MHD_gtls_session_t session, opaque * data,
size_t length);
int mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
int MHD_gtls_handshake_buffer_put (MHD_gtls_session_t session, opaque * data,
size_t length);
int mhd_gtls_handshake_buffer_clear (mhd_gtls_session_t session);
int mhd_gtls_handshake_buffer_empty (mhd_gtls_session_t session);
int mhd_gtls_handshake_buffer_get_ptr (mhd_gtls_session_t session,
int MHD_gtls_handshake_buffer_clear (MHD_gtls_session_t session);
int MHD_gtls_handshake_buffer_empty (MHD_gtls_session_t session);
int MHD_gtls_handshake_buffer_get_ptr (MHD_gtls_session_t session,
opaque ** data_ptr, size_t * length);
#define _gnutls_handshake_io_buffer_clear( session) \
mhd_gtls_buffer_clear( &session->internals.handshake_send_buffer); \
mhd_gtls_buffer_clear( &session->internals.handshake_recv_buffer); \
#define MHD__gnutls_handshake_io_buffer_clear( session) \
MHD_gtls_buffer_clear( &session->internals.handshake_send_buffer); \
MHD_gtls_buffer_clear( &session->internals.handshake_recv_buffer); \
session->internals.handshake_send_buffer_prev_size = 0
ssize_t mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t, content_type_t,
gnutls_handshake_description_t,
ssize_t MHD_gtls_handshake_io_recv_int (MHD_gtls_session_t, content_type_t,
MHD_gnutls_handshake_description_t,
void *, size_t);
ssize_t mhd_gtls_handshake_io_send_int (mhd_gtls_session_t, content_type_t,
gnutls_handshake_description_t,
ssize_t MHD_gtls_handshake_io_send_int (MHD_gtls_session_t, content_type_t,
MHD_gnutls_handshake_description_t,
const void *, size_t);
ssize_t mhd_gtls_io_write_flush (mhd_gtls_session_t session);
ssize_t mhd_gtls_handshake_io_write_flush (mhd_gtls_session_t session);
ssize_t MHD_gtls_io_write_flush (MHD_gtls_session_t session);
ssize_t MHD_gtls_handshake_io_write_flush (MHD_gtls_session_t session);
size_t MHD_gtls_record_check_pending (mhd_gtls_session_t session);
size_t MHD_gtls_record_check_pending (MHD_gtls_session_t session);
src/daemon/https/tls/gnutls_cert.c
+141 -141
View File
@@ -45,8 +45,8 @@
#include "mpi.h"
/**
* MHD_gnutls_certificate_free_keys - Used to free all the keys from a mhd_gtls_cert_credentials_t structure
* @sc: is an #mhd_gtls_cert_credentials_t structure.
* MHD__gnutls_certificate_free_keys - Used to free all the keys from a MHD_gtls_cert_credentials_t structure
* @sc: is an #MHD_gtls_cert_credentials_t structure.
*
* This function will delete all the keys and the certificates associated
* with the given credentials. This function must not be called when a
@@ -54,7 +54,7 @@
*
**/
void
MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
MHD__gnutls_certificate_free_keys (MHD_gtls_cert_credentials_t sc)
{
unsigned i, j;
@@ -62,23 +62,23 @@ MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
{
for (j = 0; j < sc->cert_list_length[i]; j++)
{
mhd_gtls_gcert_deinit (&sc->cert_list[i][j]);
MHD_gtls_gcert_deinit (&sc->cert_list[i][j]);
}
gnutls_free (sc->cert_list[i]);
MHD_gnutls_free (sc->cert_list[i]);
}
gnutls_free (sc->cert_list_length);
MHD_gnutls_free (sc->cert_list_length);
sc->cert_list_length = NULL;
gnutls_free (sc->cert_list);
MHD_gnutls_free (sc->cert_list);
sc->cert_list = NULL;
for (i = 0; i < sc->ncerts; i++)
{
mhd_gtls_gkey_deinit (&sc->pkey[i]);
MHD_gtls_gkey_deinit (&sc->pkey[i]);
}
gnutls_free (sc->pkey);
MHD_gnutls_free (sc->pkey);
sc->pkey = NULL;
sc->ncerts = 0;
@@ -86,8 +86,8 @@ MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
}
/**
* MHD_gnutls_certificate_free_cas - Used to free all the CAs from a mhd_gtls_cert_credentials_t structure
* @sc: is an #mhd_gtls_cert_credentials_t structure.
* MHD__gnutls_certificate_free_cas - Used to free all the CAs from a MHD_gtls_cert_credentials_t structure
* @sc: is an #MHD_gtls_cert_credentials_t structure.
*
* This function will delete all the CAs associated
* with the given credentials. Servers that do not use
@@ -96,25 +96,25 @@ MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
*
**/
void
MHD_gnutls_certificate_free_cas (mhd_gtls_cert_credentials_t sc)
MHD__gnutls_certificate_free_cas (MHD_gtls_cert_credentials_t sc)
{
unsigned j;
for (j = 0; j < sc->x509_ncas; j++)
{
gnutls_x509_crt_deinit (sc->x509_ca_list[j]);
MHD_gnutls_x509_crt_deinit (sc->x509_ca_list[j]);
}
sc->x509_ncas = 0;
gnutls_free (sc->x509_ca_list);
MHD_gnutls_free (sc->x509_ca_list);
sc->x509_ca_list = NULL;
}
/**
* MHD_gnutls_certificate_free_ca_names - Used to free all the CA names from a mhd_gtls_cert_credentials_t structure
* @sc: is an #mhd_gtls_cert_credentials_t structure.
* MHD__gnutls_certificate_free_ca_names - Used to free all the CA names from a MHD_gtls_cert_credentials_t structure
* @sc: is an #MHD_gtls_cert_credentials_t structure.
*
* This function will delete all the CA name in the
* given credentials. Clients may call this to save some memory
@@ -125,13 +125,13 @@ MHD_gnutls_certificate_free_cas (mhd_gtls_cert_credentials_t sc)
*
**/
void
MHD_gnutls_certificate_free_ca_names (mhd_gtls_cert_credentials_t sc)
MHD__gnutls_certificate_free_ca_names (MHD_gtls_cert_credentials_t sc)
{
_gnutls_free_datum (&sc->x509_rdn_sequence);
MHD__gnutls_free_datum (&sc->x509_rdn_sequence);
}
/*-
* mhd_gtls_certificate_get_rsa_params - Returns the RSA parameters pointer
* MHD_gtls_certificate_get_rsa_params - Returns the RSA parameters pointer
* @rsa_params: holds the RSA parameters or NULL.
* @func: function to retrieve the parameters or NULL.
* @session: The session.
@@ -139,12 +139,12 @@ MHD_gnutls_certificate_free_ca_names (mhd_gtls_cert_credentials_t sc)
* This function will return the rsa parameters pointer.
*
-*/
mhd_gtls_rsa_params_t
mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
gnutls_params_function * func,
mhd_gtls_session_t session)
MHD_gtls_rsa_params_t
MHD_gtls_certificate_get_rsa_params (MHD_gtls_rsa_params_t rsa_params,
MHD_gnutls_params_function * func,
MHD_gtls_session_t session)
{
gnutls_params_st params;
MHD_gnutls_params_st params;
int ret;
if (session->internals.params.rsa_params)
@@ -171,8 +171,8 @@ mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
/**
* MHD_gnutls_certificate_free_credentials - Used to free an allocated mhd_gtls_cert_credentials_t structure
* @sc: is an #mhd_gtls_cert_credentials_t structure.
* MHD__gnutls_certificate_free_credentials - Used to free an allocated MHD_gtls_cert_credentials_t structure
* @sc: is an #MHD_gtls_cert_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus
* this helper function is provided in order to free (deallocate) it.
@@ -182,26 +182,26 @@ mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
* this function).
**/
void
MHD_gnutls_certificate_free_credentials (mhd_gtls_cert_credentials_t sc)
MHD__gnutls_certificate_free_credentials (MHD_gtls_cert_credentials_t sc)
{
MHD_gnutls_certificate_free_keys (sc);
MHD_gnutls_certificate_free_cas (sc);
MHD_gnutls_certificate_free_ca_names (sc);
MHD__gnutls_certificate_free_keys (sc);
MHD__gnutls_certificate_free_cas (sc);
MHD__gnutls_certificate_free_ca_names (sc);
#ifdef ENABLE_PKI
MHD_gnutls_certificate_free_crls (sc);
MHD__gnutls_certificate_free_crls (sc);
#endif
#ifdef KEYRING_HACK
_gnutls_free_datum (&sc->keyring);
MHD__gnutls_free_datum (&sc->keyring);
#endif
gnutls_free (sc);
MHD_gnutls_free (sc);
}
/**
* MHD_gnutls_certificate_allocate_credentials - Used to allocate a mhd_gtls_cert_credentials_t structure
* @res: is a pointer to an #mhd_gtls_cert_credentials_t structure.
* MHD__gnutls_certificate_allocate_credentials - Used to allocate a MHD_gtls_cert_credentials_t structure
* @res: is a pointer to an #MHD_gtls_cert_credentials_t structure.
*
* This structure is complex enough to manipulate directly thus this
* helper function is provided in order to allocate it.
@@ -209,10 +209,10 @@ MHD_gnutls_certificate_free_credentials (mhd_gtls_cert_credentials_t sc)
* Returns: %GNUTLS_E_SUCCESS on success, or an error code.
**/
int
MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_credentials_t *
MHD__gnutls_certificate_allocate_credentials (MHD_gtls_cert_credentials_t *
res)
{
*res = gnutls_calloc (1, sizeof (mhd_gtls_cert_credentials_st));
*res = MHD_gnutls_calloc (1, sizeof (MHD_gtls_cert_credentials_st));
if (*res == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -231,14 +231,14 @@ MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_credentials_t *
* extensions in order to disable unneded algorithms.
*/
int
mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
MHD_gtls_selected_cert_supported_kx (MHD_gtls_session_t session,
enum MHD_GNUTLS_KeyExchangeAlgorithm
**alg, int *alg_size)
{
enum MHD_GNUTLS_KeyExchangeAlgorithm kx;
enum MHD_GNUTLS_PublicKeyAlgorithm pk;
enum MHD_GNUTLS_KeyExchangeAlgorithm kxlist[MAX_ALGOS];
gnutls_cert *cert;
MHD_gnutls_cert *cert;
int i;
if (session->internals.selected_cert_list_length == 0)
@@ -253,11 +253,11 @@ mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
for (kx = 0; kx < MAX_ALGOS; kx++)
{
pk = mhd_gtls_map_pk_get_pk (kx);
pk = MHD_gtls_map_pk_get_pk (kx);
if (pk == cert->subject_pk_algorithm)
{
/* then check key usage */
if (_gnutls_check_key_usage (cert, kx) == 0)
if (MHD__gnutls_check_key_usage (cert, kx) == 0)
{
kxlist[i] = kx;
i++;
@@ -267,11 +267,11 @@ mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
if (i == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
*alg = gnutls_calloc (1, sizeof (enum MHD_GNUTLS_KeyExchangeAlgorithm) * i);
*alg = MHD_gnutls_calloc (1, sizeof (enum MHD_GNUTLS_KeyExchangeAlgorithm) * i);
if (*alg == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -285,7 +285,7 @@ mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
/**
* MHD_gtls_certificate_server_set_request - Used to set whether to request a client certificate
* @session: is an #mhd_gtls_session_t structure.
* @session: is an #MHD_gtls_session_t structure.
* @req: is one of GNUTLS_CERT_REQUEST, GNUTLS_CERT_REQUIRE
*
* This function specifies if we (in case of a server) are going
@@ -296,28 +296,28 @@ mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
* send a certificate.
**/
void
MHD_gtls_certificate_server_set_request (mhd_gtls_session_t session,
gnutls_certificate_request_t req)
MHD_gtls_certificate_server_set_request (MHD_gtls_session_t session,
MHD_gnutls_certificate_request_t req)
{
session->internals.send_cert_req = req;
}
/**
* MHD_gtls_certificate_client_set_retrieve_function - Used to set a callback to retrieve the certificate
* @cred: is a #mhd_gtls_cert_credentials_t structure.
* @cred: is a #MHD_gtls_cert_credentials_t structure.
* @func: is the callback function
*
* This function sets a callback to be called in order to retrieve the certificate
* to be used in the handshake.
* The callback's function prototype is:
* int (*callback)(mhd_gtls_session_t, const gnutls_datum_t* req_ca_dn, int nreqs,
* const enum MHD_GNUTLS_PublicKeyAlgorithm* pk_algos, int pk_algos_length, gnutls_retr_st* st);
* int (*callback)(MHD_gtls_session_t, const MHD_gnutls_datum_t* req_ca_dn, int nreqs,
* const enum MHD_GNUTLS_PublicKeyAlgorithm* pk_algos, int pk_algos_length, MHD_gnutls_retr_st* st);
*
* @req_ca_cert is only used in X.509 certificates.
* Contains a list with the CA names that the server considers trusted.
* Normally we should send a certificate that is signed
* by one of these CAs. These names are DER encoded. To get a more
* meaningful value use the function gnutls_x509_rdn_get().
* meaningful value use the function MHD_gnutls_x509_rdn_get().
*
* @pk_algos contains a list with server's acceptable signature algorithms.
* The certificate returned should support the server's given algorithms.
@@ -333,21 +333,21 @@ MHD_gtls_certificate_server_set_request (mhd_gtls_session_t session,
* will be terminated.
**/
void MHD_gtls_certificate_client_set_retrieve_function
(mhd_gtls_cert_credentials_t cred,
gnutls_certificate_client_retrieve_function * func)
(MHD_gtls_cert_credentials_t cred,
MHD_gnutls_certificate_client_retrieve_function * func)
{
cred->client_get_cert_callback = func;
}
/**
* MHD_gtls_certificate_server_set_retrieve_function - Used to set a callback to retrieve the certificate
* @cred: is a #mhd_gtls_cert_credentials_t structure.
* @cred: is a #MHD_gtls_cert_credentials_t structure.
* @func: is the callback function
*
* This function sets a callback to be called in order to retrieve the certificate
* to be used in the handshake.
* The callback's function prototype is:
* int (*callback)(mhd_gtls_session_t, gnutls_retr_st* st);
* int (*callback)(MHD_gtls_session_t, MHD_gnutls_retr_st* st);
*
* @st should contain the certificates and private keys.
*
@@ -359,14 +359,14 @@ void MHD_gtls_certificate_client_set_retrieve_function
* will be terminated.
**/
void MHD_gtls_certificate_server_set_retrieve_function
(mhd_gtls_cert_credentials_t cred,
gnutls_certificate_server_retrieve_function * func)
(MHD_gtls_cert_credentials_t cred,
MHD_gnutls_certificate_server_retrieve_function * func)
{
cred->server_get_cert_callback = func;
}
/*-
* _gnutls_x509_extract_certificate_activation_time - This function returns the peer's certificate activation time
* MHD__gnutls_x509_extract_certificate_activation_time - This function returns the peer's certificate activation time
* @cert: should contain an X.509 DER encoded certificate
*
* This function will return the certificate's activation time in UNIX time
@@ -376,31 +376,31 @@ void MHD_gtls_certificate_server_set_retrieve_function
*
-*/
static time_t
_gnutls_x509_get_raw_crt_activation_time (const gnutls_datum_t * cert)
MHD__gnutls_x509_get_raw_crt_activation_time (const MHD_gnutls_datum_t * cert)
{
gnutls_x509_crt_t xcert;
MHD_gnutls_x509_crt_t xcert;
time_t result;
result = gnutls_x509_crt_init (&xcert);
result = MHD_gnutls_x509_crt_init (&xcert);
if (result < 0)
return (time_t) - 1;
result = gnutls_x509_crt_import (xcert, cert, GNUTLS_X509_FMT_DER);
result = MHD_gnutls_x509_crt_import (xcert, cert, GNUTLS_X509_FMT_DER);
if (result < 0)
{
gnutls_x509_crt_deinit (xcert);
MHD_gnutls_x509_crt_deinit (xcert);
return (time_t) - 1;
}
result = gnutls_x509_crt_get_activation_time (xcert);
result = MHD_gnutls_x509_crt_get_activation_time (xcert);
gnutls_x509_crt_deinit (xcert);
MHD_gnutls_x509_crt_deinit (xcert);
return result;
}
/*-
* gnutls_x509_extract_certificate_expiration_time - This function returns the certificate's expiration time
* MHD_gnutls_x509_extract_certificate_expiration_time - This function returns the certificate's expiration time
* @cert: should contain an X.509 DER encoded certificate
*
* This function will return the certificate's expiration time in UNIX
@@ -410,25 +410,25 @@ _gnutls_x509_get_raw_crt_activation_time (const gnutls_datum_t * cert)
*
-*/
static time_t
_gnutls_x509_get_raw_crt_expiration_time (const gnutls_datum_t * cert)
MHD__gnutls_x509_get_raw_crt_expiration_time (const MHD_gnutls_datum_t * cert)
{
gnutls_x509_crt_t xcert;
MHD_gnutls_x509_crt_t xcert;
time_t result;
result = gnutls_x509_crt_init (&xcert);
result = MHD_gnutls_x509_crt_init (&xcert);
if (result < 0)
return (time_t) - 1;
result = gnutls_x509_crt_import (xcert, cert, GNUTLS_X509_FMT_DER);
result = MHD_gnutls_x509_crt_import (xcert, cert, GNUTLS_X509_FMT_DER);
if (result < 0)
{
gnutls_x509_crt_deinit (xcert);
MHD_gnutls_x509_crt_deinit (xcert);
return (time_t) - 1;
}
result = gnutls_x509_crt_get_expiration_time (xcert);
result = MHD_gnutls_x509_crt_get_expiration_time (xcert);
gnutls_x509_crt_deinit (xcert);
MHD_gnutls_x509_crt_deinit (xcert);
return result;
}
@@ -440,34 +440,34 @@ _gnutls_x509_get_raw_crt_expiration_time (const gnutls_datum_t * cert)
*
* This function will try to verify the peer's certificate and return
* its status (trusted, invalid etc.). The value of @status should
* be one or more of the gnutls_certificate_status_t enumerated
* be one or more of the MHD_gnutls_certificate_status_t enumerated
* elements bitwise or'd. To avoid denial of service attacks some
* default upper limits regarding the certificate key size and chain
* size are set. To override them use
* MHD_gnutls_certificate_set_verify_limits().
* MHD__gnutls_certificate_set_verify_limits().
*
* Note that you must also check the peer's name in order to check if
* the verified certificate belongs to the actual peer.
*
* This is the same as gnutls_x509_crt_list_verify() and uses the
* This is the same as MHD_gnutls_x509_crt_list_verify() and uses the
* loaded CAs in the credentials as trusted CAs.
*
* Note that some commonly used X.509 Certificate Authorities are
* still using Version 1 certificates. If you want to accept them,
* you need to call MHD_gnutls_certificate_set_verify_flags() with, e.g.,
* you need to call MHD__gnutls_certificate_set_verify_flags() with, e.g.,
* %GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT parameter.
*
* Returns: a negative error code on error and zero on success.
**/
int
MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
MHD_gtls_certificate_verify_peers2 (MHD_gtls_session_t session,
unsigned int *status)
{
cert_auth_info_t info;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
info = mhd_gtls_get_auth_info (session);
info = MHD_gtls_get_auth_info (session);
if (info == NULL)
{
return GNUTLS_E_NO_CERTIFICATE_FOUND;
@@ -476,10 +476,10 @@ MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
if (info->raw_certificate_list == NULL || info->ncerts == 0)
return GNUTLS_E_NO_CERTIFICATE_FOUND;
switch (gnutls_certificate_type_get (session))
switch (MHD_gnutls_certificate_type_get (session))
{
case MHD_GNUTLS_CRT_X509:
return _gnutls_x509_cert_verify_peers (session, status);
return MHD__gnutls_x509_cert_verify_peers (session, status);
default:
return GNUTLS_E_INVALID_REQUEST;
}
@@ -495,15 +495,15 @@ MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
* belongs to the actual peer.
*
* The return value should be one or more of the
* gnutls_certificate_status_t enumerated elements bitwise or'd, or a
* MHD_gnutls_certificate_status_t enumerated elements bitwise or'd, or a
* negative value on error.
*
* This is the same as gnutls_x509_crt_list_verify().
* This is the same as MHD_gnutls_x509_crt_list_verify().
*
* Deprecated: Use MHD_gtls_certificate_verify_peers2() instead.
**/
int
MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session)
MHD_gtls_certificate_verify_peers (MHD_gtls_session_t session)
{
unsigned int status;
int ret;
@@ -512,7 +512,7 @@ MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session)
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -528,13 +528,13 @@ MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session)
* Returns: (time_t)-1 on error.
**/
time_t
MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t session)
MHD_gtls_certificate_expiration_time_peers (MHD_gtls_session_t session)
{
cert_auth_info_t info;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
info = mhd_gtls_get_auth_info (session);
info = MHD_gtls_get_auth_info (session);
if (info == NULL)
{
return (time_t) - 1;
@@ -542,15 +542,15 @@ MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t session)
if (info->raw_certificate_list == NULL || info->ncerts == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return (time_t) - 1;
}
switch (gnutls_certificate_type_get (session))
switch (MHD_gnutls_certificate_type_get (session))
{
case MHD_GNUTLS_CRT_X509:
return
_gnutls_x509_get_raw_crt_expiration_time (&info->raw_certificate_list
MHD__gnutls_x509_get_raw_crt_expiration_time (&info->raw_certificate_list
[0]);
default:
return (time_t) - 1;
@@ -567,13 +567,13 @@ MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t session)
* Returns: (time_t)-1 on error.
**/
time_t
MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t session)
MHD_gtls_certificate_activation_time_peers (MHD_gtls_session_t session)
{
cert_auth_info_t info;
CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
info = mhd_gtls_get_auth_info (session);
info = MHD_gtls_get_auth_info (session);
if (info == NULL)
{
return (time_t) - 1;
@@ -581,15 +581,15 @@ MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t session)
if (info->raw_certificate_list == NULL || info->ncerts == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return (time_t) - 1;
}
switch (gnutls_certificate_type_get (session))
switch (MHD_gnutls_certificate_type_get (session))
{
case MHD_GNUTLS_CRT_X509:
return
_gnutls_x509_get_raw_crt_activation_time (&info->raw_certificate_list
MHD__gnutls_x509_get_raw_crt_activation_time (&info->raw_certificate_list
[0]);
default:
return (time_t) - 1;
@@ -597,33 +597,33 @@ MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t session)
}
int
mhd_gtls_raw_cert_to_gcert (gnutls_cert * gcert,
MHD_gtls_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
enum MHD_GNUTLS_CertificateType type,
const gnutls_datum_t * raw_cert,
const MHD_gnutls_datum_t * raw_cert,
int flags /* OR of ConvFlags */ )
{
switch (type)
{
case MHD_GNUTLS_CRT_X509:
return mhd_gtls_x509_raw_cert_to_gcert (gcert, raw_cert, flags);
return MHD_gtls_x509_raw_cert_to_gcert (gcert, raw_cert, flags);
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
}
int
mhd_gtls_raw_privkey_to_gkey (gnutls_privkey * key,
MHD_gtls_raw_privkey_to_gkey (MHD_gnutls_privkey * key,
enum MHD_GNUTLS_CertificateType type,
const gnutls_datum_t * raw_key,
const MHD_gnutls_datum_t * raw_key,
int key_enc /* DER or PEM */ )
{
switch (type)
{
case MHD_GNUTLS_CRT_X509:
return _gnutls_x509_raw_privkey_to_gkey (key, raw_key, key_enc);
return MHD__gnutls_x509_raw_privkey_to_gkey (key, raw_key, key_enc);
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
}
@@ -639,30 +639,30 @@ mhd_gtls_raw_privkey_to_gkey (gnutls_privkey * key,
* The critical extensions will be catched by the verification functions.
*/
int
mhd_gtls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
const gnutls_datum_t * derCert,
MHD_gtls_x509_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
const MHD_gnutls_datum_t * derCert,
int flags /* OR of ConvFlags */ )
{
int ret;
gnutls_x509_crt_t cert;
MHD_gnutls_x509_crt_t cert;
ret = gnutls_x509_crt_init (&cert);
ret = MHD_gnutls_x509_crt_init (&cert);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret = gnutls_x509_crt_import (cert, derCert, GNUTLS_X509_FMT_DER);
ret = MHD_gnutls_x509_crt_import (cert, derCert, GNUTLS_X509_FMT_DER);
if (ret < 0)
{
gnutls_assert ();
gnutls_x509_crt_deinit (cert);
MHD_gnutls_assert ();
MHD_gnutls_x509_crt_deinit (cert);
return ret;
}
ret = mhd_gtls_x509_crt_to_gcert (gcert, cert, flags);
gnutls_x509_crt_deinit (cert);
ret = MHD_gtls_x509_crt_to_gcert (gcert, cert, flags);
MHD_gnutls_x509_crt_deinit (cert);
return ret;
}
@@ -670,12 +670,12 @@ mhd_gtls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
/* Like above but it accepts a parsed certificate instead.
*/
int
mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
gnutls_x509_crt_t cert, unsigned int flags)
MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert,
MHD_gnutls_x509_crt_t cert, unsigned int flags)
{
int ret = 0;
memset (gcert, 0, sizeof (gnutls_cert));
memset (gcert, 0, sizeof (MHD_gnutls_cert));
gcert->cert_type = MHD_GNUTLS_CRT_X509;
if (!(flags & CERT_NO_COPY))
@@ -687,38 +687,38 @@ mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
/* initially allocate a bogus size, just in case the certificate
* fits in it. That way we minimize the DER encodings performed.
*/
der = gnutls_malloc (SMALL_DER);
der = MHD_gnutls_malloc (SMALL_DER);
if (der == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
ret =
gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der, &der_size);
MHD_gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der, &der_size);
if (ret < 0 && ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
{
gnutls_assert ();
gnutls_free (der);
MHD_gnutls_assert ();
MHD_gnutls_free (der);
return ret;
}
if (ret == GNUTLS_E_SHORT_MEMORY_BUFFER)
{
der = gnutls_realloc (der, der_size);
der = MHD_gnutls_realloc (der, der_size);
if (der == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
ret =
gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der,
MHD_gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der,
&der_size);
if (ret < 0)
{
gnutls_assert ();
gnutls_free (der);
MHD_gnutls_assert ();
MHD_gnutls_free (der);
return ret;
}
}
@@ -733,19 +733,19 @@ mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
if (flags & CERT_ONLY_EXTENSIONS || flags == 0)
{
gnutls_x509_crt_get_key_usage (cert, &gcert->key_usage, NULL);
gcert->version = gnutls_x509_crt_get_version (cert);
MHD_gnutls_x509_crt_get_key_usage (cert, &gcert->key_usage, NULL);
gcert->version = MHD_gnutls_x509_crt_get_version (cert);
}
gcert->subject_pk_algorithm = gnutls_x509_crt_get_pk_algorithm (cert, NULL);
gcert->subject_pk_algorithm = MHD_gnutls_x509_crt_get_pk_algorithm (cert, NULL);
if (flags & CERT_ONLY_PUBKEY || flags == 0)
{
gcert->params_size = MAX_PUBLIC_PARAMS_SIZE;
ret =
_gnutls_x509_crt_get_mpis (cert, gcert->params, &gcert->params_size);
MHD__gnutls_x509_crt_get_mpis (cert, gcert->params, &gcert->params_size);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
@@ -755,7 +755,7 @@ mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
}
void
mhd_gtls_gcert_deinit (gnutls_cert * cert)
MHD_gtls_gcert_deinit (MHD_gnutls_cert * cert)
{
int i;
@@ -764,10 +764,10 @@ mhd_gtls_gcert_deinit (gnutls_cert * cert)
for (i = 0; i < cert->params_size; i++)
{
mhd_gtls_mpi_release (&cert->params[i]);
MHD_gtls_mpi_release (&cert->params[i]);
}
_gnutls_free_datum (&cert->raw);
MHD__gnutls_free_datum (&cert->raw);
}
/**
@@ -778,20 +778,20 @@ mhd_gtls_gcert_deinit (gnutls_cert * cert)
*
* Set the callback function. The function must have this prototype:
*
* typedef int (*gnutls_sign_func) (mhd_gtls_session_t session,
* typedef int (*MHD_gnutls_sign_func) (MHD_gtls_session_t session,
* void *userdata,
* enum MHD_GNUTLS_CertificateType cert_type,
* const gnutls_datum_t * cert,
* const gnutls_datum_t * hash,
* gnutls_datum_t * signature);
* const MHD_gnutls_datum_t * cert,
* const MHD_gnutls_datum_t * hash,
* MHD_gnutls_datum_t * signature);
*
* The @userdata parameter is passed to the @sign_func verbatim, and
* can be used to store application-specific data needed in the
* callback function. See also MHD_gtls_sign_callback_get().
**/
void
MHD_gtls_sign_callback_set (mhd_gtls_session_t session,
gnutls_sign_func sign_func, void *userdata)
MHD_gtls_sign_callback_set (MHD_gtls_session_t session,
MHD_gnutls_sign_func sign_func, void *userdata)
{
session->internals.sign_func = sign_func;
session->internals.sign_func_userdata = userdata;
@@ -807,8 +807,8 @@ MHD_gtls_sign_callback_set (mhd_gtls_session_t session,
* Returns: The function pointer set by MHD_gtls_sign_callback_set(), or
* if not set, %NULL.
**/
gnutls_sign_func
MHD_gtls_sign_callback_get (mhd_gtls_session_t session, void **userdata)
MHD_gnutls_sign_func
MHD_gtls_sign_callback_get (MHD_gtls_session_t session, void **userdata)
{
if (userdata)
*userdata = session->internals.sign_func_userdata;
src/daemon/https/tls/gnutls_cert.h
+16 -16
View File
@@ -48,7 +48,7 @@
#define KEY_ENCIPHER_ONLY 1
#define KEY_DECIPHER_ONLY 32768
typedef struct gnutls_cert
typedef struct MHD_gnutls_cert
{
mpi_t params[MAX_PUBLIC_PARAMS_SIZE]; /* the size of params depends on the public
* key algorithm
@@ -71,11 +71,11 @@ typedef struct gnutls_cert
*/
enum MHD_GNUTLS_CertificateType cert_type;
gnutls_datum_t raw;
MHD_gnutls_datum_t raw;
} gnutls_cert;
} MHD_gnutls_cert;
typedef struct gnutls_privkey_int
typedef struct MHD_gnutls_privkey_int
{
mpi_t params[MAX_PRIV_PARAMS_SIZE]; /* the size of params depends on the public
* key algorithm
@@ -96,9 +96,9 @@ typedef struct gnutls_privkey_int
int params_size; /* holds the number of params */
enum MHD_GNUTLS_PublicKeyAlgorithm pk_algorithm;
} gnutls_privkey;
} MHD_gnutls_privkey;
struct MHD_gtls_session_int; /* because mhd_gtls_session_t is not defined when this file is included */
struct MHD_gtls_session_int; /* because MHD_gtls_session_t is not defined when this file is included */
typedef enum ConvFlags
{
@@ -107,26 +107,26 @@ typedef enum ConvFlags
CERT_ONLY_EXTENSIONS = 16
} ConvFlags;
int mhd_gtls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
const gnutls_datum_t * derCert,
int MHD_gtls_x509_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
const MHD_gnutls_datum_t * derCert,
int flags);
int mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert, gnutls_x509_crt_t cert,
int MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert, MHD_gnutls_x509_crt_t cert,
unsigned int flags);
void mhd_gtls_gkey_deinit (gnutls_privkey * key);
void mhd_gtls_gcert_deinit (gnutls_cert * cert);
void MHD_gtls_gkey_deinit (MHD_gnutls_privkey * key);
void MHD_gtls_gcert_deinit (MHD_gnutls_cert * cert);
int mhd_gtls_selected_cert_supported_kx (struct MHD_gtls_session_int *session,
int MHD_gtls_selected_cert_supported_kx (struct MHD_gtls_session_int *session,
enum MHD_GNUTLS_KeyExchangeAlgorithm
**alg, int *alg_size);
int mhd_gtls_raw_cert_to_gcert (gnutls_cert * gcert,
int MHD_gtls_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
enum MHD_GNUTLS_CertificateType type,
const gnutls_datum_t * raw_cert,
const MHD_gnutls_datum_t * raw_cert,
int flags /* OR of ConvFlags */ );
int mhd_gtls_raw_privkey_to_gkey (gnutls_privkey * key,
int MHD_gtls_raw_privkey_to_gkey (MHD_gnutls_privkey * key,
enum MHD_GNUTLS_CertificateType type,
const gnutls_datum_t * raw_key,
const MHD_gnutls_datum_t * raw_key,
int key_enc /* DER or PEM */ );
#endif
src/daemon/https/tls/gnutls_cipher.c
+78 -78
View File
@@ -42,7 +42,7 @@
#include <gc.h>
inline static int
is_write_comp_null (mhd_gtls_session_t session)
is_write_comp_null (MHD_gtls_session_t session)
{
if (session->security_parameters.write_compression_algorithm ==
MHD_GNUTLS_COMP_NULL)
@@ -52,7 +52,7 @@ is_write_comp_null (mhd_gtls_session_t session)
}
inline static int
is_read_comp_null (mhd_gtls_session_t session)
is_read_comp_null (MHD_gtls_session_t session)
{
if (session->security_parameters.read_compression_algorithm ==
MHD_GNUTLS_COMP_NULL)
@@ -68,13 +68,13 @@ is_read_comp_null (mhd_gtls_session_t session)
* If random pad != 0 then the random pad data will be appended.
*/
int
mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
MHD_gtls_encrypt (MHD_gtls_session_t session, const opaque * headers,
size_t headers_size, const opaque * data,
size_t data_size, opaque * ciphertext,
size_t ciphertext_size, content_type_t type, int random_pad)
{
gnutls_datum_t plain;
gnutls_datum_t comp;
MHD_gnutls_datum_t plain;
MHD_gnutls_datum_t comp;
int ret;
int free_comp = 1;
@@ -91,31 +91,31 @@ mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
/* Here comp is allocated and must be
* freed.
*/
ret = _gnutls_m_plaintext2compressed (session, &comp, &plain);
ret = MHD__gnutls_m_plaintext2compressed (session, &comp, &plain);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
ret = mhd_gtls_compressed2ciphertext (session, &ciphertext[headers_size],
ret = MHD_gtls_compressed2ciphertext (session, &ciphertext[headers_size],
ciphertext_size - headers_size,
comp, type, random_pad);
if (free_comp)
_gnutls_free_datum (&comp);
MHD__gnutls_free_datum (&comp);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
/* copy the headers */
memcpy (ciphertext, headers, headers_size);
mhd_gtls_write_uint16 (ret, &ciphertext[3]);
MHD_gtls_write_uint16 (ret, &ciphertext[3]);
return ret + headers_size;
}
@@ -124,12 +124,12 @@ mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
* Returns the decrypted data length.
*/
int
mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
MHD_gtls_decrypt (MHD_gtls_session_t session, opaque * ciphertext,
size_t ciphertext_size, uint8_t * data,
size_t max_data_size, content_type_t type)
{
gnutls_datum_t gtxt;
gnutls_datum_t gcipher;
MHD_gnutls_datum_t gtxt;
MHD_gnutls_datum_t gcipher;
int ret;
if (ciphertext_size == 0)
@@ -139,7 +139,7 @@ mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
gcipher.data = ciphertext;
ret =
mhd_gtls_ciphertext2compressed (session, data, max_data_size,
MHD_gtls_ciphertext2compressed (session, data, max_data_size,
gcipher, type);
if (ret < 0)
{
@@ -153,14 +153,14 @@ mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
}
else
{
gnutls_datum_t gcomp;
MHD_gnutls_datum_t gcomp;
/* compression has this malloc overhead.
*/
gcomp.data = data;
gcomp.size = ret;
ret = _gnutls_m_compressed2plaintext (session, &gtxt, &gcomp);
ret = MHD__gnutls_m_compressed2plaintext (session, &gtxt, &gcomp);
if (ret < 0)
{
return ret;
@@ -168,8 +168,8 @@ mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
if (gtxt.size > MAX_RECORD_RECV_SIZE)
{
gnutls_assert ();
_gnutls_free_datum (&gtxt);
MHD_gnutls_assert ();
MHD__gnutls_free_datum (&gtxt);
/* This shouldn't have happen and
* is a TLS fatal error.
*/
@@ -179,15 +179,15 @@ mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
/* This check is not really needed */
if (max_data_size < MAX_RECORD_RECV_SIZE)
{
gnutls_assert ();
_gnutls_free_datum (&gtxt);
MHD_gnutls_assert ();
MHD__gnutls_free_datum (&gtxt);
return GNUTLS_E_INTERNAL_ERROR;
}
memcpy (data, gtxt.data, gtxt.size);
ret = gtxt.size;
_gnutls_free_datum (&gtxt);
MHD__gnutls_free_datum (&gtxt);
}
return ret;
@@ -204,11 +204,11 @@ mac_init (enum MHD_GNUTLS_HashAlgorithm mac, opaque * secret, int secret_size,
if (ver == MHD_GNUTLS_PROTOCOL_SSL3)
{ /* SSL 3.0 */
td = mhd_gnutls_mac_init_ssl3 (mac, secret, secret_size);
td = MHD_gnutls_mac_init_ssl3 (mac, secret, secret_size);
}
else
{ /* TLS 1.x */
td = mhd_gtls_hmac_init (mac, secret, secret_size);
td = MHD_gtls_MHD_hmac_init (mac, secret, secret_size);
}
return td;
@@ -219,16 +219,16 @@ mac_deinit (mac_hd_t td, opaque * res, int ver)
{
if (ver == MHD_GNUTLS_PROTOCOL_SSL3)
{ /* SSL 3.0 */
mhd_gnutls_mac_deinit_ssl3 (td, res);
MHD_gnutls_mac_deinit_ssl3 (td, res);
}
else
{
mhd_gnutls_hmac_deinit (td, res);
MHD_gnutls_MHD_hmac_deinit (td, res);
}
}
inline static int
calc_enc_length (mhd_gtls_session_t session, int data_size,
calc_enc_length (MHD_gtls_session_t session, int data_size,
int hash_size, uint8_t * pad, int random_pad,
cipher_type_t block_algo, uint16_t blocksize)
{
@@ -244,9 +244,9 @@ calc_enc_length (mhd_gtls_session_t session, int data_size,
break;
case CIPHER_BLOCK:
if (gc_nonce (&rnd, 1) != GC_OK)
if (MHD_gc_nonce (&rnd, 1) != GC_OK)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RANDOM_FAILED;
}
@@ -276,7 +276,7 @@ calc_enc_length (mhd_gtls_session_t session, int data_size,
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -289,9 +289,9 @@ calc_enc_length (mhd_gtls_session_t session, int data_size,
* return the actual encrypted data length.
*/
int
mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
MHD_gtls_compressed2ciphertext (MHD_gtls_session_t session,
opaque * cipher_data, int cipher_size,
gnutls_datum_t compressed,
MHD_gnutls_datum_t compressed,
content_type_t _type, int random_pad)
{
uint8_t MAC[MAX_HASH_SIZE];
@@ -302,21 +302,21 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
uint8_t type = _type;
uint8_t major, minor;
int hash_size =
mhd_gnutls_hash_get_algo_len (session->security_parameters.
MHD_gnutls_hash_get_algo_len (session->security_parameters.
write_mac_algorithm);
enum MHD_GNUTLS_Protocol ver;
int blocksize =
mhd_gtls_cipher_get_block_size (session->security_parameters.
MHD_gtls_cipher_get_block_size (session->security_parameters.
write_bulk_cipher_algorithm);
cipher_type_t block_algo =
mhd_gtls_cipher_is_block (session->security_parameters.
MHD_gtls_cipher_is_block (session->security_parameters.
write_bulk_cipher_algorithm);
opaque *data_ptr;
ver = MHD_gnutls_protocol_get_version (session);
minor = mhd_gtls_version_get_minor (ver);
major = mhd_gtls_version_get_major (ver);
ver = MHD__gnutls_protocol_get_version (session);
minor = MHD_gtls_version_get_minor (ver);
major = MHD_gtls_version_get_major (ver);
/* Initialize MAC */
@@ -328,26 +328,26 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
&& session->security_parameters.write_mac_algorithm !=
MHD_GNUTLS_MAC_NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
c_length = mhd_gtls_conv_uint16 (compressed.size);
c_length = MHD_gtls_conv_uint16 (compressed.size);
if (td != GNUTLS_MAC_FAILED)
{ /* actually when the algorithm in not the NULL one */
mhd_gnutls_hash (td,
MHD_gnutls_hash (td,
UINT64DATA (session->connection_state.
write_sequence_number), 8);
mhd_gnutls_hash (td, &type, 1);
MHD_gnutls_hash (td, &type, 1);
if (ver >= MHD_GNUTLS_PROTOCOL_TLS1_0)
{ /* TLS 1.0 or higher */
mhd_gnutls_hash (td, &major, 1);
mhd_gnutls_hash (td, &minor, 1);
MHD_gnutls_hash (td, &major, 1);
MHD_gnutls_hash (td, &minor, 1);
}
mhd_gnutls_hash (td, &c_length, 2);
mhd_gnutls_hash (td, compressed.data, compressed.size);
MHD_gnutls_hash (td, &c_length, 2);
MHD_gnutls_hash (td, compressed.data, compressed.size);
mac_deinit (td, MAC, ver);
}
@@ -359,7 +359,7 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
random_pad, block_algo, blocksize);
if (length < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return length;
}
@@ -367,7 +367,7 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
*/
if (cipher_size < length)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -377,9 +377,9 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
{
/* copy the random IV.
*/
if (gc_nonce (data_ptr, blocksize) != GC_OK)
if (MHD_gc_nonce (data_ptr, blocksize) != GC_OK)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RANDOM_FAILED;
}
data_ptr += blocksize;
@@ -402,11 +402,11 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
/* Actual encryption (inplace).
*/
ret =
mhd_gtls_cipher_encrypt (session->connection_state.write_cipher_state,
MHD_gtls_cipher_encrypt (session->connection_state.write_cipher_state,
cipher_data, length);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -417,10 +417,10 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
* Returns the actual compressed packet size.
*/
int
mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
opaque * compress_data,
int compress_size,
gnutls_datum_t ciphertext, uint8_t type)
MHD_gnutls_datum_t ciphertext, uint8_t type)
{
uint8_t MAC[MAX_HASH_SIZE];
uint16_t c_length;
@@ -432,15 +432,15 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
uint8_t major, minor;
enum MHD_GNUTLS_Protocol ver;
int hash_size =
mhd_gnutls_hash_get_algo_len (session->security_parameters.
MHD_gnutls_hash_get_algo_len (session->security_parameters.
read_mac_algorithm);
ver = MHD_gnutls_protocol_get_version (session);
minor = mhd_gtls_version_get_minor (ver);
major = mhd_gtls_version_get_major (ver);
ver = MHD__gnutls_protocol_get_version (session);
minor = MHD_gtls_version_get_minor (ver);
major = MHD_gtls_version_get_major (ver);
blocksize =
mhd_gtls_cipher_get_block_size (session->security_parameters.
MHD_gtls_cipher_get_block_size (session->security_parameters.
read_bulk_cipher_algorithm);
/* initialize MAC
@@ -453,23 +453,23 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
&& session->security_parameters.read_mac_algorithm !=
MHD_GNUTLS_MAC_NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
/* actual decryption (inplace)
*/
switch (mhd_gtls_cipher_is_block
switch (MHD_gtls_cipher_is_block
(session->security_parameters.read_bulk_cipher_algorithm))
{
case CIPHER_STREAM:
if ((ret =
mhd_gtls_cipher_decrypt (session->connection_state.
MHD_gtls_cipher_decrypt (session->connection_state.
read_cipher_state, ciphertext.data,
ciphertext.size)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -479,16 +479,16 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
case CIPHER_BLOCK:
if ((ciphertext.size < blocksize) || (ciphertext.size % blocksize != 0))
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_DECRYPTION_FAILED;
}
if ((ret =
mhd_gtls_cipher_decrypt (session->connection_state.
MHD_gtls_cipher_decrypt (session->connection_state.
read_cipher_state, ciphertext.data,
ciphertext.size)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -501,7 +501,7 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
if (ciphertext.size == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_DECRYPTION_FAILED;
}
}
@@ -512,7 +512,7 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
if (pad > ciphertext.size - hash_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* We do not fail here. We check below for the
* the pad_failed. If zero means success.
*/
@@ -530,33 +530,33 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
}
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (length < 0)
length = 0;
c_length = mhd_gtls_conv_uint16 ((uint16_t) length);
c_length = MHD_gtls_conv_uint16 ((uint16_t) length);
/* Pass the type, version, length and compressed through
* MAC.
*/
if (td != GNUTLS_MAC_FAILED)
{
mhd_gnutls_hash (td,
MHD_gnutls_hash (td,
UINT64DATA (session->connection_state.
read_sequence_number), 8);
mhd_gnutls_hash (td, &type, 1);
MHD_gnutls_hash (td, &type, 1);
if (ver >= MHD_GNUTLS_PROTOCOL_TLS1_0)
{ /* TLS 1.x */
mhd_gnutls_hash (td, &major, 1);
mhd_gnutls_hash (td, &minor, 1);
MHD_gnutls_hash (td, &major, 1);
MHD_gnutls_hash (td, &minor, 1);
}
mhd_gnutls_hash (td, &c_length, 2);
MHD_gnutls_hash (td, &c_length, 2);
if (length > 0)
mhd_gnutls_hash (td, ciphertext.data, length);
MHD_gnutls_hash (td, ciphertext.data, length);
mac_deinit (td, MAC, ver);
}
@@ -571,7 +571,7 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
*/
if (memcmp (MAC, &ciphertext.data[length], hash_size) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_DECRYPTION_FAILED;
}
@@ -579,7 +579,7 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
*/
if (compress_size < length)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_DECOMPRESSION_FAILED;
}
memcpy (compress_data, ciphertext.data, length);
src/daemon/https/tls/gnutls_cipher.h
+6 -6
View File
@@ -22,19 +22,19 @@
*
*/
int mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
int MHD_gtls_encrypt (MHD_gtls_session_t session, const opaque * headers,
size_t headers_size, const opaque * data,
size_t data_size, opaque * ciphertext,
size_t ciphertext_size, content_type_t type,
int random_pad);
int mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
int MHD_gtls_decrypt (MHD_gtls_session_t session, opaque * ciphertext,
size_t ciphertext_size, uint8_t * data,
size_t data_size, content_type_t type);
int mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
int MHD_gtls_compressed2ciphertext (MHD_gtls_session_t session,
opaque * cipher_data, int cipher_size,
gnutls_datum_t compressed,
MHD_gnutls_datum_t compressed,
content_type_t _type, int random_pad);
int mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
int MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
opaque * compress_data, int compress_size,
gnutls_datum_t ciphertext, uint8_t type);
MHD_gnutls_datum_t ciphertext, uint8_t type);
src/daemon/https/tls/gnutls_cipher_int.c
+24 -24
View File
@@ -28,8 +28,8 @@
#include <gnutls_datum.h>
cipher_hd_t
mhd_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
const gnutls_datum_t * key, const gnutls_datum_t * iv)
MHD_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
const MHD_gnutls_datum_t * key, const MHD_gnutls_datum_t * iv)
{
cipher_hd_t ret = NULL;
int err = GC_INVALID_CIPHER; /* doesn't matter */
@@ -37,40 +37,40 @@ mhd_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
switch (cipher)
{
case MHD_GNUTLS_CIPHER_AES_128_CBC:
err = gc_cipher_open (GC_AES128, GC_CBC, &ret);
err = MHD_gc_cipher_open (GC_AES128, GC_CBC, &ret);
break;
case MHD_GNUTLS_CIPHER_AES_256_CBC:
err = gc_cipher_open (GC_AES256, GC_CBC, &ret);
err = MHD_gc_cipher_open (GC_AES256, GC_CBC, &ret);
break;
case MHD_GNUTLS_CIPHER_3DES_CBC:
err = gc_cipher_open (GC_3DES, GC_CBC, &ret);
err = MHD_gc_cipher_open (GC_3DES, GC_CBC, &ret);
break;
case MHD_GNUTLS_CIPHER_DES_CBC:
err = gc_cipher_open (GC_DES, GC_CBC, &ret);
err = MHD_gc_cipher_open (GC_DES, GC_CBC, &ret);
break;
case MHD_GNUTLS_CIPHER_ARCFOUR_128:
err = gc_cipher_open (GC_ARCFOUR128, GC_STREAM, &ret);
err = MHD_gc_cipher_open (GC_ARCFOUR128, GC_STREAM, &ret);
break;
case MHD_GNUTLS_CIPHER_ARCFOUR_40:
err = gc_cipher_open (GC_ARCFOUR40, GC_STREAM, &ret);
err = MHD_gc_cipher_open (GC_ARCFOUR40, GC_STREAM, &ret);
break;
case MHD_GNUTLS_CIPHER_RC2_40_CBC:
err = gc_cipher_open (GC_ARCTWO40, GC_CBC, &ret);
err = MHD_gc_cipher_open (GC_ARCTWO40, GC_CBC, &ret);
break;
#ifdef ENABLE_CAMELLIA
case MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC:
err = gc_cipher_open (GC_CAMELLIA128, GC_CBC, &ret);
err = MHD_gc_cipher_open (GC_CAMELLIA128, GC_CBC, &ret);
break;
case MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC:
err = gc_cipher_open (GC_CAMELLIA256, GC_CBC, &ret);
err = MHD_gc_cipher_open (GC_CAMELLIA256, GC_CBC, &ret);
break;
#endif
@@ -80,28 +80,28 @@ mhd_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
if (err == 0)
{
gc_cipher_setkey (ret, key->size, key->data);
MHD_gc_cipher_setkey (ret, key->size, key->data);
if (iv->data != NULL && iv->size > 0)
gc_cipher_setiv (ret, iv->size, iv->data);
MHD_gc_cipher_setiv (ret, iv->size, iv->data);
}
else if (cipher != MHD_GNUTLS_CIPHER_NULL)
{
gnutls_assert ();
_gnutls_x509_log ("Crypto cipher[%d] error: %d\n", cipher, err);
/* FIXME: gc_strerror */
MHD_gnutls_assert ();
MHD__gnutls_x509_log ("Crypto cipher[%d] error: %d\n", cipher, err);
/* FIXME: MHD_gc_strerror */
}
return ret;
}
int
mhd_gtls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
MHD_gtls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
{
if (handle != GNUTLS_CIPHER_FAILED)
{
if (gc_cipher_encrypt_inline (handle, textlen, text) != 0)
if (MHD_gc_cipher_encrypt_inline (handle, textlen, text) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
}
@@ -109,14 +109,14 @@ mhd_gtls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
}
int
mhd_gtls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
MHD_gtls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
int ciphertextlen)
{
if (handle != GNUTLS_CIPHER_FAILED)
{
if (gc_cipher_decrypt_inline (handle, ciphertextlen, ciphertext) != 0)
if (MHD_gc_cipher_decrypt_inline (handle, ciphertextlen, ciphertext) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
}
@@ -124,10 +124,10 @@ mhd_gtls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
}
void
mhd_gnutls_cipher_deinit (cipher_hd_t handle)
MHD_gnutls_cipher_deinit (cipher_hd_t handle)
{
if (handle != GNUTLS_CIPHER_FAILED)
{
gc_cipher_close (handle);
MHD_gc_cipher_close (handle);
}
}
src/daemon/https/tls/gnutls_cipher_int.h
+8 -8
View File
@@ -25,19 +25,19 @@
#ifndef GNUTLS_CIPHER_INT
# define GNUTLS_CIPHER_INT
#define cipher_hd_t gc_cipher_handle
#define cipher_hd_t MHD_gc_cipher_handle
#define GNUTLS_CIPHER_FAILED NULL
// TODO gc_cipher_handle -> void * x3
void *mhd_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
const gnutls_datum_t * key,
const gnutls_datum_t * iv);
// TODO MHD_gc_cipher_handle -> void * x3
void *MHD_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
const MHD_gnutls_datum_t * key,
const MHD_gnutls_datum_t * iv);
int mhd_gtls_cipher_encrypt (void *handle, void *text, int textlen);
int MHD_gtls_cipher_encrypt (void *handle, void *text, int textlen);
int mhd_gtls_cipher_decrypt (void *handle,
int MHD_gtls_cipher_decrypt (void *handle,
void *ciphertext, int ciphertextlen);
void mhd_gnutls_cipher_deinit (void *handle);
void MHD_gnutls_cipher_deinit (void *handle);
#endif /* GNUTLS_CIPHER_INT */
src/daemon/https/tls/gnutls_compress.c
+10 -10
View File
@@ -34,20 +34,20 @@
/* These functions allocate the return value internally
*/
int
_gnutls_m_plaintext2compressed (mhd_gtls_session_t session,
gnutls_datum_t * compressed,
const gnutls_datum_t * plaintext)
MHD__gnutls_m_plaintext2compressed (MHD_gtls_session_t session,
MHD_gnutls_datum_t * compressed,
const MHD_gnutls_datum_t * plaintext)
{
int size;
opaque *data;
size =
mhd_gtls_compress (session->connection_state.write_compression_state,
MHD_gtls_compress (session->connection_state.write_compression_state,
plaintext->data, plaintext->size, &data,
MAX_RECORD_SEND_SIZE + EXTRA_COMP_SIZE);
if (size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_COMPRESSION_FAILED;
}
compressed->data = data;
@@ -57,20 +57,20 @@ _gnutls_m_plaintext2compressed (mhd_gtls_session_t session,
}
int
_gnutls_m_compressed2plaintext (mhd_gtls_session_t session,
gnutls_datum_t * plain,
const gnutls_datum_t * compressed)
MHD__gnutls_m_compressed2plaintext (MHD_gtls_session_t session,
MHD_gnutls_datum_t * plain,
const MHD_gnutls_datum_t * compressed)
{
int size;
opaque *data;
size =
mhd_gtls_decompress (session->connection_state.read_compression_state,
MHD_gtls_decompress (session->connection_state.read_compression_state,
compressed->data, compressed->size, &data,
MAX_RECORD_RECV_SIZE);
if (size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_DECOMPRESSION_FAILED;
}
plain->data = data;
src/daemon/https/tls/gnutls_compress.h
+6 -6
View File
@@ -22,9 +22,9 @@
*
*/
int _gnutls_m_plaintext2compressed (mhd_gtls_session_t session,
gnutls_datum_t * compressed,
const gnutls_datum_t * plaintext);
int _gnutls_m_compressed2plaintext (mhd_gtls_session_t session,
gnutls_datum_t * plain,
const gnutls_datum_t * compressed);
int MHD__gnutls_m_plaintext2compressed (MHD_gtls_session_t session,
MHD_gnutls_datum_t * compressed,
const MHD_gnutls_datum_t * plaintext);
int MHD__gnutls_m_compressed2plaintext (MHD_gtls_session_t session,
MHD_gnutls_datum_t * plain,
const MHD_gnutls_datum_t * compressed);
src/daemon/https/tls/gnutls_compress_int.c
+33 -33
View File
@@ -31,14 +31,14 @@
* decompress.
*/
comp_hd_t
mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
MHD_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
{
comp_hd_t ret;
ret = gnutls_malloc (sizeof (struct comp_hd_t_STRUCT));
ret = MHD_gnutls_malloc (sizeof (struct comp_hd_t_STRUCT));
if (ret == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return NULL;
}
@@ -54,14 +54,14 @@ mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
int comp_level;
z_stream *zhandle;
window_bits = mhd_gtls_compression_get_wbits (method);
mem_level = mhd_gtls_compression_get_mem_level (method);
comp_level = mhd_gtls_compression_get_comp_level (method);
window_bits = MHD_gtls_compression_get_wbits (method);
mem_level = MHD_gtls_compression_get_mem_level (method);
comp_level = MHD_gtls_compression_get_comp_level (method);
ret->handle = gnutls_malloc (sizeof (z_stream));
ret->handle = MHD_gnutls_malloc (sizeof (z_stream));
if (ret->handle == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
goto cleanup_ret;
}
@@ -81,8 +81,8 @@ mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
}
if (err != Z_OK)
{
gnutls_assert ();
gnutls_free (ret->handle);
MHD_gnutls_assert ();
MHD_gnutls_free (ret->handle);
goto cleanup_ret;
}
break;
@@ -94,7 +94,7 @@ mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
return ret;
cleanup_ret:
gnutls_free (ret);
MHD_gnutls_free (ret);
return NULL;
}
@@ -102,7 +102,7 @@ cleanup_ret:
* decompress.
*/
void
mhd_gtls_comp_deinit (comp_hd_t handle, int d)
MHD_gtls_comp_deinit (comp_hd_t handle, int d)
{
if (handle != NULL)
{
@@ -119,8 +119,8 @@ mhd_gtls_comp_deinit (comp_hd_t handle, int d)
default:
break;
}
gnutls_free (handle->handle);
gnutls_free (handle);
MHD_gnutls_free (handle->handle);
MHD_gnutls_free (handle);
}
}
@@ -129,7 +129,7 @@ mhd_gtls_comp_deinit (comp_hd_t handle, int d)
*/
int
mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
MHD_gtls_compress (comp_hd_t handle, const opaque * plain,
size_t plain_size, opaque ** compressed,
size_t max_comp_size)
{
@@ -139,7 +139,7 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
*/
if (handle == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -153,10 +153,10 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
z_stream *zhandle;
size = (plain_size + plain_size) + 10;
*compressed = gnutls_malloc (size);
*compressed = MHD_gnutls_malloc (size);
if (*compressed == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -171,8 +171,8 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
if (err != Z_OK || zhandle->avail_in != 0)
{
gnutls_assert ();
gnutls_free (*compressed);
MHD_gnutls_assert ();
MHD_gnutls_free (*compressed);
*compressed = NULL;
return GNUTLS_E_COMPRESSION_FAILED;
}
@@ -182,18 +182,18 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
}
#endif
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
} /* switch */
#ifdef COMPRESSION_DEBUG
_gnutls_debug_log ("Compression ratio: %f\n",
MHD__gnutls_debug_log ("Compression ratio: %f\n",
(float) ((float) compressed_size / (float) plain_size));
#endif
if ((size_t) compressed_size > max_comp_size)
{
gnutls_free (*compressed);
MHD_gnutls_free (*compressed);
*compressed = NULL;
return GNUTLS_E_COMPRESSION_FAILED;
}
@@ -204,7 +204,7 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
int
mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
MHD_gtls_decompress (comp_hd_t handle, opaque * compressed,
size_t compressed_size, opaque ** plain,
size_t max_record_size)
{
@@ -212,7 +212,7 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
if (compressed_size > max_record_size + EXTRA_COMP_SIZE)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_DECOMPRESSION_FAILED;
}
@@ -221,7 +221,7 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
if (handle == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -247,10 +247,10 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
do
{
out_size += 512;
*plain = mhd_gtls_realloc_fast (*plain, out_size);
*plain = MHD_gtls_realloc_fast (*plain, out_size);
if (*plain == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -268,8 +268,8 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
if (err != Z_OK)
{
gnutls_assert ();
gnutls_free (*plain);
MHD_gnutls_assert ();
MHD_gnutls_free (*plain);
*plain = NULL;
return GNUTLS_E_DECOMPRESSION_FAILED;
}
@@ -279,14 +279,14 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
}
#endif
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
} /* switch */
if ((size_t) plain_size > max_record_size)
{
gnutls_assert ();
gnutls_free (*plain);
MHD_gnutls_assert ();
MHD_gnutls_free (*plain);
*plain = NULL;
return GNUTLS_E_DECOMPRESSION_FAILED;
}
src/daemon/https/tls/gnutls_compress_int.h
+4 -4
View File
@@ -37,13 +37,13 @@ typedef struct comp_hd_t_STRUCT
enum MHD_GNUTLS_CompressionMethod algo;
} *comp_hd_t;
comp_hd_t mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod, int d);
void mhd_gtls_comp_deinit (comp_hd_t handle, int d);
comp_hd_t MHD_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod, int d);
void MHD_gtls_comp_deinit (comp_hd_t handle, int d);
int mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
int MHD_gtls_decompress (comp_hd_t handle, opaque * compressed,
size_t compressed_size, opaque ** plain,
size_t max_record_size);
int mhd_gtls_compress (comp_hd_t, const opaque * plain, size_t plain_size,
int MHD_gtls_compress (comp_hd_t, const opaque * plain, size_t plain_size,
opaque ** compressed, size_t max_comp_size);
#endif
src/daemon/https/tls/gnutls_constate.c
+187 -187
View File
@@ -56,7 +56,7 @@ static const int servwrite_length = sizeof (servwrite) - 1;
* (session->cipher_specs)
*/
int
_gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
int key_size, int export_flag)
{
@@ -82,10 +82,10 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
if (export_flag == 0)
block_size += 2 * IV_size;
key_block = gnutls_secure_malloc (block_size);
key_block = MHD_gnutls_secure_malloc (block_size);
if (key_block == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -100,46 +100,46 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
{ /* SSL 3 */
ret =
mhd_gnutls_ssl3_generate_random
MHD_gnutls_ssl3_generate_random
(session->security_parameters.master_secret, TLS_MASTER_SIZE, rnd,
2 * TLS_RANDOM_SIZE, block_size, key_block);
}
else
{ /* TLS 1.0 */
ret =
mhd_gtls_PRF (session, session->security_parameters.master_secret,
MHD_gtls_PRF (session, session->security_parameters.master_secret,
TLS_MASTER_SIZE, keyexp, keyexp_length,
rnd, 2 * TLS_RANDOM_SIZE, block_size, key_block);
}
if (ret < 0)
{
gnutls_assert ();
gnutls_free (key_block);
MHD_gnutls_assert ();
MHD_gnutls_free (key_block);
return ret;
}
_gnutls_hard_log ("INT: KEY BLOCK[%d]: %s\n", block_size,
mhd_gtls_bin2hex (key_block, block_size, buf,
MHD__gnutls_hard_log ("INT: KEY BLOCK[%d]: %s\n", block_size,
MHD_gtls_bin2hex (key_block, block_size, buf,
sizeof (buf)));
pos = 0;
if (hash_size > 0)
{
if (_gnutls_sset_datum
if (MHD__gnutls_sset_datum
(&session->cipher_specs.client_write_mac_secret,
&key_block[pos], hash_size) < 0)
{
gnutls_free (key_block);
MHD_gnutls_free (key_block);
return GNUTLS_E_MEMORY_ERROR;
}
pos += hash_size;
if (_gnutls_sset_datum
if (MHD__gnutls_sset_datum
(&session->cipher_specs.server_write_mac_secret,
&key_block[pos], hash_size) < 0)
{
gnutls_free (key_block);
MHD_gnutls_free (key_block);
return GNUTLS_E_MEMORY_ERROR;
}
pos += hash_size;
@@ -168,20 +168,20 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
{ /* export */
free_keys = 1;
client_write_key = gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
client_write_key = MHD_gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
if (client_write_key == NULL)
{
gnutls_assert ();
gnutls_free (key_block);
MHD_gnutls_assert ();
MHD_gnutls_free (key_block);
return GNUTLS_E_MEMORY_ERROR;
}
server_write_key = gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
server_write_key = MHD_gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
if (server_write_key == NULL)
{
gnutls_assert ();
gnutls_free (key_block);
gnutls_free (client_write_key);
MHD_gnutls_assert ();
MHD_gnutls_free (key_block);
MHD_gnutls_free (client_write_key);
return GNUTLS_E_MEMORY_ERROR;
}
@@ -190,7 +190,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
{ /* SSL 3 */
ret =
mhd_gnutls_ssl3_hash_md5 (&key_block[pos],
MHD_gnutls_ssl3_hash_md5 (&key_block[pos],
key_size, rrnd,
2 * TLS_RANDOM_SIZE,
EXPORT_FINAL_KEY_SIZE,
@@ -200,7 +200,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
else
{ /* TLS 1.0 */
ret =
mhd_gtls_PRF (session, &key_block[pos], key_size,
MHD_gtls_PRF (session, &key_block[pos], key_size,
cliwrite, cliwrite_length,
rrnd,
2 * TLS_RANDOM_SIZE,
@@ -209,10 +209,10 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
if (ret < 0)
{
gnutls_assert ();
gnutls_free (key_block);
gnutls_free (server_write_key);
gnutls_free (client_write_key);
MHD_gnutls_assert ();
MHD_gnutls_free (key_block);
MHD_gnutls_free (server_write_key);
MHD_gnutls_free (client_write_key);
return ret;
}
@@ -222,7 +222,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
{ /* SSL 3 */
ret =
mhd_gnutls_ssl3_hash_md5 (&key_block[pos], key_size,
MHD_gnutls_ssl3_hash_md5 (&key_block[pos], key_size,
rnd, 2 * TLS_RANDOM_SIZE,
EXPORT_FINAL_KEY_SIZE,
server_write_key);
@@ -230,7 +230,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
else
{ /* TLS 1.0 */
ret =
mhd_gtls_PRF (session, &key_block[pos], key_size,
MHD_gtls_PRF (session, &key_block[pos], key_size,
servwrite, servwrite_length,
rrnd, 2 * TLS_RANDOM_SIZE,
EXPORT_FINAL_KEY_SIZE, server_write_key);
@@ -238,10 +238,10 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
if (ret < 0)
{
gnutls_assert ();
gnutls_free (key_block);
gnutls_free (server_write_key);
gnutls_free (client_write_key);
MHD_gnutls_assert ();
MHD_gnutls_free (key_block);
MHD_gnutls_free (server_write_key);
MHD_gnutls_free (client_write_key);
return ret;
}
@@ -249,41 +249,41 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
pos += key_size;
}
if (_gnutls_sset_datum
if (MHD__gnutls_sset_datum
(&session->cipher_specs.client_write_key,
client_write_key, client_write_key_size) < 0)
{
gnutls_free (key_block);
gnutls_free (server_write_key);
gnutls_free (client_write_key);
MHD_gnutls_free (key_block);
MHD_gnutls_free (server_write_key);
MHD_gnutls_free (client_write_key);
return GNUTLS_E_MEMORY_ERROR;
}
_gnutls_hard_log ("INT: CLIENT WRITE KEY [%d]: %s\n",
MHD__gnutls_hard_log ("INT: CLIENT WRITE KEY [%d]: %s\n",
client_write_key_size,
mhd_gtls_bin2hex (client_write_key,
MHD_gtls_bin2hex (client_write_key,
client_write_key_size, buf,
sizeof (buf)));
if (_gnutls_sset_datum
if (MHD__gnutls_sset_datum
(&session->cipher_specs.server_write_key,
server_write_key, server_write_key_size) < 0)
{
gnutls_free (key_block);
gnutls_free (server_write_key);
gnutls_free (client_write_key);
MHD_gnutls_free (key_block);
MHD_gnutls_free (server_write_key);
MHD_gnutls_free (client_write_key);
return GNUTLS_E_MEMORY_ERROR;
}
_gnutls_hard_log ("INT: SERVER WRITE KEY [%d]: %s\n",
MHD__gnutls_hard_log ("INT: SERVER WRITE KEY [%d]: %s\n",
server_write_key_size,
mhd_gtls_bin2hex (server_write_key,
MHD_gtls_bin2hex (server_write_key,
server_write_key_size, buf,
sizeof (buf)));
if (free_keys != 0)
{
gnutls_free (server_write_key);
gnutls_free (client_write_key);
MHD_gnutls_free (server_write_key);
MHD_gnutls_free (client_write_key);
}
}
@@ -292,20 +292,20 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
*/
if (IV_size > 0 && export_flag == 0)
{
if (_gnutls_sset_datum
if (MHD__gnutls_sset_datum
(&session->cipher_specs.client_write_IV, &key_block[pos],
IV_size) < 0)
{
gnutls_free (key_block);
MHD_gnutls_free (key_block);
return GNUTLS_E_MEMORY_ERROR;
}
pos += IV_size;
if (_gnutls_sset_datum
if (MHD__gnutls_sset_datum
(&session->cipher_specs.server_write_IV, &key_block[pos],
IV_size) < 0)
{
gnutls_free (key_block);
MHD_gnutls_free (key_block);
return GNUTLS_E_MEMORY_ERROR;
}
pos += IV_size;
@@ -313,69 +313,69 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
}
else if (IV_size > 0 && export_flag != 0)
{
opaque *iv_block = gnutls_alloca (IV_size * 2);
opaque *iv_block = MHD_gnutls_alloca (IV_size * 2);
if (iv_block == NULL)
{
gnutls_assert ();
gnutls_free (key_block);
MHD_gnutls_assert ();
MHD_gnutls_free (key_block);
return GNUTLS_E_MEMORY_ERROR;
}
if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
{ /* SSL 3 */
ret = mhd_gnutls_ssl3_hash_md5 ("", 0,
ret = MHD_gnutls_ssl3_hash_md5 ("", 0,
rrnd, TLS_RANDOM_SIZE * 2,
IV_size, iv_block);
if (ret < 0)
{
gnutls_assert ();
gnutls_free (key_block);
gnutls_afree (iv_block);
MHD_gnutls_assert ();
MHD_gnutls_free (key_block);
MHD_gnutls_afree (iv_block);
return ret;
}
ret = mhd_gnutls_ssl3_hash_md5 ("", 0, rnd,
ret = MHD_gnutls_ssl3_hash_md5 ("", 0, rnd,
TLS_RANDOM_SIZE * 2,
IV_size, &iv_block[IV_size]);
}
else
{ /* TLS 1.0 */
ret = mhd_gtls_PRF (session, "", 0,
ret = MHD_gtls_PRF (session, "", 0,
ivblock, ivblock_length, rrnd,
2 * TLS_RANDOM_SIZE, IV_size * 2, iv_block);
}
if (ret < 0)
{
gnutls_assert ();
gnutls_afree (iv_block);
gnutls_free (key_block);
MHD_gnutls_assert ();
MHD_gnutls_afree (iv_block);
MHD_gnutls_free (key_block);
return ret;
}
if (_gnutls_sset_datum
if (MHD__gnutls_sset_datum
(&session->cipher_specs.client_write_IV, iv_block, IV_size) < 0)
{
gnutls_afree (iv_block);
gnutls_free (key_block);
MHD_gnutls_afree (iv_block);
MHD_gnutls_free (key_block);
return GNUTLS_E_MEMORY_ERROR;
}
if (_gnutls_sset_datum
if (MHD__gnutls_sset_datum
(&session->cipher_specs.server_write_IV,
&iv_block[IV_size], IV_size) < 0)
{
gnutls_afree (iv_block);
gnutls_free (key_block);
MHD_gnutls_afree (iv_block);
MHD_gnutls_free (key_block);
return GNUTLS_E_MEMORY_ERROR;
}
gnutls_afree (iv_block);
MHD_gnutls_afree (iv_block);
}
gnutls_free (key_block);
MHD_gnutls_free (key_block);
session->cipher_specs.generated_keys = 1;
@@ -383,7 +383,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
}
int
_gnutls_set_read_keys (mhd_gtls_session_t session)
MHD__gnutls_set_read_keys (MHD_gtls_session_t session)
{
int hash_size;
int IV_size;
@@ -394,17 +394,17 @@ _gnutls_set_read_keys (mhd_gtls_session_t session)
mac_algo = session->security_parameters.read_mac_algorithm;
algo = session->security_parameters.read_bulk_cipher_algorithm;
hash_size = mhd_gnutls_hash_get_algo_len (mac_algo);
IV_size = mhd_gtls_cipher_get_iv_size (algo);
key_size = MHD_gnutls_cipher_get_key_size (algo);
export_flag = mhd_gtls_cipher_get_export_flag (algo);
hash_size = MHD_gnutls_hash_get_algo_len (mac_algo);
IV_size = MHD_gtls_cipher_get_iv_size (algo);
key_size = MHD__gnutls_cipher_get_key_size (algo);
export_flag = MHD_gtls_cipher_get_export_flag (algo);
return _gnutls_set_keys (session, hash_size, IV_size, key_size,
return MHD__gnutls_set_keys (session, hash_size, IV_size, key_size,
export_flag);
}
int
_gnutls_set_write_keys (mhd_gtls_session_t session)
MHD__gnutls_set_write_keys (MHD_gtls_session_t session)
{
int hash_size;
int IV_size;
@@ -415,12 +415,12 @@ _gnutls_set_write_keys (mhd_gtls_session_t session)
mac_algo = session->security_parameters.write_mac_algorithm;
algo = session->security_parameters.write_bulk_cipher_algorithm;
hash_size = mhd_gnutls_hash_get_algo_len (mac_algo);
IV_size = mhd_gtls_cipher_get_iv_size (algo);
key_size = MHD_gnutls_cipher_get_key_size (algo);
export_flag = mhd_gtls_cipher_get_export_flag (algo);
hash_size = MHD_gnutls_hash_get_algo_len (mac_algo);
IV_size = MHD_gtls_cipher_get_iv_size (algo);
key_size = MHD__gnutls_cipher_get_key_size (algo);
export_flag = MHD_gtls_cipher_get_export_flag (algo);
return _gnutls_set_keys (session, hash_size, IV_size, key_size,
return MHD__gnutls_set_keys (session, hash_size, IV_size, key_size,
export_flag);
}
@@ -437,12 +437,12 @@ _gnutls_set_write_keys (mhd_gtls_session_t session)
dst->max_record_recv_size = src->max_record_recv_size; \
dst->max_record_send_size = src->max_record_send_size; \
dst->version = src->version; \
memcpy( &dst->extensions, &src->extensions, sizeof(mhd_gtls_ext_st)); \
memcpy( &dst->extensions, &src->extensions, sizeof(MHD_gtls_ext_st)); \
memcpy( &dst->inner_secret, &src->inner_secret, TLS_MASTER_SIZE);
static void
_gnutls_cpy_read_security_parameters (mhd_gtls_security_param_st *
dst, mhd_gtls_security_param_st * src)
MHD__gnutls_cpy_read_security_parameters (MHD_gtls_security_param_st *
dst, MHD_gtls_security_param_st * src)
{
CPY_COMMON;
@@ -452,8 +452,8 @@ _gnutls_cpy_read_security_parameters (mhd_gtls_security_param_st *
}
static void
_gnutls_cpy_write_security_parameters (mhd_gtls_security_param_st *
dst, mhd_gtls_security_param_st * src)
MHD__gnutls_cpy_write_security_parameters (MHD_gtls_security_param_st *
dst, MHD_gtls_security_param_st * src)
{
CPY_COMMON;
@@ -469,15 +469,15 @@ _gnutls_cpy_write_security_parameters (mhd_gtls_security_param_st *
* This is to be called after sending the Change Cipher Spec packet.
*/
int
mhd_gtls_connection_state_init (mhd_gtls_session_t session)
MHD_gtls_connection_state_init (MHD_gtls_session_t session)
{
int ret;
/* Setup the master secret
*/
if ((ret = mhd_gtls_generate_master (session, 0), 0) < 0)
if ((ret = MHD_gtls_generate_master (session, 0), 0) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -490,39 +490,39 @@ mhd_gtls_connection_state_init (mhd_gtls_session_t session)
* (read encrypted data)
*/
int
mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
{
int mac_size;
int rc;
_gnutls_uint64zero (session->connection_state.read_sequence_number);
MHD__gnutls_uint64zero (session->connection_state.read_sequence_number);
/* Update internals from CipherSuite selected.
* If we are resuming just copy the connection session
*/
if (session->internals.resumed == RESUME_FALSE)
{
rc = mhd_gtls_set_read_cipher (session,
mhd_gtls_cipher_suite_get_cipher_algo
rc = MHD_gtls_set_read_cipher (session,
MHD_gtls_cipher_suite_get_cipher_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
rc = mhd_gtls_set_read_mac (session,
mhd_gtls_cipher_suite_get_mac_algo
rc = MHD_gtls_set_read_mac (session,
MHD_gtls_cipher_suite_get_mac_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
rc = mhd_gtls_set_kx (session,
mhd_gtls_cipher_suite_get_kx_algo
rc = MHD_gtls_set_kx (session,
MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
rc = mhd_gtls_set_read_compression (session,
rc = MHD_gtls_set_read_compression (session,
session->internals.
compression_method);
if (rc < 0)
@@ -530,54 +530,54 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
}
else
{ /* RESUME_TRUE */
_gnutls_cpy_read_security_parameters (&session->security_parameters,
MHD__gnutls_cpy_read_security_parameters (&session->security_parameters,
&session->internals.
resumed_security_parameters);
}
rc = _gnutls_set_read_keys (session);
rc = MHD__gnutls_set_read_keys (session);
if (rc < 0)
return rc;
_gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n",
MHD__gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n",
session,
mhd_gtls_cipher_suite_get_name
MHD_gtls_cipher_suite_get_name
(&session->security_parameters.
current_cipher_suite));
if (mhd_gtls_compression_is_ok
if (MHD_gtls_compression_is_ok
(session->security_parameters.read_compression_algorithm) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
if (mhd_gnutls_mac_is_ok
if (MHD_gnutls_mac_is_ok
(session->security_parameters.read_mac_algorithm) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
/* Free all the previous keys/ sessions etc.
*/
if (session->connection_state.read_mac_secret.data != NULL)
_gnutls_free_datum (&session->connection_state.read_mac_secret);
MHD__gnutls_free_datum (&session->connection_state.read_mac_secret);
if (session->connection_state.read_cipher_state != NULL)
mhd_gnutls_cipher_deinit (session->connection_state.read_cipher_state);
MHD_gnutls_cipher_deinit (session->connection_state.read_cipher_state);
if (session->connection_state.read_compression_state != NULL)
mhd_gtls_comp_deinit (session->connection_state.read_compression_state,
MHD_gtls_comp_deinit (session->connection_state.read_compression_state,
1);
mac_size =
mhd_gnutls_hash_get_algo_len (session->security_parameters.
MHD_gnutls_hash_get_algo_len (session->security_parameters.
read_mac_algorithm);
_gnutls_handshake_log
MHD__gnutls_handshake_log
("HSK[%x]: Initializing internal [read] cipher sessions\n", session);
switch (session->security_parameters.entity)
@@ -586,7 +586,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
/* initialize cipher session
*/
session->connection_state.read_cipher_state =
mhd_gtls_cipher_init (session->security_parameters.
MHD_gtls_cipher_init (session->security_parameters.
read_bulk_cipher_algorithm,
&session->cipher_specs.client_write_key,
&session->cipher_specs.client_write_IV);
@@ -594,7 +594,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
&& session->security_parameters.read_bulk_cipher_algorithm !=
MHD_GNUTLS_CIPHER_NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -603,13 +603,13 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
*/
if (mac_size > 0)
{
if (_gnutls_sset_datum (&session->connection_state.read_mac_secret,
if (MHD__gnutls_sset_datum (&session->connection_state.read_mac_secret,
session->cipher_specs.
client_write_mac_secret.data,
session->cipher_specs.
client_write_mac_secret.size) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -619,7 +619,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
#if MHD_DEBUG_TLS
case GNUTLS_CLIENT:
session->connection_state.read_cipher_state =
mhd_gtls_cipher_init (session->security_parameters.
MHD_gtls_cipher_init (session->security_parameters.
read_bulk_cipher_algorithm,
&session->cipher_specs.server_write_key,
&session->cipher_specs.server_write_IV);
@@ -629,7 +629,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
&& session->security_parameters.read_bulk_cipher_algorithm !=
MHD_GNUTLS_CIPHER_NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -638,13 +638,13 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
*/
if (mac_size > 0)
{
if (_gnutls_sset_datum (&session->connection_state.read_mac_secret,
if (MHD__gnutls_sset_datum (&session->connection_state.read_mac_secret,
session->cipher_specs.
server_write_mac_secret.data,
session->cipher_specs.
server_write_mac_secret.size) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
}
@@ -652,17 +652,17 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
break;
#endif
default: /* this check is useless */
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
session->connection_state.read_compression_state =
mhd_gtls_comp_init (session->security_parameters.
MHD_gtls_comp_init (session->security_parameters.
read_compression_algorithm, 1);
if (session->connection_state.read_compression_state == GNUTLS_COMP_FAILED)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
@@ -675,39 +675,39 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
* (write encrypted data)
*/
int
mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
{
int mac_size;
int rc;
_gnutls_uint64zero (session->connection_state.write_sequence_number);
MHD__gnutls_uint64zero (session->connection_state.write_sequence_number);
/* Update internals from CipherSuite selected.
* If we are resuming just copy the connection session
*/
if (session->internals.resumed == RESUME_FALSE)
{
rc = mhd_gtls_set_write_cipher (session,
mhd_gtls_cipher_suite_get_cipher_algo
rc = MHD_gtls_set_write_cipher (session,
MHD_gtls_cipher_suite_get_cipher_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
rc = mhd_gtls_set_write_mac (session,
mhd_gtls_cipher_suite_get_mac_algo
rc = MHD_gtls_set_write_mac (session,
MHD_gtls_cipher_suite_get_mac_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
rc = mhd_gtls_set_kx (session,
mhd_gtls_cipher_suite_get_kx_algo
rc = MHD_gtls_set_kx (session,
MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite));
if (rc < 0)
return rc;
rc = mhd_gtls_set_write_compression (session,
rc = MHD_gtls_set_write_compression (session,
session->internals.
compression_method);
if (rc < 0)
@@ -715,31 +715,31 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
}
else
{ /* RESUME_TRUE */
_gnutls_cpy_write_security_parameters (&session->security_parameters,
MHD__gnutls_cpy_write_security_parameters (&session->security_parameters,
&session->internals.
resumed_security_parameters);
}
rc = _gnutls_set_write_keys (session);
rc = MHD__gnutls_set_write_keys (session);
if (rc < 0)
return rc;
_gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n", session,
mhd_gtls_cipher_suite_get_name
MHD__gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n", session,
MHD_gtls_cipher_suite_get_name
(&session->security_parameters.
current_cipher_suite));
if (mhd_gtls_compression_is_ok
if (MHD_gtls_compression_is_ok
(session->security_parameters.write_compression_algorithm) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
if (mhd_gnutls_mac_is_ok
if (MHD_gnutls_mac_is_ok
(session->security_parameters.write_mac_algorithm) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -748,20 +748,20 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
/* Free all the previous keys/ sessions etc.
*/
if (session->connection_state.write_mac_secret.data != NULL)
_gnutls_free_datum (&session->connection_state.write_mac_secret);
MHD__gnutls_free_datum (&session->connection_state.write_mac_secret);
if (session->connection_state.write_cipher_state != NULL)
mhd_gnutls_cipher_deinit (session->connection_state.write_cipher_state);
MHD_gnutls_cipher_deinit (session->connection_state.write_cipher_state);
if (session->connection_state.write_compression_state != NULL)
mhd_gtls_comp_deinit (session->connection_state.write_compression_state,
MHD_gtls_comp_deinit (session->connection_state.write_compression_state,
0);
mac_size =
mhd_gnutls_hash_get_algo_len (session->security_parameters.
MHD_gnutls_hash_get_algo_len (session->security_parameters.
write_mac_algorithm);
_gnutls_handshake_log
MHD__gnutls_handshake_log
("HSK[%x]: Initializing internal [write] cipher sessions\n", session);
switch (session->security_parameters.entity)
@@ -770,7 +770,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
/* initialize cipher session
*/
session->connection_state.write_cipher_state =
mhd_gtls_cipher_init (session->security_parameters.
MHD_gtls_cipher_init (session->security_parameters.
write_bulk_cipher_algorithm,
&session->cipher_specs.server_write_key,
&session->cipher_specs.server_write_IV);
@@ -780,7 +780,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
&& session->security_parameters.write_bulk_cipher_algorithm !=
MHD_GNUTLS_CIPHER_NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -790,13 +790,13 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
*/
if (mac_size > 0)
{
if (_gnutls_sset_datum (&session->connection_state.write_mac_secret,
if (MHD__gnutls_sset_datum (&session->connection_state.write_mac_secret,
session->cipher_specs.
server_write_mac_secret.data,
session->cipher_specs.
server_write_mac_secret.size) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -807,7 +807,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
#if MHD_DEBUG_TLS
case GNUTLS_CLIENT:
session->connection_state.write_cipher_state =
mhd_gtls_cipher_init (session->security_parameters.
MHD_gtls_cipher_init (session->security_parameters.
write_bulk_cipher_algorithm,
&session->cipher_specs.client_write_key,
&session->cipher_specs.client_write_IV);
@@ -817,7 +817,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
&& session->security_parameters.write_bulk_cipher_algorithm !=
MHD_GNUTLS_CIPHER_NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -825,13 +825,13 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
*/
if (mac_size > 0)
{
if (_gnutls_sset_datum (&session->connection_state.write_mac_secret,
if (MHD__gnutls_sset_datum (&session->connection_state.write_mac_secret,
session->cipher_specs.
client_write_mac_secret.data,
session->cipher_specs.
client_write_mac_secret.size) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
}
@@ -839,18 +839,18 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
break;
#endif
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
session->connection_state.write_compression_state =
mhd_gtls_comp_init (session->security_parameters.
MHD_gtls_comp_init (session->security_parameters.
write_compression_algorithm, 0);
if (session->connection_state.write_compression_state == GNUTLS_COMP_FAILED)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
@@ -860,15 +860,15 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
/* Sets the specified cipher into the pending session
*/
int
mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
MHD_gtls_set_read_cipher (MHD_gtls_session_t session,
enum MHD_GNUTLS_CipherAlgorithm algo)
{
if (mhd_gtls_cipher_is_ok (algo) == 0)
if (MHD_gtls_cipher_is_ok (algo) == 0)
{
if (mhd_gtls_cipher_priority (session, algo) < 0)
if (MHD_gtls_cipher_priority (session, algo) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNWANTED_ALGORITHM;
}
@@ -877,7 +877,7 @@ mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -886,15 +886,15 @@ mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
}
int
mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
MHD_gtls_set_write_cipher (MHD_gtls_session_t session,
enum MHD_GNUTLS_CipherAlgorithm algo)
{
if (mhd_gtls_cipher_is_ok (algo) == 0)
if (MHD_gtls_cipher_is_ok (algo) == 0)
{
if (mhd_gtls_cipher_priority (session, algo) < 0)
if (MHD_gtls_cipher_priority (session, algo) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNWANTED_ALGORITHM;
}
@@ -903,7 +903,7 @@ mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -915,17 +915,17 @@ mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
/* Sets the specified algorithm into pending compression session
*/
int
mhd_gtls_set_read_compression (mhd_gtls_session_t session,
MHD_gtls_set_read_compression (MHD_gtls_session_t session,
enum MHD_GNUTLS_CompressionMethod algo)
{
if (mhd_gtls_compression_is_ok (algo) == 0)
if (MHD_gtls_compression_is_ok (algo) == 0)
{
session->security_parameters.read_compression_algorithm = algo;
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
return 0;
@@ -933,17 +933,17 @@ mhd_gtls_set_read_compression (mhd_gtls_session_t session,
}
int
mhd_gtls_set_write_compression (mhd_gtls_session_t session,
MHD_gtls_set_write_compression (MHD_gtls_session_t session,
enum MHD_GNUTLS_CompressionMethod algo)
{
if (mhd_gtls_compression_is_ok (algo) == 0)
if (MHD_gtls_compression_is_ok (algo) == 0)
{
session->security_parameters.write_compression_algorithm = algo;
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
return 0;
@@ -953,22 +953,22 @@ mhd_gtls_set_write_compression (mhd_gtls_session_t session,
/* Sets the specified kx algorithm into pending session
*/
int
mhd_gtls_set_kx (mhd_gtls_session_t session,
MHD_gtls_set_kx (MHD_gtls_session_t session,
enum MHD_GNUTLS_KeyExchangeAlgorithm algo)
{
if (mhd_gtls_kx_is_ok (algo) == 0)
if (MHD_gtls_kx_is_ok (algo) == 0)
{
session->security_parameters.kx_algorithm = algo;
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (mhd_gtls_kx_priority (session, algo) < 0)
if (MHD_gtls_kx_priority (session, algo) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
/* we shouldn't get here */
return GNUTLS_E_UNWANTED_ALGORITHM;
}
@@ -979,22 +979,22 @@ mhd_gtls_set_kx (mhd_gtls_session_t session,
/* Sets the specified mac algorithm into pending session */
int
mhd_gtls_set_read_mac (mhd_gtls_session_t session,
MHD_gtls_set_read_mac (MHD_gtls_session_t session,
enum MHD_GNUTLS_HashAlgorithm algo)
{
if (mhd_gnutls_mac_is_ok (algo) == 0)
if (MHD_gnutls_mac_is_ok (algo) == 0)
{
session->security_parameters.read_mac_algorithm = algo;
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (mhd_gtls_mac_priority (session, algo) < 0)
if (MHD_gtls_mac_priority (session, algo) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNWANTED_ALGORITHM;
}
@@ -1004,22 +1004,22 @@ mhd_gtls_set_read_mac (mhd_gtls_session_t session,
}
int
mhd_gtls_set_write_mac (mhd_gtls_session_t session,
MHD_gtls_set_write_mac (MHD_gtls_session_t session,
enum MHD_GNUTLS_HashAlgorithm algo)
{
if (mhd_gnutls_mac_is_ok (algo) == 0)
if (MHD_gnutls_mac_is_ok (algo) == 0)
{
session->security_parameters.write_mac_algorithm = algo;
}
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (mhd_gtls_mac_priority (session, algo) < 0)
if (MHD_gtls_mac_priority (session, algo) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNWANTED_ALGORITHM;
}
src/daemon/https/tls/gnutls_constate.h
+10 -10
View File
@@ -22,20 +22,20 @@
*
*/
int mhd_gtls_connection_state_init (mhd_gtls_session_t session);
int mhd_gtls_read_connection_state_init (mhd_gtls_session_t session);
int mhd_gtls_write_connection_state_init (mhd_gtls_session_t session);
int mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
int MHD_gtls_connection_state_init (MHD_gtls_session_t session);
int MHD_gtls_read_connection_state_init (MHD_gtls_session_t session);
int MHD_gtls_write_connection_state_init (MHD_gtls_session_t session);
int MHD_gtls_set_write_cipher (MHD_gtls_session_t session,
enum MHD_GNUTLS_CipherAlgorithm algo);
int mhd_gtls_set_write_mac (mhd_gtls_session_t session,
int MHD_gtls_set_write_mac (MHD_gtls_session_t session,
enum MHD_GNUTLS_HashAlgorithm algo);
int mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
int MHD_gtls_set_read_cipher (MHD_gtls_session_t session,
enum MHD_GNUTLS_CipherAlgorithm algo);
int mhd_gtls_set_read_mac (mhd_gtls_session_t session,
int MHD_gtls_set_read_mac (MHD_gtls_session_t session,
enum MHD_GNUTLS_HashAlgorithm algo);
int mhd_gtls_set_read_compression (mhd_gtls_session_t session,
int MHD_gtls_set_read_compression (MHD_gtls_session_t session,
enum MHD_GNUTLS_CompressionMethod algo);
int mhd_gtls_set_write_compression (mhd_gtls_session_t session,
int MHD_gtls_set_write_compression (MHD_gtls_session_t session,
enum MHD_GNUTLS_CompressionMethod algo);
int mhd_gtls_set_kx (mhd_gtls_session_t session,
int MHD_gtls_set_kx (MHD_gtls_session_t session,
enum MHD_GNUTLS_KeyExchangeAlgorithm algo);
src/daemon/https/tls/gnutls_datum.c
+12 -12
View File
@@ -34,31 +34,31 @@
void
mhd_gtls_write_datum16 (opaque * dest, gnutls_datum_t dat)
MHD_gtls_write_datum16 (opaque * dest, MHD_gnutls_datum_t dat)
{
mhd_gtls_write_uint16 (dat.size, dest);
MHD_gtls_write_uint16 (dat.size, dest);
if (dat.data != NULL)
memcpy (&dest[2], dat.data, dat.size);
}
void
mhd_gtls_write_datum24 (opaque * dest, gnutls_datum_t dat)
MHD_gtls_write_datum24 (opaque * dest, MHD_gnutls_datum_t dat)
{
mhd_gtls_write_uint24 (dat.size, dest);
MHD_gtls_write_uint24 (dat.size, dest);
if (dat.data != NULL)
memcpy (&dest[3], dat.data, dat.size);
}
void
mhd_gtls_write_datum32 (opaque * dest, gnutls_datum_t dat)
MHD_gtls_write_datum32 (opaque * dest, MHD_gnutls_datum_t dat)
{
mhd_gtls_write_uint32 (dat.size, dest);
MHD_gtls_write_uint32 (dat.size, dest);
if (dat.data != NULL)
memcpy (&dest[4], dat.data, dat.size);
}
void
mhd_gtls_write_datum8 (opaque * dest, gnutls_datum_t dat)
MHD_gtls_write_datum8 (opaque * dest, MHD_gnutls_datum_t dat)
{
dest[0] = (uint8_t) dat.size;
if (dat.data != NULL)
@@ -67,8 +67,8 @@ mhd_gtls_write_datum8 (opaque * dest, gnutls_datum_t dat)
int
mhd_gtls_set_datum_m (gnutls_datum_t * dat, const void *data,
size_t data_size, gnutls_alloc_function galloc_func)
MHD_gtls_set_datum_m (MHD_gnutls_datum_t * dat, const void *data,
size_t data_size, MHD_gnutls_alloc_function galloc_func)
{
if (data_size == 0 || data == NULL)
{
@@ -88,9 +88,9 @@ mhd_gtls_set_datum_m (gnutls_datum_t * dat, const void *data,
}
int
mhd_gtls_datum_append_m (gnutls_datum_t * dst, const void *data,
MHD_gtls_datum_append_m (MHD_gnutls_datum_t * dst, const void *data,
size_t data_size,
gnutls_realloc_function grealloc_func)
MHD_gnutls_realloc_function grealloc_func)
{
dst->data = grealloc_func (dst->data, data_size + dst->size);
@@ -104,7 +104,7 @@ mhd_gtls_datum_append_m (gnutls_datum_t * dst, const void *data,
}
void
mhd_gtls_free_datum_m (gnutls_datum_t * dat, gnutls_free_function gfree_func)
MHD_gtls_free_datum_m (MHD_gnutls_datum_t * dat, MHD_gnutls_free_function gfree_func)
{
if (dat->data != NULL)
gfree_func (dat->data);
src/daemon/https/tls/gnutls_datum.h
+13 -13
View File
@@ -22,19 +22,19 @@
*
*/
void mhd_gtls_write_datum16 (opaque * dest, gnutls_datum_t dat);
void mhd_gtls_write_datum24 (opaque * dest, gnutls_datum_t dat);
void mhd_gtls_write_datum32 (opaque * dest, gnutls_datum_t dat);
void mhd_gtls_write_datum8 (opaque * dest, gnutls_datum_t dat);
void MHD_gtls_write_datum16 (opaque * dest, MHD_gnutls_datum_t dat);
void MHD_gtls_write_datum24 (opaque * dest, MHD_gnutls_datum_t dat);
void MHD_gtls_write_datum32 (opaque * dest, MHD_gnutls_datum_t dat);
void MHD_gtls_write_datum8 (opaque * dest, MHD_gnutls_datum_t dat);
int mhd_gtls_set_datum_m (gnutls_datum_t * dat, const void *data,
size_t data_size, gnutls_alloc_function);
#define _gnutls_set_datum( x, y, z) mhd_gtls_set_datum_m(x,y,z, gnutls_malloc)
#define _gnutls_sset_datum( x, y, z) mhd_gtls_set_datum_m(x,y,z, gnutls_secure_malloc)
int MHD_gtls_set_datum_m (MHD_gnutls_datum_t * dat, const void *data,
size_t data_size, MHD_gnutls_alloc_function);
#define MHD__gnutls_set_datum( x, y, z) MHD_gtls_set_datum_m(x,y,z, MHD_gnutls_malloc)
#define MHD__gnutls_sset_datum( x, y, z) MHD_gtls_set_datum_m(x,y,z, MHD_gnutls_secure_malloc)
int mhd_gtls_datum_append_m (gnutls_datum_t * dat, const void *data,
size_t data_size, gnutls_realloc_function);
#define _gnutls_datum_append(x,y,z) mhd_gtls_datum_append_m(x,y,z, gnutls_realloc)
int MHD_gtls_datum_append_m (MHD_gnutls_datum_t * dat, const void *data,
size_t data_size, MHD_gnutls_realloc_function);
#define MHD__gnutls_datum_append(x,y,z) MHD_gtls_datum_append_m(x,y,z, MHD_gnutls_realloc)
void mhd_gtls_free_datum_m (gnutls_datum_t * dat, gnutls_free_function);
#define _gnutls_free_datum(x) mhd_gtls_free_datum_m(x, gnutls_free)
void MHD_gtls_free_datum_m (MHD_gnutls_datum_t * dat, MHD_gnutls_free_function);
#define MHD__gnutls_free_datum(x) MHD_gtls_free_datum_m(x, MHD_gnutls_free)
src/daemon/https/tls/gnutls_dh.c
+27 -27
View File
@@ -35,11 +35,11 @@
his_key = X ^ y mod p;
// generate our secret and the public value (X) for it
X = mhd_gtls_calc_dh_secret(&x, g, p);
X = MHD_gtls_calc_dh_secret(&x, g, p);
// now we can calculate the shared secret
key = mhd_gtls_calc_dh_key(Y, x, g, p);
mhd_gtls_mpi_release(x);
mhd_gtls_mpi_release(g);
key = MHD_gtls_calc_dh_key(Y, x, g, p);
MHD_gtls_mpi_release(x);
MHD_gtls_mpi_release(g);
*/
#define MAX_BITS 18000
@@ -47,24 +47,24 @@
/* returns the public value (X), and the secret (ret_x).
*/
mpi_t
mhd_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
MHD_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
{
mpi_t e, x;
int x_size = _gnutls_mpi_get_nbits (prime) - 1;
int x_size = MHD__gnutls_mpi_get_nbits (prime) - 1;
/* The size of the secret key is less than
* prime/2
*/
if (x_size > MAX_BITS || x_size <= 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return NULL;
}
x = _gnutls_mpi_new (x_size);
x = MHD__gnutls_mpi_new (x_size);
if (x == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
if (ret_x)
*ret_x = NULL;
@@ -76,55 +76,55 @@ mhd_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
*/
do
{
_gnutls_mpi_randomize (x, (x_size / 8) * 8, GCRY_STRONG_RANDOM);
MHD__gnutls_mpi_randomize (x, (x_size / 8) * 8, GCRY_STRONG_RANDOM);
/* Check whether x is zero.
*/
}
while (_gnutls_mpi_cmp_ui (x, 0) == 0);
while (MHD__gnutls_mpi_cmp_ui (x, 0) == 0);
e = _gnutls_mpi_alloc_like (prime);
e = MHD__gnutls_mpi_alloc_like (prime);
if (e == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
if (ret_x)
*ret_x = NULL;
mhd_gtls_mpi_release (&x);
MHD_gtls_mpi_release (&x);
return NULL;
}
_gnutls_mpi_powm (e, g, x, prime);
MHD__gnutls_mpi_powm (e, g, x, prime);
if (ret_x)
*ret_x = x;
else
mhd_gtls_mpi_release (&x);
MHD_gtls_mpi_release (&x);
return e;
}
mpi_t
mhd_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
MHD_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
{
mpi_t k;
int bits;
bits = _gnutls_mpi_get_nbits (prime);
bits = MHD__gnutls_mpi_get_nbits (prime);
if (bits <= 0 || bits > MAX_BITS)
{
gnutls_assert ();
MHD_gnutls_assert ();
return NULL;
}
k = _gnutls_mpi_alloc_like (prime);
k = MHD__gnutls_mpi_alloc_like (prime);
if (k == NULL)
return NULL;
_gnutls_mpi_powm (k, f, x, prime);
MHD__gnutls_mpi_powm (k, f, x, prime);
return k;
}
/*-
* mhd_gtls_get_dh_params - Returns the DH parameters pointer
* MHD_gtls_get_dh_params - Returns the DH parameters pointer
* @dh_params: is an DH parameters structure, or NULL.
* @func: is a callback function to receive the parameters or NULL.
* @session: a gnutls session.
@@ -132,12 +132,12 @@ mhd_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
* This function will return the dh parameters pointer.
*
-*/
mhd_gtls_dh_params_t
mhd_gtls_get_dh_params (mhd_gtls_dh_params_t dh_params,
gnutls_params_function * func,
mhd_gtls_session_t session)
MHD_gtls_dh_params_t
MHD_gtls_get_dh_params (MHD_gtls_dh_params_t dh_params,
MHD_gnutls_params_function * func,
MHD_gtls_session_t session)
{
gnutls_params_st params;
MHD_gnutls_params_st params;
int ret;
/* if cached return the cached */
src/daemon/https/tls/gnutls_dh.h
+8 -8
View File
@@ -25,14 +25,14 @@
#ifndef GNUTLS_DH_H
# define GNUTLS_DH_H
const mpi_t *mhd_gtls_dh_params_to_mpi (mhd_gtls_dh_params_t);
mpi_t mhd_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime);
mpi_t mhd_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime);
int mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned bits);
const mpi_t *MHD_gtls_dh_params_to_mpi (MHD_gtls_dh_params_t);
mpi_t MHD_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime);
mpi_t MHD_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime);
int MHD_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned bits);
mhd_gtls_dh_params_t
mhd_gtls_get_dh_params (mhd_gtls_dh_params_t dh_params,
gnutls_params_function * func,
mhd_gtls_session_t session);
MHD_gtls_dh_params_t
MHD_gtls_get_dh_params (MHD_gtls_dh_params_t dh_params,
MHD_gnutls_params_function * func,
MHD_gtls_session_t session);
#endif
src/daemon/https/tls/gnutls_dh_primes.c
+24 -24
View File
@@ -36,7 +36,7 @@
/* returns the prime and the generator of DH params.
*/
const mpi_t *
mhd_gtls_dh_params_to_mpi (mhd_gtls_dh_params_t dh_primes)
MHD_gtls_dh_params_to_mpi (MHD_gtls_dh_params_t dh_primes)
{
if (dh_primes == NULL || dh_primes->params[1] == NULL
|| dh_primes->params[0] == NULL)
@@ -48,7 +48,7 @@ mhd_gtls_dh_params_to_mpi (mhd_gtls_dh_params_t dh_primes)
}
int
mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
MHD_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
{
mpi_t g = NULL, prime = NULL;
gcry_error_t err;
@@ -75,7 +75,7 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
if (times)
{
mhd_gtls_mpi_release (&prime);
MHD_gtls_mpi_release (&prime);
gcry_prime_release_factors (factors);
}
@@ -85,7 +85,7 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
if (err != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
result = GNUTLS_E_INTERNAL_ERROR;
goto cleanup;
}
@@ -98,7 +98,7 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
if (err != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
result = GNUTLS_E_INTERNAL_ERROR;
goto cleanup;
}
@@ -108,7 +108,7 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
err = gcry_prime_group_generator (&g, prime, factors, NULL);
if (err != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
result = GNUTLS_E_INTERNAL_ERROR;
goto cleanup;
}
@@ -119,17 +119,17 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
if (ret_g)
*ret_g = g;
else
mhd_gtls_mpi_release (&g);
MHD_gtls_mpi_release (&g);
if (ret_n)
*ret_n = prime;
else
mhd_gtls_mpi_release (&prime);
MHD_gtls_mpi_release (&prime);
return 0;
cleanup:gcry_prime_release_factors (factors);
mhd_gtls_mpi_release (&g);
mhd_gtls_mpi_release (&prime);
MHD_gtls_mpi_release (&g);
MHD_gtls_mpi_release (&prime);
return result;
@@ -139,20 +139,20 @@ cleanup:gcry_prime_release_factors (factors);
* generated one.
*/
/**
* MHD_gnutls_dh_params_init - This function will initialize the DH parameters
* MHD__gnutls_dh_params_init - This function will initialize the DH parameters
* @dh_params: Is a structure that will hold the prime numbers
*
* This function will initialize the DH parameters structure.
*
**/
int
MHD_gnutls_dh_params_init (mhd_gtls_dh_params_t * dh_params)
MHD__gnutls_dh_params_init (MHD_gtls_dh_params_t * dh_params)
{
(*dh_params) = gnutls_calloc (1, sizeof (mhd_gtls_dh_params_st));
(*dh_params) = MHD_gnutls_calloc (1, sizeof (MHD_gtls_dh_params_st));
if (*dh_params == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -161,33 +161,33 @@ MHD_gnutls_dh_params_init (mhd_gtls_dh_params_t * dh_params)
}
/**
* MHD_gnutls_dh_params_deinit - This function will deinitialize the DH parameters
* MHD__gnutls_dh_params_deinit - This function will deinitialize the DH parameters
* @dh_params: Is a structure that holds the prime numbers
*
* This function will deinitialize the DH parameters structure.
*
**/
void
MHD_gnutls_dh_params_deinit (mhd_gtls_dh_params_t dh_params)
MHD__gnutls_dh_params_deinit (MHD_gtls_dh_params_t dh_params)
{
if (dh_params == NULL)
return;
mhd_gtls_mpi_release (&dh_params->params[0]);
mhd_gtls_mpi_release (&dh_params->params[1]);
MHD_gtls_mpi_release (&dh_params->params[0]);
MHD_gtls_mpi_release (&dh_params->params[1]);
gnutls_free (dh_params);
MHD_gnutls_free (dh_params);
}
/**
* MHD_gnutls_dh_params_generate2 - This function will generate new DH parameters
* MHD__gnutls_dh_params_generate2 - This function will generate new DH parameters
* @params: Is the structure that the DH parameters will be stored
* @bits: is the prime's number of bits
*
* This function will generate a new pair of prime and generator for use in
* the Diffie-Hellman key exchange. The new parameters will be allocated using
* gnutls_malloc() and will be stored in the appropriate datum.
* MHD_gnutls_malloc() and will be stored in the appropriate datum.
* This function is normally slow.
*
* Note that the bits value should be one of 768, 1024, 2048, 3072 or 4096.
@@ -197,16 +197,16 @@ MHD_gnutls_dh_params_deinit (mhd_gtls_dh_params_t dh_params)
*
**/
int
MHD_gnutls_dh_params_generate2 (mhd_gtls_dh_params_t params,
MHD__gnutls_dh_params_generate2 (MHD_gtls_dh_params_t params,
unsigned int bits)
{
int ret;
ret =
mhd_gtls_dh_generate_prime (&params->params[1], &params->params[0], bits);
MHD_gtls_dh_generate_prime (&params->params[1], &params->params[0], bits);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
src/daemon/https/tls/gnutls_errors.c
+12 -12
View File
@@ -33,21 +33,21 @@
#define _(String) (String)
#define N_(String) (String)
extern LOG_FUNC _gnutls_log_func;
extern LOG_FUNC MHD__gnutls_log_func;
#define ERROR_ENTRY(desc, name, fatal) \
{ desc, #name, name, fatal}
struct gnutls_error_entry
struct MHD_gnutls_error_entry
{
const char *desc;
const char *_name;
int number;
int fatal;
};
typedef struct gnutls_error_entry gnutls_error_entry;
typedef struct MHD_gnutls_error_entry MHD_gnutls_error_entry;
static const gnutls_error_entry mhd_gtls_error_algorithms[] = {
static const MHD_gnutls_error_entry MHD_gtls_error_algorithms[] = {
/* "Short Description", Error code define, critical (0,1) -- 1 in most cases */
ERROR_ENTRY (N_("Success."), GNUTLS_E_SUCCESS, 0),
ERROR_ENTRY (N_("Could not negotiate a supported cipher suite."),
@@ -246,8 +246,8 @@ static const gnutls_error_entry mhd_gtls_error_algorithms[] = {
};
#define GNUTLS_ERROR_LOOP(b) \
const gnutls_error_entry *p; \
for(p = mhd_gtls_error_algorithms; p->desc != NULL; p++) { b ; }
const MHD_gnutls_error_entry *p; \
for(p = MHD_gtls_error_algorithms; p->desc != NULL; p++) { b ; }
#define GNUTLS_ERROR_ALG_LOOP(a) \
GNUTLS_ERROR_LOOP( if(p->number == error) { a; break; } )
@@ -329,7 +329,7 @@ MHD_gtls_strerror (int error)
* given error code.
*/
const char *
_gnutls_strerror (int error)
MHD__gnutls_strerror (int error)
{
const char *ret = NULL;
@@ -340,7 +340,7 @@ _gnutls_strerror (int error)
}
int
mhd_gtls_asn2err (int asn_err)
MHD_gtls_asn2err (int asn_err)
{
switch (asn_err)
{
@@ -382,13 +382,13 @@ mhd_gtls_asn2err (int asn_err)
* caller provided function
*/
void
mhd_gtls_log (int level, const char *fmt, ...)
MHD_gtls_log (int level, const char *fmt, ...)
{
va_list args;
char str[MAX_LOG_SIZE];
void (*log_func) (int, const char *) = _gnutls_log_func;
void (*log_func) (int, const char *) = MHD__gnutls_log_func;
if (_gnutls_log_func == NULL)
if (MHD__gnutls_log_func == NULL)
return;
va_start (args, fmt);
@@ -405,7 +405,7 @@ mhd_gtls_log (int level, const char *fmt, ...)
* be called. This may affect performance.
*/
void
_gnutls_null_log (void *x, ...)
MHD__gnutls_null_log (void *x, ...)
{
return;
}
src/daemon/https/tls/gnutls_errors.h
+29 -29
View File
@@ -28,46 +28,46 @@
#ifdef __FILE__
# ifdef __LINE__
# define gnutls_assert() _gnutls_debug_log( "ASSERT: %s:%d\n", __FILE__,__LINE__);
# define MHD_gnutls_assert() MHD__gnutls_debug_log( "ASSERT: %s:%d\n", __FILE__,__LINE__);
# else
# define gnutls_assert()
# define MHD_gnutls_assert()
# endif
#else /* __FILE__ not defined */
# define gnutls_assert()
# define MHD_gnutls_assert()
#endif
int mhd_gtls_asn2err (int asn_err);
void mhd_gtls_log (int, const char *fmt, ...);
int MHD_gtls_asn2err (int asn_err);
void MHD_gtls_log (int, const char *fmt, ...);
extern int _gnutls_log_level;
extern int MHD__gnutls_log_level;
#ifdef C99_MACROS
#define LEVEL(l, ...) if (_gnutls_log_level >= l || _gnutls_log_level > 9) \
mhd_gtls_log( l, __VA_ARGS__)
#define LEVEL(l, ...) if (MHD__gnutls_log_level >= l || MHD__gnutls_log_level > 9) \
MHD_gtls_log( l, __VA_ARGS__)
#define LEVEL_EQ(l, ...) if (_gnutls_log_level == l || _gnutls_log_level > 9) \
mhd_gtls_log( l, __VA_ARGS__)
#define LEVEL_EQ(l, ...) if (MHD__gnutls_log_level == l || MHD__gnutls_log_level > 9) \
MHD_gtls_log( l, __VA_ARGS__)
# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__)
# define _gnutls_handshake_log(...) LEVEL(3, __VA_ARGS__)
# define _gnutls_io_log(...) LEVEL_EQ(5, __VA_ARGS__)
# define _gnutls_buffers_log(...) LEVEL_EQ(6, __VA_ARGS__)
# define _gnutls_hard_log(...) LEVEL(9, __VA_ARGS__)
# define _gnutls_record_log(...) LEVEL(4, __VA_ARGS__)
# define _gnutls_read_log(...) LEVEL_EQ(7, __VA_ARGS__)
# define _gnutls_write_log(...) LEVEL_EQ(7, __VA_ARGS__)
# define _gnutls_x509_log(...) LEVEL(1, __VA_ARGS__)
# define MHD__gnutls_debug_log(...) LEVEL(2, __VA_ARGS__)
# define MHD__gnutls_handshake_log(...) LEVEL(3, __VA_ARGS__)
# define MHD__gnutls_io_log(...) LEVEL_EQ(5, __VA_ARGS__)
# define MHD__gnutls_buffers_log(...) LEVEL_EQ(6, __VA_ARGS__)
# define MHD__gnutls_hard_log(...) LEVEL(9, __VA_ARGS__)
# define MHD__gnutls_record_log(...) LEVEL(4, __VA_ARGS__)
# define MHD__gnutls_read_log(...) LEVEL_EQ(7, __VA_ARGS__)
# define MHD__gnutls_write_log(...) LEVEL_EQ(7, __VA_ARGS__)
# define MHD__gnutls_x509_log(...) LEVEL(1, __VA_ARGS__)
#else
# define _gnutls_debug_log _gnutls_null_log
# define _gnutls_handshake_log _gnutls_null_log
# define _gnutls_io_log _gnutls_null_log
# define _gnutls_buffers_log _gnutls_null_log
# define _gnutls_hard_log _gnutls_null_log
# define _gnutls_record_log _gnutls_null_log
# define _gnutls_read_log _gnutls_null_log
# define _gnutls_write_log _gnutls_null_log
# define _gnutls_x509_log _gnutls_null_log
# define MHD__gnutls_debug_log MHD__gnutls_null_log
# define MHD__gnutls_handshake_log MHD__gnutls_null_log
# define MHD__gnutls_io_log MHD__gnutls_null_log
# define MHD__gnutls_buffers_log MHD__gnutls_null_log
# define MHD__gnutls_hard_log MHD__gnutls_null_log
# define MHD__gnutls_record_log MHD__gnutls_null_log
# define MHD__gnutls_read_log MHD__gnutls_null_log
# define MHD__gnutls_write_log MHD__gnutls_null_log
# define MHD__gnutls_x509_log MHD__gnutls_null_log
void _gnutls_null_log (void *, ...);
void MHD__gnutls_null_log (void *, ...);
#endif /* C99_MACROS */
src/daemon/https/tls/gnutls_extensions.c
+59 -59
View File
@@ -43,39 +43,39 @@
#define MAX_EXT_SIZE 10
const int mhd_gtls_extensions_size = MAX_EXT_SIZE;
const int MHD_gtls_extensions_size = MAX_EXT_SIZE;
mhd_gtls_extension_entry mhd_gtls_extensions[MAX_EXT_SIZE] = {
MHD_gtls_extension_entry MHD_gtls_extensions[MAX_EXT_SIZE] = {
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_MAX_RECORD_SIZE,
EXTENSION_TLS,
mhd_gtls_max_record_recv_params,
mhd_gtls_max_record_send_params),
MHD_gtls_max_record_recv_params,
MHD_gtls_max_record_send_params),
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_CERT_TYPE,
EXTENSION_TLS,
mhd_gtls_cert_type_recv_params,
mhd_gtls_cert_type_send_params),
MHD_gtls_cert_type_recv_params,
MHD_gtls_cert_type_send_params),
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_SERVER_NAME,
EXTENSION_APPLICATION,
mhd_gtls_server_name_recv_params,
mhd_gtls_server_name_send_params),
MHD_gtls_server_name_recv_params,
MHD_gtls_server_name_send_params),
#ifdef ENABLE_OPRFI
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_OPAQUE_PRF_INPUT,
EXTENSION_TLS,
mhd_gtls_oprfi_recv_params,
mhd_gtls_oprfi_send_params),
MHD_gtls_oprfi_recv_params,
MHD_gtls_oprfi_send_params),
#endif
#ifdef ENABLE_SRP
GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_SRP,
EXTENSION_TLS,
_gnutls_srp_recv_params,
_gnutls_srp_send_params),
MHD__gnutls_srp_recv_params,
MHD__gnutls_srp_send_params),
#endif
{0, 0, 0, 0}
};
#define GNUTLS_EXTENSION_LOOP2(b) \
mhd_gtls_extension_entry *p; \
for(p = mhd_gtls_extensions; p->name != NULL; p++) { b ; }
MHD_gtls_extension_entry *p; \
for(p = MHD_gtls_extensions; p->name != NULL; p++) { b ; }
#define GNUTLS_EXTENSION_LOOP(a) \
GNUTLS_EXTENSION_LOOP2( if(p->type == type) { a; break; } )
@@ -83,29 +83,29 @@ mhd_gtls_extension_entry mhd_gtls_extensions[MAX_EXT_SIZE] = {
/* EXTENSION functions */
mhd_gtls_ext_recv_func
mhd_gtls_ext_func_recv (uint16_t type, mhd_gtls_ext_parse_type_t parse_type)
MHD_gtls_ext_recv_func
MHD_gtls_ext_func_recv (uint16_t type, MHD_gtls_ext_parse_type_t parse_type)
{
mhd_gtls_ext_recv_func ret = NULL;
MHD_gtls_ext_recv_func ret = NULL;
GNUTLS_EXTENSION_LOOP (if
(parse_type == EXTENSION_ANY
|| p->parse_type == parse_type) ret =
p->gnutls_ext_func_recv);
p->MHD_gnutls_ext_func_recv);
return ret;
}
mhd_gtls_ext_send_func
mhd_gtls_ext_func_send (uint16_t type)
MHD_gtls_ext_send_func
MHD_gtls_ext_func_send (uint16_t type)
{
mhd_gtls_ext_send_func ret = NULL;
GNUTLS_EXTENSION_LOOP (ret = p->gnutls_ext_func_send);
MHD_gtls_ext_send_func ret = NULL;
GNUTLS_EXTENSION_LOOP (ret = p->MHD_gnutls_ext_func_send);
return ret;
}
const char *
mhd_gtls_extension_get_name (uint16_t type)
MHD_gtls_extension_get_name (uint16_t type)
{
const char *ret = NULL;
@@ -119,7 +119,7 @@ mhd_gtls_extension_get_name (uint16_t type)
* requested ones. Otherwise it's a fatal error.
*/
static int
_gnutls_extension_list_check (mhd_gtls_session_t session, uint16_t type)
MHD__gnutls_extension_list_check (MHD_gtls_session_t session, uint16_t type)
{
#if MHD_DEBUG_TLS
if (session->security_parameters.entity == GNUTLS_CLIENT)
@@ -137,15 +137,15 @@ _gnutls_extension_list_check (mhd_gtls_session_t session, uint16_t type)
}
int
mhd_gtls_parse_extensions (mhd_gtls_session_t session,
mhd_gtls_ext_parse_type_t parse_type,
MHD_gtls_parse_extensions (MHD_gtls_session_t session,
MHD_gtls_ext_parse_type_t parse_type,
const opaque * data, int data_size)
{
int next, ret;
int pos = 0;
uint16_t type;
const opaque *sdata;
mhd_gtls_ext_recv_func ext_recv;
MHD_gtls_ext_recv_func ext_recv;
uint16_t size;
#if MHD_DEBUG_TLS
@@ -153,15 +153,15 @@ mhd_gtls_parse_extensions (mhd_gtls_session_t session,
if (session->security_parameters.entity == GNUTLS_CLIENT)
for (i = 0; i < session->internals.extensions_sent_size; i++)
{
_gnutls_debug_log ("EXT[%d]: expecting extension '%s'\n",
MHD__gnutls_debug_log ("EXT[%d]: expecting extension '%s'\n",
session,
mhd_gtls_extension_get_name
MHD_gtls_extension_get_name
(session->internals.extensions_sent[i]));
}
#endif
DECR_LENGTH_RET (data_size, 2, 0);
next = mhd_gtls_read_uint16 (data);
next = MHD_gtls_read_uint16 (data);
pos += 2;
DECR_LENGTH_RET (data_size, next, 0);
@@ -169,32 +169,32 @@ mhd_gtls_parse_extensions (mhd_gtls_session_t session,
do
{
DECR_LENGTH_RET (next, 2, 0);
type = mhd_gtls_read_uint16 (&data[pos]);
type = MHD_gtls_read_uint16 (&data[pos]);
pos += 2;
_gnutls_debug_log ("EXT[%x]: Received extension '%s/%d'\n", session,
mhd_gtls_extension_get_name (type), type);
MHD__gnutls_debug_log ("EXT[%x]: Received extension '%s/%d'\n", session,
MHD_gtls_extension_get_name (type), type);
if ((ret = _gnutls_extension_list_check (session, type)) < 0)
if ((ret = MHD__gnutls_extension_list_check (session, type)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
DECR_LENGTH_RET (next, 2, 0);
size = mhd_gtls_read_uint16 (&data[pos]);
size = MHD_gtls_read_uint16 (&data[pos]);
pos += 2;
DECR_LENGTH_RET (next, size, 0);
sdata = &data[pos];
pos += size;
ext_recv = mhd_gtls_ext_func_recv (type, parse_type);
ext_recv = MHD_gtls_ext_func_recv (type, parse_type);
if (ext_recv == NULL)
continue;
if ((ret = ext_recv (session, sdata, size)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -210,7 +210,7 @@ mhd_gtls_parse_extensions (mhd_gtls_session_t session,
* extensions are the ones we requested.
*/
static void
_gnutls_extension_list_add (mhd_gtls_session_t session, uint16_t type)
MHD__gnutls_extension_list_add (MHD_gtls_session_t session, uint16_t type)
{
#if MHD_DEBUG_TLS
if (session->security_parameters.entity == GNUTLS_CLIENT)
@@ -223,43 +223,43 @@ _gnutls_extension_list_add (mhd_gtls_session_t session, uint16_t type)
}
else
{
_gnutls_debug_log ("extensions: Increase MAX_EXT_TYPES\n");
MHD__gnutls_debug_log ("extensions: Increase MAX_EXT_TYPES\n");
}
}
#endif
}
int
mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
MHD_gtls_gen_extensions (MHD_gtls_session_t session, opaque * data,
size_t data_size)
{
int size;
uint16_t pos = 0;
opaque *sdata;
int sdata_size;
mhd_gtls_ext_send_func ext_send;
mhd_gtls_extension_entry *p;
MHD_gtls_ext_send_func ext_send;
MHD_gtls_extension_entry *p;
if (data_size < 2)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
/* allocate enough data for each extension.
*/
sdata_size = data_size;
sdata = gnutls_malloc (sdata_size);
sdata = MHD_gnutls_malloc (sdata_size);
if (sdata == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
pos += 2;
for (p = mhd_gtls_extensions; p->name != NULL; p++)
for (p = MHD_gtls_extensions; p->name != NULL; p++)
{
ext_send = mhd_gtls_ext_func_send (p->type);
ext_send = MHD_gtls_ext_func_send (p->type);
if (ext_send == NULL)
continue;
size = ext_send (session, sdata, sdata_size);
@@ -267,17 +267,17 @@ mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
{
if (data_size < pos + (size_t) size + 4)
{
gnutls_assert ();
gnutls_free (sdata);
MHD_gnutls_assert ();
MHD_gnutls_free (sdata);
return GNUTLS_E_INTERNAL_ERROR;
}
/* write extension type */
mhd_gtls_write_uint16 (p->type, &data[pos]);
MHD_gtls_write_uint16 (p->type, &data[pos]);
pos += 2;
/* write size */
mhd_gtls_write_uint16 (size, &data[pos]);
MHD_gtls_write_uint16 (size, &data[pos]);
pos += 2;
memcpy (&data[pos], sdata, size);
@@ -285,15 +285,15 @@ mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
/* add this extension to the extension list
*/
_gnutls_extension_list_add (session, p->type);
MHD__gnutls_extension_list_add (session, p->type);
_gnutls_debug_log ("EXT[%x]: Sending extension %s\n", session,
mhd_gtls_extension_get_name (p->type));
MHD__gnutls_debug_log ("EXT[%x]: Sending extension %s\n", session,
MHD_gtls_extension_get_name (p->type));
}
else if (size < 0)
{
gnutls_assert ();
gnutls_free (sdata);
MHD_gnutls_assert ();
MHD_gnutls_free (sdata);
return size;
}
}
@@ -301,14 +301,14 @@ mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
size = pos;
pos -= 2; /* remove the size of the size header! */
mhd_gtls_write_uint16 (pos, data);
MHD_gtls_write_uint16 (pos, data);
if (size == 2)
{ /* empty */
size = 0;
}
gnutls_free (sdata);
MHD_gnutls_free (sdata);
return size;
}
src/daemon/https/tls/gnutls_extensions.h
+12 -12
View File
@@ -24,24 +24,24 @@
#include <gnutls_int.h>
const char *mhd_gtls_extension_get_name (uint16_t type);
int mhd_gtls_parse_extensions (mhd_gtls_session_t, mhd_gtls_ext_parse_type_t,
const char *MHD_gtls_extension_get_name (uint16_t type);
int MHD_gtls_parse_extensions (MHD_gtls_session_t, MHD_gtls_ext_parse_type_t,
const opaque *, int);
int mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
int MHD_gtls_gen_extensions (MHD_gtls_session_t session, opaque * data,
size_t data_size);
typedef int (*mhd_gtls_ext_recv_func) (mhd_gtls_session_t, const opaque *, size_t); /* recv data */
typedef int (*mhd_gtls_ext_send_func) (mhd_gtls_session_t, opaque *, size_t); /* send data */
typedef int (*MHD_gtls_ext_recv_func) (MHD_gtls_session_t, const opaque *, size_t); /* recv data */
typedef int (*MHD_gtls_ext_send_func) (MHD_gtls_session_t, opaque *, size_t); /* send data */
mhd_gtls_ext_send_func mhd_gtls_ext_func_send (uint16_t type);
mhd_gtls_ext_recv_func mhd_gtls_ext_func_recv (uint16_t type,
mhd_gtls_ext_parse_type_t);
MHD_gtls_ext_send_func MHD_gtls_ext_func_send (uint16_t type);
MHD_gtls_ext_recv_func MHD_gtls_ext_func_recv (uint16_t type,
MHD_gtls_ext_parse_type_t);
typedef struct
{
const char *name;
uint16_t type;
mhd_gtls_ext_parse_type_t parse_type;
mhd_gtls_ext_recv_func gnutls_ext_func_recv;
mhd_gtls_ext_send_func gnutls_ext_func_send;
} mhd_gtls_extension_entry;
MHD_gtls_ext_parse_type_t parse_type;
MHD_gtls_ext_recv_func MHD_gnutls_ext_func_recv;
MHD_gtls_ext_send_func MHD_gnutls_ext_func_send;
} MHD_gtls_extension_entry;
src/daemon/https/tls/gnutls_global.c
+74 -74
View File
@@ -44,17 +44,17 @@
GCRY_THREAD_OPTION_PTHREAD_IMPL;
#define gnutls_log_func LOG_FUNC
#define MHD_gnutls_log_func LOG_FUNC
/* created by asn1c */
extern const ASN1_ARRAY_TYPE gnutls_asn1_tab[];
extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
extern const ASN1_ARRAY_TYPE MHD_gnutlsMHD__asn1_tab[];
extern const ASN1_ARRAY_TYPE MHD_pkix_asn1_tab[];
LOG_FUNC _gnutls_log_func;
int _gnutls_log_level = 0; /* default log level */
LOG_FUNC MHD__gnutls_log_func;
int MHD__gnutls_log_level = 0; /* default log level */
ASN1_TYPE _gnutls_pkix1_asn;
ASN1_TYPE _gnutls_gnutls_asn;
ASN1_TYPE MHD__gnutls_pkix1_asn;
ASN1_TYPE MHD__gnutlsMHD__gnutls_asn;
/**
* MHD_gtls_global_set_log_function - This function sets the logging function
@@ -65,13 +65,13 @@ ASN1_TYPE _gnutls_gnutls_asn;
* Normally you may not use this function since it is only used
* for debugging purposes.
*
* gnutls_log_func is of the form,
* void (*gnutls_log_func)( int level, const char*);
* MHD_gnutls_log_func is of the form,
* void (*MHD_gnutls_log_func)( int level, const char*);
**/
void
MHD_gtls_global_set_log_function (gnutls_log_func log_func)
MHD_gtls_global_set_log_function (MHD_gnutls_log_func log_func)
{
_gnutls_log_func = log_func;
MHD__gnutls_log_func = log_func;
}
/**
@@ -89,10 +89,10 @@ MHD_gtls_global_set_log_function (gnutls_log_func log_func)
void
MHD_gtls_global_set_log_level (int level)
{
_gnutls_log_level = level;
MHD__gnutls_log_level = level;
}
int _gnutls_is_secure_mem_null (const void *);
int MHD__gnutls_is_secure_mem_null (const void *);
/**
* MHD_gtls_global_set_mem_functions - This function sets the memory allocation functions
@@ -108,61 +108,61 @@ int _gnutls_is_secure_mem_null (const void *);
* This function is provided to set the memory allocation functions to
* something other than the defaults (ie the gcrypt allocation functions).
*
* This function must be called before MHD_gnutls_global_init() is called.
* This function must be called before MHD__gnutls_global_init() is called.
*
**/
void
MHD_gtls_global_set_mem_functions (gnutls_alloc_function alloc_func,
gnutls_alloc_function
MHD_gtls_global_set_mem_functions (MHD_gnutls_alloc_function alloc_func,
MHD_gnutls_alloc_function
secure_alloc_func,
gnutls_is_secure_function
MHD_gnutls_is_secure_function
is_secure_func,
gnutls_realloc_function realloc_func,
gnutls_free_function free_func)
MHD_gnutls_realloc_function realloc_func,
MHD_gnutls_free_function free_func)
{
gnutls_secure_malloc = secure_alloc_func;
gnutls_malloc = alloc_func;
gnutls_realloc = realloc_func;
gnutls_free = free_func;
MHD_gnutls_secure_malloc = secure_alloc_func;
MHD_gnutls_malloc = alloc_func;
MHD_gnutls_realloc = realloc_func;
MHD_gnutls_free = free_func;
if (is_secure_func != NULL)
_gnutls_is_secure_memory = is_secure_func;
MHD__gnutls_is_secure_memory = is_secure_func;
else
_gnutls_is_secure_memory = _gnutls_is_secure_mem_null;
MHD__gnutls_is_secure_memory = MHD__gnutls_is_secure_mem_null;
/* if using the libc's default malloc
* use libc's calloc as well.
*/
if (gnutls_malloc == malloc)
if (MHD_gnutls_malloc == malloc)
{
gnutls_calloc = calloc;
MHD_gnutls_calloc = calloc;
}
else
{ /* use the included ones */
gnutls_calloc = mhd_gtls_calloc;
MHD_gnutls_calloc = MHD_gtls_calloc;
}
gnutls_strdup = mhd_gtls_strdup;
MHD_gnutls_strdup = MHD_gtls_strdup;
}
#ifdef DEBUG
static void
_gnutls_gcry_log_handler (void *dummy, int level,
MHD__gnutls_gcry_log_handler (void *dummy, int level,
const char *fmt, va_list list)
{
mhd_gtls_log (level, fmt, list);
MHD_gtls_log (level, fmt, list);
}
#endif
static int _gnutls_init = 0;
static int MHD__gnutls_init_level = 0;
/**
* MHD_gnutls_global_init - This function initializes the global data to defaults.
* MHD__gnutls_global_init - This function initializes the global data to defaults.
*
* This function initializes the global data to defaults.
* Every gnutls application has a global data which holds common parameters
* shared by gnutls session structures.
* You must call MHD_gnutls_global_deinit() when gnutls usage is no longer needed
* You must call MHD__gnutls_global_deinit() when gnutls usage is no longer needed
* Returns zero on success.
*
* Note that this function will also initialize libgcrypt, if it has not
@@ -171,8 +171,8 @@ static int _gnutls_init = 0;
* want to disable libgcrypt's internal lockings etc.
*
* This function increment a global counter, so that
* MHD_gnutls_global_deinit() only releases resources when it has been
* called as many times as MHD_gnutls_global_init(). This is useful when
* MHD__gnutls_global_deinit() only releases resources when it has been
* called as many times as MHD__gnutls_global_init(). This is useful when
* GnuTLS is used by more than one library in an application. This
* function can be called many times, but will only do something the
* first time.
@@ -187,13 +187,13 @@ static int _gnutls_init = 0;
*
**/
int
MHD_gnutls_global_init (void)
MHD__gnutls_global_init (void)
{
int result = 0;
int res;
char c;
if (_gnutls_init++)
if (MHD__gnutls_init_level++)
return 0;
#if HAVE_WINSOCK
@@ -206,13 +206,13 @@ MHD_gnutls_global_init (void)
err = WSAStartup (requested, &data);
if (err != 0)
{
_gnutls_debug_log ("WSAStartup failed: %d.\n", err);
MHD__gnutls_debug_log ("WSAStartup failed: %d.\n", err);
return GNUTLS_E_LIBRARY_VERSION_MISMATCH;
}
if (data.wVersion < requested)
{
_gnutls_debug_log ("WSAStartup version check failed (%d < %d).\n",
MHD__gnutls_debug_log ("WSAStartup version check failed (%d < %d).\n",
data.wVersion, requested);
WSACleanup ();
return GNUTLS_E_LIBRARY_VERSION_MISMATCH;
@@ -239,15 +239,15 @@ MHD_gnutls_global_init (void)
/* this call initializes libgcrypt */
if (gcry_check_version (p) == NULL)
{
gnutls_assert ();
_gnutls_debug_log ("Checking for libgcrypt failed '%s'\n", p);
MHD_gnutls_assert ();
MHD__gnutls_debug_log ("Checking for libgcrypt failed '%s'\n", p);
return GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY;
}
/* for gcrypt in order to be able to allocate memory */
gcry_set_allocation_handler (gnutls_malloc, gnutls_secure_malloc,
_gnutls_is_secure_memory, gnutls_realloc,
gnutls_free);
gcry_set_allocation_handler (MHD_gnutls_malloc, MHD_gnutls_secure_malloc,
MHD__gnutls_is_secure_memory, MHD_gnutls_realloc,
MHD_gnutls_free);
/* gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING, NULL, 0); */
@@ -257,14 +257,14 @@ MHD_gnutls_global_init (void)
/* applications may want to override that, so we only use
* it in debugging mode.
*/
gcry_set_log_handler (_gnutls_gcry_log_handler, NULL);
gcry_set_log_handler (MHD__gnutls_gcry_log_handler, NULL);
#endif
}
if (gc_init () != GC_OK)
if (MHD_gc_init () != GC_OK)
{
gnutls_assert ();
_gnutls_debug_log ("Initializing crypto backend failed\n");
MHD_gnutls_assert ();
MHD__gnutls_debug_log ("Initializing crypto backend failed\n");
return GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY;
}
@@ -276,50 +276,50 @@ MHD_gnutls_global_init (void)
* This should not deal with files in the final
* version.
*/
res = asn1_array2tree (pkix_asn1_tab, &_gnutls_pkix1_asn, NULL);
res = MHD__asn1_array2tree (MHD_pkix_asn1_tab, &MHD__gnutls_pkix1_asn, NULL);
if (res != ASN1_SUCCESS)
{
result = mhd_gtls_asn2err (res);
result = MHD_gtls_asn2err (res);
return result;
}
res = asn1_array2tree (gnutls_asn1_tab, &_gnutls_gnutls_asn, NULL);
res = MHD__asn1_array2tree (MHD_gnutlsMHD__asn1_tab, &MHD__gnutlsMHD__gnutls_asn, NULL);
if (res != ASN1_SUCCESS)
{
asn1_delete_structure (&_gnutls_pkix1_asn);
result = mhd_gtls_asn2err (res);
MHD__asn1_delete_structure (&MHD__gnutls_pkix1_asn);
result = MHD_gtls_asn2err (res);
return result;
}
/* Initialize the gcrypt (if used random generator) */
gc_pseudo_random (&c, 1);
MHD_gc_pseudo_random (&c, 1);
return result;
}
/**
* MHD_gnutls_global_deinit - This function deinitializes the global data
* MHD__gnutls_global_deinit - This function deinitializes the global data
*
* This function deinitializes the global data, that were initialized
* using MHD_gnutls_global_init().
* using MHD__gnutls_global_init().
*
* Note! This function is not thread safe. See the discussion for
* MHD_gnutls_global_init() for more information.
* MHD__gnutls_global_init() for more information.
*
**/
void
MHD_gnutls_global_deinit (void)
MHD__gnutls_global_deinit (void)
{
if (_gnutls_init == 1)
if (MHD__gnutls_init_level == 1)
{
#if HAVE_WINSOCK
WSACleanup ();
#endif
asn1_delete_structure (&_gnutls_gnutls_asn);
asn1_delete_structure (&_gnutls_pkix1_asn);
gc_done ();
MHD__asn1_delete_structure (&MHD__gnutlsMHD__gnutls_asn);
MHD__asn1_delete_structure (&MHD__gnutls_pkix1_asn);
MHD_gc_done ();
}
_gnutls_init--;
MHD__gnutls_init_level--;
}
/* These functions should be elsewere. Kept here for
@@ -327,7 +327,7 @@ MHD_gnutls_global_deinit (void)
*/
/**
* MHD_gnutls_transport_set_pull_function - This function sets a read like function
* MHD__gnutls_transport_set_pull_function - This function sets a read like function
* @pull_func: a callback function similar to read()
* @session: gnutls session
*
@@ -337,17 +337,17 @@ MHD_gnutls_global_deinit (void)
* probably be ok.
*
* PULL_FUNC is of the form,
* ssize_t (*mhd_gtls_pull_func)(gnutls_transport_ptr_t, void*, size_t);
* ssize_t (*MHD_gtls_pull_func)(MHD_gnutls_transport_ptr_t, void*, size_t);
**/
void
MHD_gnutls_transport_set_pull_function (mhd_gtls_session_t session,
mhd_gtls_pull_func pull_func)
MHD__gnutls_transport_set_pull_function (MHD_gtls_session_t session,
MHD_gtls_pull_func pull_func)
{
session->internals._gnutls_pull_func = pull_func;
session->internals.MHD__gnutls_pull_func = pull_func;
}
/**
* MHD_gnutls_transport_set_push_function - This function sets the function to send data
* MHD__gnutls_transport_set_push_function - This function sets the function to send data
* @push_func: a callback function similar to write()
* @session: gnutls session
*
@@ -358,11 +358,11 @@ MHD_gnutls_transport_set_pull_function (mhd_gtls_session_t session,
* specify this function for gnutls to be able to send data.
*
* PUSH_FUNC is of the form,
* ssize_t (*mhd_gtls_push_func)(gnutls_transport_ptr_t, const void*, size_t);
* ssize_t (*MHD_gtls_push_func)(MHD_gnutls_transport_ptr_t, const void*, size_t);
**/
void
MHD_gnutls_transport_set_push_function (mhd_gtls_session_t session,
mhd_gtls_push_func push_func)
MHD__gnutls_transport_set_push_function (MHD_gtls_session_t session,
MHD_gtls_push_func push_func)
{
session->internals._gnutls_push_func = push_func;
session->internals.MHD__gnutls_push_func = push_func;
}
src/daemon/https/tls/gnutls_global.h
+7 -7
View File
@@ -27,19 +27,19 @@
#include <libtasn1.h>
/* this mutex is used to synchronize threads attemting call MHD_gnutls_global_init / MHD_gnutls_global_deinit */
pthread_mutex_t gnutls_init_mutex;
/* this mutex is used to synchronize threads attemting call MHD__gnutls_global_init / MHD__gnutls_global_deinit */
pthread_mutex_t MHD_gnutls_init_mutex;
int gnutls_is_secure_memory (const void *mem);
int MHD_gnutls_is_secure_memory (const void *mem);
extern ASN1_TYPE _gnutls_pkix1_asn;
extern ASN1_TYPE _gnutls_gnutls_asn;
extern ASN1_TYPE MHD__gnutls_pkix1_asn;
extern ASN1_TYPE MHD__gnutlsMHD__gnutls_asn;
/* removed const from node_asn* to
* prevent warnings, since libtasn1 doesn't
* use the const keywork in its functions.
*/
#define _gnutls_get_gnutls_asn() ((node_asn*) _gnutls_gnutls_asn)
#define _gnutls_get_pkix() ((node_asn*) _gnutls_pkix1_asn)
#define MHD__gnutls_getMHD__gnutls_asn() ((node_asn*) MHD__gnutlsMHD__gnutls_asn)
#define MHD__gnutls_get_pkix() ((node_asn*) MHD__gnutls_pkix1_asn)
#endif
src/daemon/https/tls/gnutls_handshake.c
+477 -477
View File
@@ -46,12 +46,12 @@
#include "gnutls_constate.h"
#include "gnutls_record.h"
#include "gnutls_state.h"
#include "gnutls_rsa_export.h" /* for gnutls_get_rsa_params() */
#include "auth_anon.h" /* for mhd_gtls_anon_server_credentials_t */
#include "gnutls_rsa_export.h" /* for MHD_gnutls_get_rsa_params() */
#include "auth_anon.h" /* for MHD_gtls_anon_server_credentials_t */
#include "gc.h"
#ifdef HANDSHAKE_DEBUG
#define ERR(x, y) _gnutls_handshake_log( "HSK[%x]: %s (%d)\n", session, x,y)
#define ERR(x, y) MHD__gnutls_handshake_log( "HSK[%x]: %s (%d)\n", session, x,y)
#else
#define ERR(x, y)
#endif
@@ -59,20 +59,20 @@
#define TRUE 1
#define FALSE 0
static int _gnutls_server_select_comp_method (mhd_gtls_session_t session,
static int MHD__gnutls_server_select_comp_method (MHD_gtls_session_t session,
opaque * data, int datalen);
/* Clears the handshake hash buffers and handles.
*/
inline static void
_gnutls_handshake_hash_buffers_clear (mhd_gtls_session_t session)
MHD__gnutls_handshake_hash_buffers_clear (MHD_gtls_session_t session)
{
mhd_gnutls_hash_deinit (session->internals.handshake_mac_handle_md5, NULL);
mhd_gnutls_hash_deinit (session->internals.handshake_mac_handle_sha, NULL);
MHD_gnutls_hash_deinit (session->internals.handshake_mac_handle_md5, NULL);
MHD_gnutls_hash_deinit (session->internals.handshake_mac_handle_sha, NULL);
session->internals.handshake_mac_handle_md5 = NULL;
session->internals.handshake_mac_handle_sha = NULL;
mhd_gtls_handshake_buffer_clear (session);
MHD_gtls_handshake_buffer_clear (session);
}
/* this will copy the required values for resuming to
@@ -80,7 +80,7 @@ _gnutls_handshake_hash_buffers_clear (mhd_gtls_session_t session)
* this will keep as less data to security_parameters.
*/
static void
resume_copy_required_values (mhd_gtls_session_t session)
resume_copy_required_values (MHD_gtls_session_t session)
{
/* get the new random values */
memcpy (session->internals.resumed_security_parameters.server_random,
@@ -105,7 +105,7 @@ resume_copy_required_values (mhd_gtls_session_t session)
session->security_parameters.entity =
session->internals.resumed_security_parameters.entity;
mhd_gtls_set_current_version (session,
MHD_gtls_set_current_version (session,
session->internals.
resumed_security_parameters.version);
@@ -120,13 +120,13 @@ resume_copy_required_values (mhd_gtls_session_t session)
}
void
mhd_gtls_set_server_random (mhd_gtls_session_t session, uint8_t * rnd)
MHD_gtls_set_server_random (MHD_gtls_session_t session, uint8_t * rnd)
{
memcpy (session->security_parameters.server_random, rnd, TLS_RANDOM_SIZE);
}
void
mhd_gtls_set_client_random (mhd_gtls_session_t session, uint8_t * rnd)
MHD_gtls_set_client_random (MHD_gtls_session_t session, uint8_t * rnd)
{
memcpy (session->security_parameters.client_random, rnd, TLS_RANDOM_SIZE);
}
@@ -136,25 +136,25 @@ mhd_gtls_set_client_random (mhd_gtls_session_t session, uint8_t * rnd)
#define SSL3_SERVER_MSG "SRVR"
#define SSL_MSG_LEN 4
static int
_gnutls_ssl3_finished (mhd_gtls_session_t session, int type, opaque * ret)
MHD__gnutls_ssl3_finished (MHD_gtls_session_t session, int type, opaque * ret)
{
const int siz = SSL_MSG_LEN;
mac_hd_t td_md5;
mac_hd_t td_sha;
const char *mesg;
td_md5 = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
td_md5 = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
if (td_md5 == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
td_sha = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
if (td_sha == NULL)
{
gnutls_assert ();
mhd_gnutls_hash_deinit (td_md5, NULL);
MHD_gnutls_assert ();
MHD_gnutls_hash_deinit (td_md5, NULL);
return GNUTLS_E_HASH_FAILED;
}
@@ -167,13 +167,13 @@ _gnutls_ssl3_finished (mhd_gtls_session_t session, int type, opaque * ret)
mesg = SSL3_CLIENT_MSG;
}
mhd_gnutls_hash (td_md5, mesg, siz);
mhd_gnutls_hash (td_sha, mesg, siz);
MHD_gnutls_hash (td_md5, mesg, siz);
MHD_gnutls_hash (td_sha, mesg, siz);
mhd_gnutls_mac_deinit_ssl3_handshake (td_md5, ret,
MHD_gnutls_mac_deinit_ssl3_handshake (td_md5, ret,
session->security_parameters.
master_secret, TLS_MASTER_SIZE);
mhd_gnutls_mac_deinit_ssl3_handshake (td_sha, &ret[16],
MHD_gnutls_mac_deinit_ssl3_handshake (td_sha, &ret[16],
session->security_parameters.
master_secret, TLS_MASTER_SIZE);
@@ -185,7 +185,7 @@ _gnutls_ssl3_finished (mhd_gtls_session_t session, int type, opaque * ret)
#define CLIENT_MSG "client finished"
#define TLS_MSG_LEN 15
static int
_gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
MHD__gnutls_finished (MHD_gtls_session_t session, int type, void *ret)
{
const int siz = TLS_MSG_LEN;
opaque concat[36];
@@ -193,37 +193,37 @@ _gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
const char *mesg;
mac_hd_t td_md5 = NULL;
mac_hd_t td_sha;
enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
if (ver < MHD_GNUTLS_PROTOCOL_TLS1_2)
{
td_md5 =
mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
if (td_md5 == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
}
td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
td_sha = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
if (td_sha == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
if (td_md5 != NULL)
mhd_gnutls_hash_deinit (td_md5, NULL);
MHD_gnutls_hash_deinit (td_md5, NULL);
return GNUTLS_E_HASH_FAILED;
}
if (ver < MHD_GNUTLS_PROTOCOL_TLS1_2)
{
mhd_gnutls_hash_deinit (td_md5, concat);
mhd_gnutls_hash_deinit (td_sha, &concat[16]);
MHD_gnutls_hash_deinit (td_md5, concat);
MHD_gnutls_hash_deinit (td_sha, &concat[16]);
len = 20 + 16;
}
else
{
mhd_gnutls_hash_deinit (td_sha, concat);
MHD_gnutls_hash_deinit (td_sha, concat);
len = 20;
}
@@ -236,7 +236,7 @@ _gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
mesg = CLIENT_MSG;
}
return mhd_gtls_PRF (session, session->security_parameters.master_secret,
return MHD_gtls_PRF (session, session->security_parameters.master_secret,
TLS_MASTER_SIZE, mesg, siz, concat, len, 12, ret);
}
@@ -244,7 +244,7 @@ _gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
* and put it to dst.
*/
int
mhd_gtls_tls_create_random (opaque * dst)
MHD_gtls_tls_create_random (opaque * dst)
{
uint32_t tim;
@@ -255,11 +255,11 @@ mhd_gtls_tls_create_random (opaque * dst)
tim = time (NULL);
/* generate server random value */
mhd_gtls_write_uint32 (tim, dst);
MHD_gtls_write_uint32 (tim, dst);
if (gc_nonce (&dst[4], TLS_RANDOM_SIZE - 4) != GC_OK)
if (MHD_gc_nonce (&dst[4], TLS_RANDOM_SIZE - 4) != GC_OK)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RANDOM_FAILED;
}
@@ -269,23 +269,23 @@ mhd_gtls_tls_create_random (opaque * dst)
/* returns the 0 on success or a negative value.
*/
int
mhd_gtls_negotiate_version (mhd_gtls_session_t session,
MHD_gtls_negotiate_version (MHD_gtls_session_t session,
enum MHD_GNUTLS_Protocol adv_version)
{
int ret;
/* if we do not support that version */
if (mhd_gtls_version_is_supported (session, adv_version) == 0)
if (MHD_gtls_version_is_supported (session, adv_version) == 0)
{
/* If he requested something we do not support
* then we send him the highest we support.
*/
ret = mhd_gtls_version_max (session);
ret = MHD_gtls_version_max (session);
if (ret == MHD_GNUTLS_PROTOCOL_VERSION_UNKNOWN)
{
/* this check is not really needed.
*/
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_CIPHER_SUITE;
}
}
@@ -294,13 +294,13 @@ mhd_gtls_negotiate_version (mhd_gtls_session_t session,
ret = adv_version;
}
mhd_gtls_set_current_version (session, ret);
MHD_gtls_set_current_version (session, ret);
return ret;
}
int
mhd_gtls_user_hello_func (mhd_gtls_session_t session,
MHD_gtls_user_hello_func (MHD_gtls_session_t session,
enum MHD_GNUTLS_Protocol adv_version)
{
int ret;
@@ -310,16 +310,16 @@ mhd_gtls_user_hello_func (mhd_gtls_session_t session,
ret = session->internals.user_hello_func (session);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
/* Here we need to renegotiate the version since the callee might
* have disabled some TLS versions.
*/
ret = mhd_gtls_negotiate_version (session, adv_version);
ret = MHD_gtls_negotiate_version (session, adv_version);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
@@ -332,7 +332,7 @@ mhd_gtls_user_hello_func (mhd_gtls_session_t session,
* since SSL version 2.0 is not supported).
*/
static int
_gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
MHD__gnutls_read_client_hello (MHD_gtls_session_t session, opaque * data,
int datalen)
{
uint8_t session_id_len;
@@ -345,28 +345,28 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
DECR_LEN (len, 2);
_gnutls_handshake_log ("HSK[%x]: Client's version: %d.%d\n", session,
MHD__gnutls_handshake_log ("HSK[%x]: Client's version: %d.%d\n", session,
data[pos], data[pos + 1]);
adv_version = mhd_gtls_version_get (data[pos], data[pos + 1]);
adv_version = MHD_gtls_version_get (data[pos], data[pos + 1]);
set_adv_version (session, data[pos], data[pos + 1]);
pos += 2;
neg_version = mhd_gtls_negotiate_version (session, adv_version);
neg_version = MHD_gtls_negotiate_version (session, adv_version);
if (neg_version < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
/* Read client random value.
*/
DECR_LEN (len, TLS_RANDOM_SIZE);
mhd_gtls_set_client_random (session, &data[pos]);
MHD_gtls_set_client_random (session, &data[pos]);
pos += TLS_RANDOM_SIZE;
mhd_gtls_tls_create_random (rnd);
mhd_gtls_set_server_random (session, rnd);
MHD_gtls_tls_create_random (rnd);
MHD_gtls_set_server_random (session, rnd);
session->security_parameters.timestamp = time (NULL);
@@ -376,7 +376,7 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
/* RESUME SESSION */
if (session_id_len > TLS_MAX_SESSION_ID_SIZE)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
DECR_LEN (len, session_id_len);
@@ -388,11 +388,11 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
{ /* resumed! */
resume_copy_required_values (session);
session->internals.resumed = RESUME_TRUE;
return mhd_gtls_user_hello_func (session, adv_version);
return MHD_gtls_user_hello_func (session, adv_version);
}
else
{
mhd_gtls_generate_session_id (session->security_parameters.session_id,
MHD_gtls_generate_session_id (session->security_parameters.session_id,
&session->security_parameters.
session_id_size);
@@ -402,7 +402,7 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
/* Remember ciphersuites for later
*/
DECR_LEN (len, 2);
suite_size = mhd_gtls_read_uint16 (&data[pos]);
suite_size = MHD_gtls_read_uint16 (&data[pos]);
pos += 2;
DECR_LEN (len, suite_size);
@@ -422,45 +422,45 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
*/
if (neg_version >= MHD_GNUTLS_PROTOCOL_TLS1_0)
{
ret = mhd_gtls_parse_extensions (session, EXTENSION_APPLICATION, &data[pos], len); /* len is the rest of the parsed length */
ret = MHD_gtls_parse_extensions (session, EXTENSION_APPLICATION, &data[pos], len); /* len is the rest of the parsed length */
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
ret = mhd_gtls_user_hello_func (session, adv_version);
ret = MHD_gtls_user_hello_func (session, adv_version);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if (neg_version >= MHD_GNUTLS_PROTOCOL_TLS1_0)
{
ret = mhd_gtls_parse_extensions (session, EXTENSION_TLS, &data[pos], len); /* len is the rest of the parsed length */
ret = MHD_gtls_parse_extensions (session, EXTENSION_TLS, &data[pos], len); /* len is the rest of the parsed length */
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
/* select an appropriate cipher suite
*/
ret = mhd_gtls_server_select_suite (session, suite_ptr, suite_size);
ret = MHD_gtls_server_select_suite (session, suite_ptr, suite_size);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
/* select appropriate compression method */
ret = _gnutls_server_select_comp_method (session, comp_ptr, comp_size);
ret = MHD__gnutls_server_select_comp_method (session, comp_ptr, comp_size);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -470,7 +470,7 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
/* here we hash all pending data.
*/
inline static int
_gnutls_handshake_hash_pending (mhd_gtls_session_t session)
MHD__gnutls_handshake_hash_pending (MHD_gtls_session_t session)
{
size_t siz;
int ret;
@@ -479,27 +479,27 @@ _gnutls_handshake_hash_pending (mhd_gtls_session_t session)
if (session->internals.handshake_mac_handle_sha == NULL ||
session->internals.handshake_mac_handle_md5 == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
/* We check if there are pending data to hash.
*/
if ((ret = mhd_gtls_handshake_buffer_get_ptr (session, &data, &siz)) < 0)
if ((ret = MHD_gtls_handshake_buffer_get_ptr (session, &data, &siz)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if (siz > 0)
{
mhd_gnutls_hash (session->internals.handshake_mac_handle_sha, data,
MHD_gnutls_hash (session->internals.handshake_mac_handle_sha, data,
siz);
mhd_gnutls_hash (session->internals.handshake_mac_handle_md5, data,
MHD_gnutls_hash (session->internals.handshake_mac_handle_md5, data,
siz);
}
mhd_gtls_handshake_buffer_empty (session);
MHD_gtls_handshake_buffer_empty (session);
return 0;
}
@@ -510,7 +510,7 @@ _gnutls_handshake_hash_pending (mhd_gtls_session_t session)
* we send.
*/
static int
_gnutls_send_finished (mhd_gtls_session_t session, int again)
MHD__gnutls_send_finished (MHD_gtls_session_t session, int again)
{
uint8_t data[36];
int ret;
@@ -523,37 +523,37 @@ _gnutls_send_finished (mhd_gtls_session_t session, int again)
/* This is needed in order to hash all the required
* messages.
*/
if ((ret = _gnutls_handshake_hash_pending (session)) < 0)
if ((ret = MHD__gnutls_handshake_hash_pending (session)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
{
ret =
_gnutls_ssl3_finished (session,
MHD__gnutls_ssl3_finished (session,
session->security_parameters.entity, data);
data_size = 36;
}
else
{ /* TLS 1.0 */
ret =
_gnutls_finished (session,
MHD__gnutls_finished (session,
session->security_parameters.entity, data);
data_size = 12;
}
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
ret =
mhd_gtls_send_handshake (session, data, data_size,
MHD_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_FINISHED);
return ret;
@@ -563,7 +563,7 @@ _gnutls_send_finished (mhd_gtls_session_t session, int again)
* went fine we have negotiated a secure connection
*/
static int
_gnutls_recv_finished (mhd_gtls_session_t session)
MHD__gnutls_recv_finished (MHD_gtls_session_t session)
{
uint8_t data[36], *vrfy;
int data_size;
@@ -571,17 +571,17 @@ _gnutls_recv_finished (mhd_gtls_session_t session)
int vrfysize;
ret =
mhd_gtls_recv_handshake (session, &vrfy, &vrfysize,
MHD_gtls_recv_handshake (session, &vrfy, &vrfysize,
GNUTLS_HANDSHAKE_FINISHED, MANDATORY_PACKET);
if (ret < 0)
{
ERR ("recv finished int", ret);
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
{
data_size = 36;
}
@@ -592,39 +592,39 @@ _gnutls_recv_finished (mhd_gtls_session_t session)
if (vrfysize != data_size)
{
gnutls_assert ();
gnutls_free (vrfy);
MHD_gnutls_assert ();
MHD_gnutls_free (vrfy);
return GNUTLS_E_ERROR_IN_FINISHED_PACKET;
}
if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
{
ret =
_gnutls_ssl3_finished (session,
MHD__gnutls_ssl3_finished (session,
(session->security_parameters.entity + 1) % 2,
data);
}
else
{ /* TLS 1.0 */
ret =
_gnutls_finished (session,
MHD__gnutls_finished (session,
(session->security_parameters.entity +
1) % 2, data);
}
if (ret < 0)
{
gnutls_assert ();
gnutls_free (vrfy);
MHD_gnutls_assert ();
MHD_gnutls_free (vrfy);
return ret;
}
if (memcmp (vrfy, data, data_size) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
ret = GNUTLS_E_ERROR_IN_FINISHED_PACKET;
}
gnutls_free (vrfy);
MHD_gnutls_free (vrfy);
return ret;
}
@@ -633,7 +633,7 @@ _gnutls_recv_finished (mhd_gtls_session_t session)
* RSA algorithms, PK_DSA if DSS, and PK_ANY for both or PK_NONE for none.
*/
static int
_gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
MHD__gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
data, int datalen)
{
int j;
@@ -643,18 +643,18 @@ _gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
if (datalen % 2 != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
for (j = 0; j < datalen; j += 2)
{
memcpy (&cs.suite, &data[j], 2);
kx = mhd_gtls_cipher_suite_get_kx_algo (&cs);
kx = MHD_gtls_cipher_suite_get_kx_algo (&cs);
if (mhd_gtls_map_kx_get_cred (kx, 1) == MHD_GNUTLS_CRD_CERTIFICATE)
if (MHD_gtls_map_kx_get_cred (kx, 1) == MHD_GNUTLS_CRD_CERTIFICATE)
{
algo = mhd_gtls_map_pk_get_pk (kx);
algo = MHD_gtls_map_pk_get_pk (kx);
if (algo != prev_algo && prev_algo != 0)
return GNUTLS_PK_ANY;
@@ -670,7 +670,7 @@ _gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
* it adds the suite to the session and performs some checks.
*/
int
mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
MHD_gtls_server_select_suite (MHD_gtls_session_t session, opaque * data,
int datalen)
{
int x, i, j;
@@ -680,12 +680,12 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
* supported by the peer.
*/
pk_algo = _gnutls_server_find_pk_algos_in_ciphersuites (data, datalen);
pk_algo = MHD__gnutls_server_find_pk_algos_in_ciphersuites (data, datalen);
x = mhd_gtls_supported_ciphersuites (session, &ciphers);
x = MHD_gtls_supported_ciphersuites (session, &ciphers);
if (x < 0)
{ /* the case x==0 is handled within the function. */
gnutls_assert ();
MHD_gnutls_assert ();
return x;
}
@@ -693,11 +693,11 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
* the certificate requested, or to the
* authentication requested (e.g. SRP).
*/
x = mhd_gtls_remove_unwanted_ciphersuites (session, &ciphers, x, pk_algo);
x = MHD_gtls_remove_unwanted_ciphersuites (session, &ciphers, x, pk_algo);
if (x <= 0)
{
gnutls_assert ();
gnutls_free (ciphers);
MHD_gnutls_assert ();
MHD_gnutls_free (ciphers);
if (x < 0)
return x;
else
@@ -710,21 +710,21 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
*/
if (datalen % 2 != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
#ifdef HANDSHAKE_DEBUG
_gnutls_handshake_log ("HSK[%x]: Requested cipher suites: \n", session);
MHD__gnutls_handshake_log ("HSK[%x]: Requested cipher suites: \n", session);
for (j = 0; j < datalen; j += 2)
{
memcpy (&cs.suite, &data[j], 2);
_gnutls_handshake_log ("\t%s\n", mhd_gtls_cipher_suite_get_name (&cs));
MHD__gnutls_handshake_log ("\t%s\n", MHD_gtls_cipher_suite_get_name (&cs));
}
_gnutls_handshake_log ("HSK[%x]: Supported cipher suites: \n", session);
MHD__gnutls_handshake_log ("HSK[%x]: Supported cipher suites: \n", session);
for (j = 0; j < x; j++)
_gnutls_handshake_log ("\t%s\n",
mhd_gtls_cipher_suite_get_name (&ciphers[j]));
MHD__gnutls_handshake_log ("\t%s\n",
MHD_gtls_cipher_suite_get_name (&ciphers[j]));
#endif
memset (session->security_parameters.current_cipher_suite.suite, '\0', 2);
@@ -738,9 +738,9 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
{
memcpy (&cs.suite, &data[j], 2);
_gnutls_handshake_log
MHD__gnutls_handshake_log
("HSK[%x]: Selected cipher suite: %s\n", session,
mhd_gtls_cipher_suite_get_name (&cs));
MHD_gtls_cipher_suite_get_name (&cs));
memcpy (session->security_parameters.current_cipher_suite.suite,
ciphers[i].suite, 2);
retval = 0;
@@ -750,42 +750,42 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
}
finish:
gnutls_free (ciphers);
MHD_gnutls_free (ciphers);
if (retval != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return retval;
}
/* check if the credentials (username, public key etc.) are ok
*/
if (mhd_gtls_get_kx_cred
if (MHD_gtls_get_kx_cred
(session,
mhd_gtls_cipher_suite_get_kx_algo (&session->security_parameters.
MHD_gtls_cipher_suite_get_kx_algo (&session->security_parameters.
current_cipher_suite), &err) == NULL
&& err != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
/* set the mhd_gtls_mod_auth_st to the appropriate struct
/* set the MHD_gtls_mod_auth_st to the appropriate struct
* according to the KX algorithm. This is needed since all the
* handshake functions are read from there;
*/
session->internals.auth_struct =
mhd_gtls_kx_auth_struct (mhd_gtls_cipher_suite_get_kx_algo
MHD_gtls_kx_auth_struct (MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite));
if (session->internals.auth_struct == NULL)
{
_gnutls_handshake_log
MHD__gnutls_handshake_log
("HSK[%x]: Cannot find the appropriate handler for the KX algorithm\n",
session);
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -797,16 +797,16 @@ finish:
/* This selects the best supported compression method from the ones provided
*/
static int
_gnutls_server_select_comp_method (mhd_gtls_session_t session,
MHD__gnutls_server_select_comp_method (MHD_gtls_session_t session,
opaque * data, int datalen)
{
int x, i, j;
uint8_t *comps;
x = mhd_gtls_supported_compression_methods (session, &comps);
x = MHD_gtls_supported_compression_methods (session, &comps);
if (x < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return x;
}
@@ -820,12 +820,12 @@ _gnutls_server_select_comp_method (mhd_gtls_session_t session,
if (comps[i] == data[j])
{
enum MHD_GNUTLS_CompressionMethod method =
mhd_gtls_compression_get_id (comps[i]);
MHD_gtls_compression_get_id_from_int (comps[i]);
session->internals.compression_method = method;
gnutls_free (comps);
MHD_gnutls_free (comps);
_gnutls_handshake_log
MHD__gnutls_handshake_log
("HSK[%x]: Selected Compression Method: %s\n", session,
MHD_gtls_compression_get_name (session->internals.
compression_method));
@@ -839,20 +839,20 @@ _gnutls_server_select_comp_method (mhd_gtls_session_t session,
/* we were not able to find a compatible compression
* algorithm
*/
gnutls_free (comps);
gnutls_assert ();
MHD_gnutls_free (comps);
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
/* This function sends an empty handshake packet. (like hello request).
* If the previous _gnutls_send_empty_handshake() returned
* If the previous MHD__gnutls_send_empty_handshake() returned
* GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again
* (until it returns ok), with NULL parameters.
*/
static int
_gnutls_send_empty_handshake (mhd_gtls_session_t session,
gnutls_handshake_description_t type, int again)
MHD__gnutls_send_empty_handshake (MHD_gtls_session_t session,
MHD_gnutls_handshake_description_t type, int again)
{
opaque data = 0;
opaque *ptr;
@@ -862,29 +862,29 @@ _gnutls_send_empty_handshake (mhd_gtls_session_t session,
else
ptr = NULL;
return mhd_gtls_send_handshake (session, ptr, 0, type);
return MHD_gtls_send_handshake (session, ptr, 0, type);
}
/* This function will hash the handshake message we sent. */
static int
_gnutls_handshake_hash_add_sent (mhd_gtls_session_t session,
gnutls_handshake_description_t type,
MHD__gnutls_handshake_hash_add_sent (MHD_gtls_session_t session,
MHD_gnutls_handshake_description_t type,
opaque * dataptr, uint32_t datalen)
{
int ret;
if ((ret = _gnutls_handshake_hash_pending (session)) < 0)
if ((ret = MHD__gnutls_handshake_hash_pending (session)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if (type != GNUTLS_HANDSHAKE_HELLO_REQUEST)
{
mhd_gnutls_hash (session->internals.handshake_mac_handle_sha, dataptr,
MHD_gnutls_hash (session->internals.handshake_mac_handle_sha, dataptr,
datalen);
mhd_gnutls_hash (session->internals.handshake_mac_handle_md5, dataptr,
MHD_gnutls_hash (session->internals.handshake_mac_handle_md5, dataptr,
datalen);
}
@@ -893,14 +893,14 @@ _gnutls_handshake_hash_add_sent (mhd_gtls_session_t session,
/* This function sends a handshake message of type 'type' containing the
* data specified here. If the previous mhd_gtls_send_handshake() returned
* data specified here. If the previous MHD_gtls_send_handshake() returned
* GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again
* (until it returns ok), with NULL parameters.
*/
int
mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
MHD_gtls_send_handshake (MHD_gtls_session_t session, void *i_data,
uint32_t i_datasize,
gnutls_handshake_description_t type)
MHD_gnutls_handshake_description_t type)
{
int ret;
uint8_t *data;
@@ -912,28 +912,28 @@ mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
/* we are resuming a previously interrupted
* send.
*/
ret = mhd_gtls_handshake_io_write_flush (session);
ret = MHD_gtls_handshake_io_write_flush (session);
return ret;
}
if (i_data == NULL && i_datasize > 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
/* first run */
datasize = i_datasize + HANDSHAKE_HEADER_SIZE;
data = gnutls_alloca (datasize);
data = MHD_gnutls_alloca (datasize);
if (data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
data[pos++] = (uint8_t) type;
mhd_gtls_write_uint24 (i_datasize, &data[pos]);
MHD_gtls_write_uint24 (i_datasize, &data[pos]);
pos += 3;
if (i_datasize > 0)
@@ -943,23 +943,23 @@ mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
*/
if (type != GNUTLS_HANDSHAKE_HELLO_REQUEST)
if ((ret =
_gnutls_handshake_hash_add_sent (session, type, data, datasize)) < 0)
MHD__gnutls_handshake_hash_add_sent (session, type, data, datasize)) < 0)
{
gnutls_assert ();
gnutls_afree (data);
MHD_gnutls_assert ();
MHD_gnutls_afree (data);
return ret;
}
session->internals.last_handshake_out = type;
ret =
mhd_gtls_handshake_io_send_int (session, GNUTLS_HANDSHAKE, type,
MHD_gtls_handshake_io_send_int (session, GNUTLS_HANDSHAKE, type,
data, datasize);
_gnutls_handshake_log ("HSK[%x]: %s was sent [%ld bytes]\n",
session, _gnutls_handshake2str (type), datasize);
MHD__gnutls_handshake_log ("HSK[%x]: %s was sent [%ld bytes]\n",
session, MHD__gnutls_handshake2str (type), datasize);
gnutls_afree (data);
MHD_gnutls_afree (data);
return ret;
}
@@ -972,9 +972,9 @@ mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
*/
#define SSL2_HEADERS 1
static int
_gnutls_recv_handshake_header (mhd_gtls_session_t session,
gnutls_handshake_description_t type,
gnutls_handshake_description_t * recv_type)
MHD__gnutls_recv_handshake_header (MHD_gtls_session_t session,
MHD_gnutls_handshake_description_t type,
MHD_gnutls_handshake_description_t * recv_type)
{
int ret;
uint32_t length32 = 0;
@@ -1006,12 +1006,12 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
if (session->internals.handshake_header_buffer.header_size < SSL2_HEADERS)
{
ret =
mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
MHD_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
type, dataptr, SSL2_HEADERS);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -1019,7 +1019,7 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
*/
if (ret != SSL2_HEADERS)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
session->internals.handshake_header_buffer.header_size = SSL2_HEADERS;
@@ -1029,7 +1029,7 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
|| type != GNUTLS_HANDSHAKE_CLIENT_HELLO)
{
ret =
mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
MHD_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
type,
&dataptr
[session->internals.
@@ -1039,14 +1039,14 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
handshake_header_buffer.header_size);
if (ret <= 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return (ret < 0) ? ret : GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
if ((size_t) ret !=
HANDSHAKE_HEADER_SIZE -
session->internals.handshake_header_buffer.header_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
*recv_type = dataptr[0];
@@ -1054,11 +1054,11 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
/* we do not use DECR_LEN because we know
* that the packet has enough data.
*/
length32 = mhd_gtls_read_uint24 (&dataptr[1]);
length32 = MHD_gtls_read_uint24 (&dataptr[1]);
handshake_header_size = HANDSHAKE_HEADER_SIZE;
_gnutls_handshake_log ("HSK[%x]: %s was received [%ld bytes]\n",
session, _gnutls_handshake2str (dataptr[0]),
MHD__gnutls_handshake_log ("HSK[%x]: %s was received [%ld bytes]\n",
session, MHD__gnutls_handshake2str (dataptr[0]),
length32 + HANDSHAKE_HEADER_SIZE);
}
@@ -1070,13 +1070,13 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
*recv_type = dataptr[0];
_gnutls_handshake_log ("HSK[%x]: %s(v2) was received [%ld bytes]\n",
session, _gnutls_handshake2str (*recv_type),
MHD__gnutls_handshake_log ("HSK[%x]: %s(v2) was received [%ld bytes]\n",
session, MHD__gnutls_handshake2str (*recv_type),
length32 + handshake_header_size);
if (*recv_type != GNUTLS_HANDSHAKE_CLIENT_HELLO)
{ /* it should be one or nothing */
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET;
}
}
@@ -1089,21 +1089,21 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
if (*recv_type != type)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET;
}
return length32;
}
#define _gnutls_handshake_header_buffer_clear( session) session->internals.handshake_header_buffer.header_size = 0
#define MHD__gnutls_handshake_header_buffer_clear( session) session->internals.handshake_header_buffer.header_size = 0
/* This function will hash the handshake headers and the
* handshake data.
*/
static int
_gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
gnutls_handshake_description_t recv_type,
MHD__gnutls_handshake_hash_add_recvd (MHD_gtls_session_t session,
MHD_gnutls_handshake_description_t recv_type,
opaque * header, uint16_t header_size,
opaque * dataptr, uint32_t datalen)
{
@@ -1113,9 +1113,9 @@ _gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
* and add the one we just received into the handshake_hash_buffer.
*/
if ((ret = _gnutls_handshake_hash_pending (session)) < 0)
if ((ret = MHD__gnutls_handshake_hash_pending (session)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -1124,18 +1124,18 @@ _gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
{
if ((ret =
mhd_gtls_handshake_buffer_put (session, header, header_size)) < 0)
MHD_gtls_handshake_buffer_put (session, header, header_size)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if (datalen > 0)
{
if ((ret =
mhd_gtls_handshake_buffer_put (session, dataptr, datalen)) < 0)
MHD_gtls_handshake_buffer_put (session, dataptr, datalen)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
@@ -1147,19 +1147,19 @@ _gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
/* This function will receive handshake messages of the given types,
* and will pass the message to the right place in order to be processed.
* E.g. for the SERVER_HELLO message (if it is expected), it will be
* passed to mhd_gtls_recv_hello().
* passed to MHD_gtls_recv_hello().
*/
int
mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
int *datalen, gnutls_handshake_description_t type,
MHD_gtls_recv_handshake (MHD_gtls_session_t session, uint8_t ** data,
int *datalen, MHD_gnutls_handshake_description_t type,
Optional optional)
{
int ret;
uint32_t length32 = 0;
opaque *dataptr = NULL;
gnutls_handshake_description_t recv_type;
MHD_gnutls_handshake_description_t recv_type;
ret = _gnutls_recv_handshake_header (session, type, &recv_type);
ret = MHD__gnutls_recv_handshake_header (session, type, &recv_type);
if (ret < 0)
{
@@ -1181,16 +1181,16 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
length32 = ret;
if (length32 > 0)
dataptr = gnutls_malloc (length32);
dataptr = MHD_gnutls_malloc (length32);
else if (recv_type != GNUTLS_HANDSHAKE_SERVER_HELLO_DONE)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
if (dataptr == NULL && length32 > 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -1200,12 +1200,12 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
if (length32 > 0)
{
ret =
mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
MHD_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
type, dataptr, length32);
if (ret <= 0)
{
gnutls_assert ();
gnutls_free (dataptr);
MHD_gnutls_assert ();
MHD_gnutls_free (dataptr);
return (ret == 0) ? GNUTLS_E_UNEXPECTED_PACKET_LENGTH : ret;
}
}
@@ -1214,7 +1214,7 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
*data = dataptr;
ret = _gnutls_handshake_hash_add_recvd (session, recv_type,
ret = MHD__gnutls_handshake_hash_add_recvd (session, recv_type,
session->internals.
handshake_header_buffer.header,
session->internals.
@@ -1222,8 +1222,8 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
dataptr, length32);
if (ret < 0)
{
gnutls_assert ();
_gnutls_handshake_header_buffer_clear (session);
MHD_gnutls_assert ();
MHD__gnutls_handshake_header_buffer_clear (session);
return ret;
}
@@ -1231,16 +1231,16 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
* have have received above. if we get here the we clear the handshake
* header we received.
*/
_gnutls_handshake_header_buffer_clear (session);
MHD__gnutls_handshake_header_buffer_clear (session);
switch (recv_type)
{
case GNUTLS_HANDSHAKE_CLIENT_HELLO:
case GNUTLS_HANDSHAKE_SERVER_HELLO:
ret = mhd_gtls_recv_hello (session, dataptr, length32);
ret = MHD_gtls_recv_hello (session, dataptr, length32);
/* dataptr is freed because the caller does not
* need it */
gnutls_free (dataptr);
MHD_gnutls_free (dataptr);
if (data != NULL)
*data = NULL;
break;
@@ -1260,8 +1260,8 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
ret = length32;
break;
default:
gnutls_assert ();
gnutls_free (dataptr);
MHD_gnutls_assert ();
MHD_gnutls_free (dataptr);
if (data != NULL)
*data = NULL;
ret = GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET;
@@ -1274,7 +1274,7 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
* to the session;
*/
static int
_gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
MHD__gnutls_client_set_ciphersuite (MHD_gtls_session_t session, opaque suite[2])
{
uint8_t z;
cipher_suite_st *cipher_suites;
@@ -1283,10 +1283,10 @@ _gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
z = 1;
cipher_suite_num =
mhd_gtls_supported_ciphersuites (session, &cipher_suites);
MHD_gtls_supported_ciphersuites (session, &cipher_suites);
if (cipher_suite_num < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return cipher_suite_num;
}
@@ -1299,18 +1299,18 @@ _gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
}
}
gnutls_free (cipher_suites);
MHD_gnutls_free (cipher_suites);
if (z != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_CIPHER_SUITE;
}
memcpy (session->security_parameters.current_cipher_suite.suite, suite, 2);
_gnutls_handshake_log ("HSK[%x]: Selected cipher suite: %s\n", session,
mhd_gtls_cipher_suite_get_name
MHD__gnutls_handshake_log ("HSK[%x]: Selected cipher suite: %s\n", session,
MHD_gtls_cipher_suite_get_name
(&session->security_parameters.
current_cipher_suite));
@@ -1318,33 +1318,33 @@ _gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
/* check if the credentials (username, public key etc.) are ok.
* Actually checks if they exist.
*/
if (mhd_gtls_get_kx_cred
if (MHD_gtls_get_kx_cred
(session,
mhd_gtls_cipher_suite_get_kx_algo
MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.current_cipher_suite), &err) == NULL
&& err != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
/* set the mhd_gtls_mod_auth_st to the appropriate struct
/* set the MHD_gtls_mod_auth_st to the appropriate struct
* according to the KX algorithm. This is needed since all the
* handshake functions are read from there;
*/
session->internals.auth_struct =
mhd_gtls_kx_auth_struct (mhd_gtls_cipher_suite_get_kx_algo
MHD_gtls_kx_auth_struct (MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.
current_cipher_suite));
if (session->internals.auth_struct == NULL)
{
_gnutls_handshake_log
MHD__gnutls_handshake_log
("HSK[%x]: Cannot find the appropriate handler for the KX algorithm\n",
session);
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -1355,18 +1355,18 @@ _gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
/* This function sets the given comp method to the session.
*/
static int
_gnutls_client_set_comp_method (mhd_gtls_session_t session,
MHD__gnutls_client_set_comp_method (MHD_gtls_session_t session,
opaque comp_method)
{
int comp_methods_num;
uint8_t *compression_methods;
int i;
comp_methods_num = mhd_gtls_supported_compression_methods (session,
comp_methods_num = MHD_gtls_supported_compression_methods (session,
&compression_methods);
if (comp_methods_num < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return comp_methods_num;
}
@@ -1379,16 +1379,16 @@ _gnutls_client_set_comp_method (mhd_gtls_session_t session,
}
}
gnutls_free (compression_methods);
MHD_gnutls_free (compression_methods);
if (comp_methods_num != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
session->internals.compression_method =
mhd_gtls_compression_get_id (comp_method);
MHD_gtls_compression_get_id_from_int (comp_method);
return 0;
@@ -1399,15 +1399,15 @@ _gnutls_client_set_comp_method (mhd_gtls_session_t session,
* hello.
*/
static int
_gnutls_client_check_if_resuming (mhd_gtls_session_t session,
MHD__gnutls_client_check_if_resuming (MHD_gtls_session_t session,
opaque * session_id, int session_id_len)
{
opaque buf[2 * TLS_MAX_SESSION_ID_SIZE + 1];
_gnutls_handshake_log ("HSK[%x]: SessionID length: %d\n", session,
MHD__gnutls_handshake_log ("HSK[%x]: SessionID length: %d\n", session,
session_id_len);
_gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
mhd_gtls_bin2hex (session_id, session_id_len, buf,
MHD__gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
MHD_gtls_bin2hex (session_id, session_id_len, buf,
sizeof (buf)));
if (session_id_len > 0 &&
@@ -1444,7 +1444,7 @@ _gnutls_client_check_if_resuming (mhd_gtls_session_t session,
* session.
*/
static int
_gnutls_read_server_hello (mhd_gtls_session_t session,
MHD__gnutls_read_server_hello (MHD_gtls_session_t session,
opaque * data, int datalen)
{
uint8_t session_id_len = 0;
@@ -1455,29 +1455,29 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
if (datalen < 38)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
_gnutls_handshake_log ("HSK[%x]: Server's version: %d.%d\n",
MHD__gnutls_handshake_log ("HSK[%x]: Server's version: %d.%d\n",
session, data[pos], data[pos + 1]);
DECR_LEN (len, 2);
version = mhd_gtls_version_get (data[pos], data[pos + 1]);
if (mhd_gtls_version_is_supported (session, version) == 0)
version = MHD_gtls_version_get (data[pos], data[pos + 1]);
if (MHD_gtls_version_is_supported (session, version) == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;
}
else
{
mhd_gtls_set_current_version (session, version);
MHD_gtls_set_current_version (session, version);
}
pos += 2;
DECR_LEN (len, TLS_RANDOM_SIZE);
mhd_gtls_set_server_random (session, &data[pos]);
MHD_gtls_set_server_random (session, &data[pos]);
pos += TLS_RANDOM_SIZE;
@@ -1488,7 +1488,7 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
if (len < session_id_len)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;
}
DECR_LEN (len, session_id_len);
@@ -1497,7 +1497,7 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
/* check if we are resuming and set the appropriate
* values;
*/
if (_gnutls_client_check_if_resuming
if (MHD__gnutls_client_check_if_resuming
(session, &data[pos], session_id_len) == 0)
return 0;
pos += session_id_len;
@@ -1508,10 +1508,10 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
*/
DECR_LEN (len, 2);
ret = _gnutls_client_set_ciphersuite (session, &data[pos]);
ret = MHD__gnutls_client_set_ciphersuite (session, &data[pos]);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
pos += 2;
@@ -1521,10 +1521,10 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
/* move to compression */
DECR_LEN (len, 1);
ret = _gnutls_client_set_comp_method (session, data[pos++]);
ret = MHD__gnutls_client_set_comp_method (session, data[pos++]);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
}
@@ -1532,10 +1532,10 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
*/
if (version >= MHD_GNUTLS_PROTOCOL_TLS1_0)
{
ret = mhd_gtls_parse_extensions (session, EXTENSION_ANY, &data[pos], len); /* len is the rest of the parsed length */
ret = MHD_gtls_parse_extensions (session, EXTENSION_ANY, &data[pos], len); /* len is the rest of the parsed length */
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
@@ -1547,7 +1547,7 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
* Needed in client hello messages. Returns the new data length.
*/
static int
_gnutls_copy_ciphersuites (mhd_gtls_session_t session,
MHD__gnutls_copy_ciphersuites (MHD_gtls_session_t session,
opaque * ret_data, size_t ret_data_size)
{
int ret, i;
@@ -1555,10 +1555,10 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
uint16_t cipher_num;
int datalen, pos;
ret = mhd_gtls_supported_ciphersuites_sorted (session, &cipher_suites);
ret = MHD_gtls_supported_ciphersuites_sorted (session, &cipher_suites);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -1567,11 +1567,11 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
* authentication requested (eg SRP).
*/
ret =
mhd_gtls_remove_unwanted_ciphersuites (session, &cipher_suites, ret, -1);
MHD_gtls_remove_unwanted_ciphersuites (session, &cipher_suites, ret, -1);
if (ret < 0)
{
gnutls_assert ();
gnutls_free (cipher_suites);
MHD_gnutls_assert ();
MHD_gnutls_free (cipher_suites);
return ret;
}
@@ -1579,8 +1579,8 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
*/
if (ret == 0)
{
gnutls_assert ();
gnutls_free (cipher_suites);
MHD_gnutls_assert ();
MHD_gnutls_free (cipher_suites);
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
@@ -1594,11 +1594,11 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
if ((size_t) datalen > ret_data_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
mhd_gtls_write_uint16 (cipher_num, ret_data);
MHD_gtls_write_uint16 (cipher_num, ret_data);
pos += 2;
for (i = 0; i < (cipher_num / 2); i++)
@@ -1606,7 +1606,7 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
memcpy (&ret_data[pos], cipher_suites[i].suite, 2);
pos += 2;
}
gnutls_free (cipher_suites);
MHD_gnutls_free (cipher_suites);
return datalen;
}
@@ -1615,7 +1615,7 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
* Needed in hello messages. Returns the new data length.
*/
static int
_gnutls_copy_comp_methods (mhd_gtls_session_t session,
MHD__gnutls_copy_comp_methods (MHD_gtls_session_t session,
opaque * ret_data, size_t ret_data_size)
{
int ret, i;
@@ -1623,10 +1623,10 @@ _gnutls_copy_comp_methods (mhd_gtls_session_t session,
int datalen, pos;
ret =
mhd_gtls_supported_compression_methods (session, &compression_methods);
MHD_gtls_supported_compression_methods (session, &compression_methods);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -1637,7 +1637,7 @@ _gnutls_copy_comp_methods (mhd_gtls_session_t session,
if ((size_t) datalen > ret_data_size)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -1648,7 +1648,7 @@ _gnutls_copy_comp_methods (mhd_gtls_session_t session,
ret_data[pos++] = compression_methods[i];
}
gnutls_free (compression_methods);
MHD_gnutls_free (compression_methods);
return datalen;
}
@@ -1662,7 +1662,7 @@ _gnutls_copy_comp_methods (mhd_gtls_session_t session,
/* This function sends the client hello handshake message.
*/
static int
_gnutls_send_client_hello (mhd_gtls_session_t session, int again)
MHD__gnutls_send_client_hello (MHD_gtls_session_t session, int again)
{
opaque *data = NULL;
int extdatalen;
@@ -1689,10 +1689,10 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
/* 2 for version, (4 for unix time + 28 for random bytes==TLS_RANDOM_SIZE)
*/
data = gnutls_malloc (datalen);
data = MHD_gnutls_malloc (datalen);
if (data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -1700,7 +1700,7 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
* version number to the previously established.
*/
if (SessionID == NULL)
hver = mhd_gtls_version_max (session);
hver = MHD_gtls_version_max (session);
else
{ /* we are resuming a session */
hver = session->internals.resumed_security_parameters.version;
@@ -1708,18 +1708,18 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
if (hver == MHD_GNUTLS_PROTOCOL_VERSION_UNKNOWN || hver == 0)
{
gnutls_assert ();
gnutls_free (data);
MHD_gnutls_assert ();
MHD_gnutls_free (data);
return GNUTLS_E_INTERNAL_ERROR;
}
data[pos++] = mhd_gtls_version_get_major (hver);
data[pos++] = mhd_gtls_version_get_minor (hver);
data[pos++] = MHD_gtls_version_get_major (hver);
data[pos++] = MHD_gtls_version_get_minor (hver);
/* Set the version we advertized as maximum
* (RSA uses it).
*/
mhd_gtls_set_adv_version (session, hver);
MHD_gtls_set_adv_version (session, hver);
/* Some old implementations do not interoperate if we send a
* different version in the record layer.
@@ -1729,7 +1729,7 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
* handshake packet and ignore the one in the packet's record
* header.
*/
mhd_gtls_set_current_version (session, hver);
MHD_gtls_set_current_version (session, hver);
/* In order to know when this session was initiated.
*/
@@ -1737,8 +1737,8 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
/* Generate random data
*/
mhd_gtls_tls_create_random (rnd);
mhd_gtls_set_client_random (session, rnd);
MHD_gtls_tls_create_random (rnd);
MHD_gtls_set_client_random (session, rnd);
memcpy (&data[pos], rnd, TLS_RANDOM_SIZE);
pos += TLS_RANDOM_SIZE;
@@ -1756,14 +1756,14 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
/* Copy the ciphersuites.
*/
extdatalen =
_gnutls_copy_ciphersuites (session, extdata, sizeof (extdata));
MHD__gnutls_copy_ciphersuites (session, extdata, sizeof (extdata));
if (extdatalen > 0)
{
datalen += extdatalen;
data = mhd_gtls_realloc_fast (data, datalen);
data = MHD_gtls_realloc_fast (data, datalen);
if (data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -1775,8 +1775,8 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
{
if (extdatalen == 0)
extdatalen = GNUTLS_E_INTERNAL_ERROR;
gnutls_free (data);
gnutls_assert ();
MHD_gnutls_free (data);
MHD_gnutls_assert ();
return extdatalen;
}
@@ -1784,14 +1784,14 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
/* Copy the compression methods.
*/
extdatalen =
_gnutls_copy_comp_methods (session, extdata, sizeof (extdata));
MHD__gnutls_copy_comp_methods (session, extdata, sizeof (extdata));
if (extdatalen > 0)
{
datalen += extdatalen;
data = mhd_gtls_realloc_fast (data, datalen);
data = MHD_gtls_realloc_fast (data, datalen);
if (data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -1803,8 +1803,8 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
{
if (extdatalen == 0)
extdatalen = GNUTLS_E_INTERNAL_ERROR;
gnutls_free (data);
gnutls_assert ();
MHD_gnutls_free (data);
MHD_gnutls_assert ();
return extdatalen;
}
@@ -1813,15 +1813,15 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
if (hver >= MHD_GNUTLS_PROTOCOL_TLS1_0)
{
extdatalen =
mhd_gtls_gen_extensions (session, extdata, sizeof (extdata));
MHD_gtls_gen_extensions (session, extdata, sizeof (extdata));
if (extdatalen > 0)
{
datalen += extdatalen;
data = mhd_gtls_realloc_fast (data, datalen);
data = MHD_gtls_realloc_fast (data, datalen);
if (data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -1829,24 +1829,24 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
}
else if (extdatalen < 0)
{
gnutls_assert ();
gnutls_free (data);
MHD_gnutls_assert ();
MHD_gnutls_free (data);
return extdatalen;
}
}
}
ret =
mhd_gtls_send_handshake (session, data, datalen,
MHD_gtls_send_handshake (session, data, datalen,
GNUTLS_HANDSHAKE_CLIENT_HELLO);
gnutls_free (data);
MHD_gnutls_free (data);
return ret;
}
#endif
static int
_gnutls_send_server_hello (mhd_gtls_session_t session, int again)
MHD__gnutls_send_server_hello (MHD_gtls_session_t session, int again)
{
opaque *data = NULL;
opaque extdata[MAX_EXT_DATA_LENGTH];
@@ -1865,7 +1865,7 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
#ifdef ENABLE_SRP
if (IS_SRP_KX
(mhd_gtls_cipher_suite_get_kx_algo
(MHD_gtls_cipher_suite_get_kx_algo
(&session->security_parameters.current_cipher_suite)))
{
/* While resuming we cannot check the username extension since it is
@@ -1879,12 +1879,12 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
* SRP username. The draft requires that we send a fatal
* alert and abort.
*/
gnutls_assert ();
ret = MHD_gnutls_alert_send (session, GNUTLS_AL_FATAL,
MHD_gnutls_assert ();
ret = MHD__gnutls_alert_send (session, GNUTLS_AL_FATAL,
GNUTLS_A_UNKNOWN_PSK_IDENTITY);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -1897,25 +1897,25 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
{
datalen = 2 + session_id_len + 1 + TLS_RANDOM_SIZE + 3;
extdatalen =
mhd_gtls_gen_extensions (session, extdata, sizeof (extdata));
MHD_gtls_gen_extensions (session, extdata, sizeof (extdata));
if (extdatalen < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return extdatalen;
}
data = gnutls_alloca (datalen + extdatalen);
data = MHD_gnutls_alloca (datalen + extdatalen);
if (data == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
data[pos++] =
mhd_gtls_version_get_major (session->security_parameters.version);
MHD_gtls_version_get_major (session->security_parameters.version);
data[pos++] =
mhd_gtls_version_get_minor (session->security_parameters.version);
MHD_gtls_version_get_minor (session->security_parameters.version);
memcpy (&data[pos],
session->security_parameters.server_random, TLS_RANDOM_SIZE);
@@ -1928,8 +1928,8 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
}
pos += session_id_len;
_gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
mhd_gtls_bin2hex (SessionID, session_id_len,
MHD__gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
MHD_gtls_bin2hex (SessionID, session_id_len,
buf, sizeof (buf)));
memcpy (&data[pos],
@@ -1937,7 +1937,7 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
pos += 2;
comp =
(uint8_t) mhd_gtls_compression_get_num (session->
(uint8_t) MHD_gtls_compression_get_num (session->
internals.compression_method);
data[pos++] = comp;
@@ -1951,47 +1951,47 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
}
ret =
mhd_gtls_send_handshake (session, data, datalen,
MHD_gtls_send_handshake (session, data, datalen,
GNUTLS_HANDSHAKE_SERVER_HELLO);
gnutls_afree (data);
MHD_gnutls_afree (data);
return ret;
}
int
mhd_gtls_send_hello (mhd_gtls_session_t session, int again)
MHD_gtls_send_hello (MHD_gtls_session_t session, int again)
{
int ret;
#if MHD_DEBUG_TLS
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
ret = _gnutls_send_client_hello (session, again);
ret = MHD__gnutls_send_client_hello (session, again);
}
else
#endif
{ /* SERVER */
ret = _gnutls_send_server_hello (session, again);
ret = MHD__gnutls_send_server_hello (session, again);
}
return ret;
}
/* RECEIVE A HELLO MESSAGE. This should be called from gnutls_recv_handshake_int only if a
/* RECEIVE A HELLO MESSAGE. This should be called from MHD_gnutls_recv_handshake_int only if a
* hello message is expected. It uses the security_parameters.current_cipher_suite
* and internals.compression_method.
*/
int
mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
MHD_gtls_recv_hello (MHD_gtls_session_t session, opaque * data, int datalen)
{
int ret;
#if MHD_DEBUG_TLS
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
ret = _gnutls_read_server_hello (session, data, datalen);
ret = MHD__gnutls_read_server_hello (session, data, datalen);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
@@ -1999,10 +1999,10 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
#endif
{ /* Server side reading a client hello */
ret = _gnutls_read_client_hello (session, data, datalen);
ret = MHD__gnutls_read_client_hello (session, data, datalen);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
@@ -2010,7 +2010,7 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
return ret;
}
/* The packets in MHD_gnutls_handshake (it's more broad than original TLS handshake)
/* The packets in MHD__gnutls_handshake (it's more broad than original TLS handshake)
*
* Client Server
*
@@ -2034,8 +2034,8 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
*/
/**
* MHD_gnutls_rehandshake - This function will renegotiate security parameters
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_rehandshake - This function will renegotiate security parameters
* @session: is a #MHD_gtls_session_t structure.
*
* This function will renegotiate security parameters with the
* client. This should only be called in case of a server.
@@ -2044,7 +2044,7 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
* parameters (perform a handshake).
*
* If this function succeeds (returns 0), you must call the
* MHD_gnutls_handshake() function in order to negotiate the new
* MHD__gnutls_handshake() function in order to negotiate the new
* parameters.
*
* If the client does not wish to renegotiate parameters he will
@@ -2057,18 +2057,18 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
*
**/
int
MHD_gnutls_rehandshake (mhd_gtls_session_t session)
MHD__gnutls_rehandshake (MHD_gtls_session_t session)
{
int ret;
ret =
_gnutls_send_empty_handshake (session, GNUTLS_HANDSHAKE_HELLO_REQUEST,
MHD__gnutls_send_empty_handshake (session, GNUTLS_HANDSHAKE_HELLO_REQUEST,
AGAIN (STATE50));
STATE = STATE50;
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
STATE = STATE0;
@@ -2077,10 +2077,10 @@ MHD_gnutls_rehandshake (mhd_gtls_session_t session)
}
inline static int
_gnutls_abort_handshake (mhd_gtls_session_t session, int ret)
MHD__gnutls_abort_handshake (MHD_gtls_session_t session, int ret)
{
if (((ret == GNUTLS_E_WARNING_ALERT_RECEIVED) &&
(gnutls_alert_get (session) == GNUTLS_A_NO_RENEGOTIATION))
(MHD_gnutls_alert_get (session) == GNUTLS_A_NO_RENEGOTIATION))
|| ret == GNUTLS_E_GOT_APPLICATION_DATA)
return 0;
@@ -2092,17 +2092,17 @@ _gnutls_abort_handshake (mhd_gtls_session_t session, int ret)
* required for finished messages.
*/
inline static int
_gnutls_handshake_hash_init (mhd_gtls_session_t session)
MHD__gnutls_handshake_hash_init (MHD_gtls_session_t session)
{
if (session->internals.handshake_mac_handle_md5 == NULL)
{
session->internals.handshake_mac_handle_md5 =
mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
MHD_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
if (session->internals.handshake_mac_handle_md5 == GNUTLS_HASH_FAILED)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
}
@@ -2110,10 +2110,10 @@ _gnutls_handshake_hash_init (mhd_gtls_session_t session)
if (session->internals.handshake_mac_handle_sha == NULL)
{
session->internals.handshake_mac_handle_sha =
mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (session->internals.handshake_mac_handle_sha == GNUTLS_HASH_FAILED)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
}
@@ -2122,68 +2122,68 @@ _gnutls_handshake_hash_init (mhd_gtls_session_t session)
}
static int
_gnutls_send_supplemental (mhd_gtls_session_t session, int again)
MHD__gnutls_send_supplemental (MHD_gtls_session_t session, int again)
{
int ret = 0;
_gnutls_debug_log ("EXT[%x]: Sending supplemental data\n", session);
MHD__gnutls_debug_log ("EXT[%x]: Sending supplemental data\n", session);
if (again)
ret = mhd_gtls_send_handshake (session, NULL, 0,
ret = MHD_gtls_send_handshake (session, NULL, 0,
GNUTLS_HANDSHAKE_SUPPLEMENTAL);
else
{
mhd_gtls_buffer buf;
mhd_gtls_buffer_init (&buf);
MHD_gtls_buffer buf;
MHD_gtls_buffer_init (&buf);
ret = _gnutls_gen_supplemental (session, &buf);
ret = MHD__gnutls_gen_supplemental (session, &buf);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret = mhd_gtls_send_handshake (session, buf.data, buf.length,
ret = MHD_gtls_send_handshake (session, buf.data, buf.length,
GNUTLS_HANDSHAKE_SUPPLEMENTAL);
mhd_gtls_buffer_clear (&buf);
MHD_gtls_buffer_clear (&buf);
}
return ret;
}
static int
_gnutls_recv_supplemental (mhd_gtls_session_t session)
MHD__gnutls_recv_supplemental (MHD_gtls_session_t session)
{
uint8_t *data = NULL;
int datalen = 0;
int ret;
_gnutls_debug_log ("EXT[%x]: Expecting supplemental data\n", session);
MHD__gnutls_debug_log ("EXT[%x]: Expecting supplemental data\n", session);
ret = mhd_gtls_recv_handshake (session, &data, &datalen,
ret = MHD_gtls_recv_handshake (session, &data, &datalen,
GNUTLS_HANDSHAKE_SUPPLEMENTAL,
OPTIONAL_PACKET);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret = _gnutls_parse_supplemental (session, data, datalen);
ret = MHD__gnutls_parse_supplemental (session, data, datalen);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
gnutls_free (data);
MHD_gnutls_free (data);
return ret;
}
/**
* MHD_gnutls_handshake - This is the main function in the handshake protocol.
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_handshake - This is the main function in the handshake protocol.
* @session: is a #MHD_gtls_session_t structure.
*
* This function does the handshake of the TLS/SSL protocol, and
* initializes the TLS connection.
@@ -2196,7 +2196,7 @@ _gnutls_recv_supplemental (mhd_gtls_session_t session)
* The non-fatal errors such as %GNUTLS_E_AGAIN and
* %GNUTLS_E_INTERRUPTED interrupt the handshake procedure, which
* should be later be resumed. Call this function again, until it
* returns 0; cf. MHD_gnutls_record_get_direction() and
* returns 0; cf. MHD__gnutls_record_get_direction() and
* MHD_gtls_error_is_fatal().
*
* If this function is called by a server after a rehandshake request
@@ -2209,24 +2209,24 @@ _gnutls_recv_supplemental (mhd_gtls_session_t session)
*
**/
int
MHD_gnutls_handshake (mhd_gtls_session_t session)
MHD__gnutls_handshake (MHD_gtls_session_t session)
{
int ret;
if ((ret = _gnutls_handshake_hash_init (session)) < 0)
if ((ret = MHD__gnutls_handshake_hash_init (session)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
#if MHD_DEBUG_TLS
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
ret = mhd_gtls_handshake_client (session);
ret = MHD_gtls_handshake_client (session);
}
else
#endif
{
ret = mhd_gtls_handshake_server (session);
ret = MHD_gtls_handshake_server (session);
}
if (ret < 0)
@@ -2234,17 +2234,17 @@ MHD_gnutls_handshake (mhd_gtls_session_t session)
/* In the case of a rehandshake abort
* we should reset the handshake's internal state.
*/
if (_gnutls_abort_handshake (session, ret) == 0)
if (MHD__gnutls_abort_handshake (session, ret) == 0)
STATE = STATE0;
return ret;
}
ret = mhd_gtls_handshake_common (session);
ret = MHD_gtls_handshake_common (session);
if (ret < 0)
{
if (_gnutls_abort_handshake (session, ret) == 0)
if (MHD__gnutls_abort_handshake (session, ret) == 0)
STATE = STATE0;
return ret;
@@ -2252,8 +2252,8 @@ MHD_gnutls_handshake (mhd_gtls_session_t session)
STATE = STATE0;
_gnutls_handshake_io_buffer_clear (session);
mhd_gtls_handshake_internal_state_clear (session);
MHD__gnutls_handshake_io_buffer_clear (session);
MHD_gtls_handshake_internal_state_clear (session);
return 0;
}
@@ -2261,20 +2261,20 @@ MHD_gnutls_handshake (mhd_gtls_session_t session)
#define IMED_RET( str, ret) do { \
if (ret < 0) { \
if (MHD_gtls_error_is_fatal(ret)==0) return ret; \
gnutls_assert(); \
MHD_gnutls_assert(); \
ERR( str, ret); \
_gnutls_handshake_hash_buffers_clear(session); \
MHD__gnutls_handshake_hash_buffers_clear(session); \
return ret; \
} } while (0)
#if MHD_DEBUG_TLS
/*
* mhd_gtls_handshake_client
* MHD_gtls_handshake_client
* This function performs the client side of the handshake of the TLS/SSL protocol.
*/
int
mhd_gtls_handshake_client (mhd_gtls_session_t session)
MHD_gtls_handshake_client (MHD_gtls_session_t session)
{
int ret = 0;
@@ -2282,8 +2282,8 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
char buf[64];
if (session->internals.resumed_security_parameters.session_id_size > 0)
_gnutls_handshake_log ("HSK[%x]: Ask to resume: %s\n", session,
mhd_gtls_bin2hex (session->internals.
MHD__gnutls_handshake_log ("HSK[%x]: Ask to resume: %s\n", session,
MHD_gtls_bin2hex (session->internals.
resumed_security_parameters.
session_id,
session->internals.
@@ -2296,14 +2296,14 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
{
case STATE0:
case STATE1:
ret = mhd_gtls_send_hello (session, AGAIN (STATE1));
ret = MHD_gtls_send_hello (session, AGAIN (STATE1));
STATE = STATE1;
IMED_RET ("send hello", ret);
case STATE2:
/* receive the server hello */
ret =
mhd_gtls_recv_handshake (session, NULL, NULL,
MHD_gtls_recv_handshake (session, NULL, NULL,
GNUTLS_HANDSHAKE_SERVER_HELLO,
MANDATORY_PACKET);
STATE = STATE2;
@@ -2312,7 +2312,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
case STATE70:
if (session->security_parameters.extensions.do_recv_supplemental)
{
ret = _gnutls_recv_supplemental (session);
ret = MHD__gnutls_recv_supplemental (session);
STATE = STATE70;
IMED_RET ("recv supplemental", ret);
}
@@ -2320,14 +2320,14 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
case STATE3:
/* RECV CERTIFICATE */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret = mhd_gtls_recv_server_certificate (session);
ret = MHD_gtls_recv_server_certificate (session);
STATE = STATE3;
IMED_RET ("recv server certificate", ret);
case STATE4:
/* receive the server key exchange */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret = mhd_gtls_recv_server_kx_message (session);
ret = MHD_gtls_recv_server_kx_message (session);
STATE = STATE4;
IMED_RET ("recv server kx message", ret);
@@ -2336,7 +2336,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
*/
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret = mhd_gtls_recv_server_certificate_request (session);
ret = MHD_gtls_recv_server_certificate_request (session);
STATE = STATE5;
IMED_RET ("recv server certificate request message", ret);
@@ -2344,7 +2344,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
/* receive the server hello done */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret =
mhd_gtls_recv_handshake (session, NULL, NULL,
MHD_gtls_recv_handshake (session, NULL, NULL,
GNUTLS_HANDSHAKE_SERVER_HELLO_DONE,
MANDATORY_PACKET);
STATE = STATE6;
@@ -2353,7 +2353,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
case STATE71:
if (session->security_parameters.extensions.do_send_supplemental)
{
ret = _gnutls_send_supplemental (session, AGAIN (STATE71));
ret = MHD__gnutls_send_supplemental (session, AGAIN (STATE71));
STATE = STATE71;
IMED_RET ("send supplemental", ret);
}
@@ -2362,13 +2362,13 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
/* send our certificate - if any and if requested
*/
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret = mhd_gtls_send_client_certificate (session, AGAIN (STATE7));
ret = MHD_gtls_send_client_certificate (session, AGAIN (STATE7));
STATE = STATE7;
IMED_RET ("send client certificate", ret);
case STATE8:
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret = mhd_gtls_send_client_kx_message (session, AGAIN (STATE8));
ret = MHD_gtls_send_client_kx_message (session, AGAIN (STATE8));
STATE = STATE8;
IMED_RET ("send client kx", ret);
@@ -2376,7 +2376,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
/* send client certificate verify */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret =
mhd_gtls_send_client_certificate_verify (session, AGAIN (STATE9));
MHD_gtls_send_client_certificate_verify (session, AGAIN (STATE9));
STATE = STATE9;
IMED_RET ("send client certificate verify", ret);
@@ -2393,7 +2393,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
/* This function sends the final handshake packets and initializes connection
*/
static int
_gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
MHD__gnutls_send_handshake_final (MHD_gtls_session_t session, int init)
{
int ret = 0;
@@ -2403,12 +2403,12 @@ _gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
{
case STATE0:
case STATE20:
ret = mhd_gtls_send_change_cipher_spec (session, AGAIN (STATE20));
ret = MHD_gtls_send_change_cipher_spec (session, AGAIN (STATE20));
STATE = STATE20;
if (ret < 0)
{
ERR ("send ChangeCipherSpec", ret);
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -2416,29 +2416,29 @@ _gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
*/
if (init == TRUE)
{
ret = mhd_gtls_connection_state_init (session);
ret = MHD_gtls_connection_state_init (session);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
ret = mhd_gtls_write_connection_state_init (session);
ret = MHD_gtls_write_connection_state_init (session);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
case STATE21:
/* send the finished message */
ret = _gnutls_send_finished (session, AGAIN (STATE21));
ret = MHD__gnutls_send_finished (session, AGAIN (STATE21));
STATE = STATE21;
if (ret < 0)
{
ERR ("send Finished", ret);
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -2455,7 +2455,7 @@ _gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
* read session.
*/
static int
_gnutls_recv_handshake_final (mhd_gtls_session_t session, int init)
MHD__gnutls_recv_handshake_final (MHD_gtls_session_t session, int init)
{
int ret = 0;
uint8_t ch;
@@ -2465,40 +2465,40 @@ _gnutls_recv_handshake_final (mhd_gtls_session_t session, int init)
case STATE0:
case STATE30:
ret =
mhd_gtls_recv_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, &ch, 1);
MHD_gtls_recv_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, &ch, 1);
STATE = STATE30;
if (ret <= 0)
{
ERR ("recv ChangeCipherSpec", ret);
gnutls_assert ();
MHD_gnutls_assert ();
return (ret < 0) ? ret : GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
/* Initialize the connection session (start encryption) - in case of server */
if (init == TRUE)
{
ret = mhd_gtls_connection_state_init (session);
ret = MHD_gtls_connection_state_init (session);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
ret = mhd_gtls_read_connection_state_init (session);
ret = MHD_gtls_read_connection_state_init (session);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
case STATE31:
ret = _gnutls_recv_finished (session);
ret = MHD__gnutls_recv_finished (session);
STATE = STATE31;
if (ret < 0)
{
ERR ("recv finished", ret);
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
STATE = STATE0;
@@ -2511,12 +2511,12 @@ _gnutls_recv_handshake_final (mhd_gtls_session_t session, int init)
}
/*
* mhd_gtls_handshake_server
* MHD_gtls_handshake_server
* This function does the server stuff of the handshake protocol.
*/
int
mhd_gtls_handshake_server (mhd_gtls_session_t session)
MHD_gtls_handshake_server (MHD_gtls_session_t session)
{
int ret = 0;
@@ -2525,21 +2525,21 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
case STATE0:
case STATE1:
ret =
mhd_gtls_recv_handshake (session, NULL, NULL,
MHD_gtls_recv_handshake (session, NULL, NULL,
GNUTLS_HANDSHAKE_CLIENT_HELLO,
MANDATORY_PACKET);
STATE = STATE1;
IMED_RET ("recv hello", ret);
case STATE2:
ret = mhd_gtls_send_hello (session, AGAIN (STATE2));
ret = MHD_gtls_send_hello (session, AGAIN (STATE2));
STATE = STATE2;
IMED_RET ("send hello", ret);
case STATE70:
if (session->security_parameters.extensions.do_send_supplemental)
{
ret = _gnutls_send_supplemental (session, AGAIN (STATE70));
ret = MHD__gnutls_send_supplemental (session, AGAIN (STATE70));
STATE = STATE70;
IMED_RET ("send supplemental data", ret);
}
@@ -2549,14 +2549,14 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
/* NOTE: these should not be send if we are resuming */
if (session->internals.resumed == RESUME_FALSE)
ret = mhd_gtls_send_server_certificate (session, AGAIN (STATE3));
ret = MHD_gtls_send_server_certificate (session, AGAIN (STATE3));
STATE = STATE3;
IMED_RET ("send server certificate", ret);
case STATE4:
/* send server key exchange (A) */
if (session->internals.resumed == RESUME_FALSE)
ret = mhd_gtls_send_server_kx_message (session, AGAIN (STATE4));
ret = MHD_gtls_send_server_kx_message (session, AGAIN (STATE4));
STATE = STATE4;
IMED_RET ("send server kx", ret);
@@ -2564,7 +2564,7 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
/* Send certificate request - if requested to */
if (session->internals.resumed == RESUME_FALSE)
ret =
mhd_gtls_send_server_certificate_request (session, AGAIN (STATE5));
MHD_gtls_send_server_certificate_request (session, AGAIN (STATE5));
STATE = STATE5;
IMED_RET ("send server cert request", ret);
@@ -2572,7 +2572,7 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
/* send the server hello done */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret =
_gnutls_send_empty_handshake (session,
MHD__gnutls_send_empty_handshake (session,
GNUTLS_HANDSHAKE_SERVER_HELLO_DONE,
AGAIN (STATE6));
STATE = STATE6;
@@ -2581,7 +2581,7 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
case STATE71:
if (session->security_parameters.extensions.do_recv_supplemental)
{
ret = _gnutls_recv_supplemental (session);
ret = MHD__gnutls_recv_supplemental (session);
STATE = STATE71;
IMED_RET ("recv client supplemental", ret);
}
@@ -2590,21 +2590,21 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
case STATE7:
/* receive the client certificate message */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret = mhd_gtls_recv_client_certificate (session);
ret = MHD_gtls_recv_client_certificate (session);
STATE = STATE7;
IMED_RET ("recv client certificate", ret);
case STATE8:
/* receive the client key exchange message */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret = mhd_gtls_recv_client_kx_message (session);
ret = MHD_gtls_recv_client_kx_message (session);
STATE = STATE8;
IMED_RET ("recv client kx", ret);
case STATE9:
/* receive the client certificate verify message */
if (session->internals.resumed == RESUME_FALSE) /* if we are not resuming */
ret = mhd_gtls_recv_client_certificate_verify_message (session);
ret = MHD_gtls_recv_client_certificate_verify_message (session);
STATE = STATE9;
IMED_RET ("recv client certificate verify", ret);
@@ -2617,7 +2617,7 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
}
int
mhd_gtls_handshake_common (mhd_gtls_session_t session)
MHD_gtls_handshake_common (MHD_gtls_session_t session)
{
int ret = 0;
@@ -2629,36 +2629,36 @@ mhd_gtls_handshake_common (mhd_gtls_session_t session)
{
/* if we are a client resuming - or we are a server not resuming */
ret = _gnutls_recv_handshake_final (session, TRUE);
ret = MHD__gnutls_recv_handshake_final (session, TRUE);
IMED_RET ("recv handshake final", ret);
ret = _gnutls_send_handshake_final (session, FALSE);
ret = MHD__gnutls_send_handshake_final (session, FALSE);
IMED_RET ("send handshake final", ret);
}
else
{ /* if we are a client not resuming - or we are a server resuming */
ret = _gnutls_send_handshake_final (session, TRUE);
ret = MHD__gnutls_send_handshake_final (session, TRUE);
IMED_RET ("send handshake final 2", ret);
ret = _gnutls_recv_handshake_final (session, FALSE);
ret = MHD__gnutls_recv_handshake_final (session, FALSE);
IMED_RET ("recv handshake final 2", ret);
}
/* clear handshake buffer */
_gnutls_handshake_hash_buffers_clear (session);
MHD__gnutls_handshake_hash_buffers_clear (session);
return ret;
}
int
mhd_gtls_generate_session_id (opaque * session_id, uint8_t * len)
MHD_gtls_generate_session_id (opaque * session_id, uint8_t * len)
{
*len = TLS_MAX_SESSION_ID_SIZE;
if (gc_nonce (session_id, *len) != GC_OK)
if (MHD_gc_nonce (session_id, *len) != GC_OK)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_RANDOM_FAILED;
}
@@ -2666,19 +2666,19 @@ mhd_gtls_generate_session_id (opaque * session_id, uint8_t * len)
}
int
mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
MHD_gtls_recv_hello_request (MHD_gtls_session_t session, void *data,
uint32_t data_size)
{
uint8_t type;
if (session->security_parameters.entity == GNUTLS_SERVER)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET;
}
if (data_size < 1)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
type = ((uint8_t *) data)[0];
@@ -2686,7 +2686,7 @@ mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
return GNUTLS_E_REHANDSHAKE;
else
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET;
}
}
@@ -2695,33 +2695,33 @@ mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
* (DH or RSA) set up. Otherwise returns 0.
*/
inline static int
check_server_params (mhd_gtls_session_t session,
check_server_params (MHD_gtls_session_t session,
enum MHD_GNUTLS_KeyExchangeAlgorithm kx,
enum MHD_GNUTLS_KeyExchangeAlgorithm *alg, int alg_size)
{
int cred_type;
mhd_gtls_dh_params_t dh_params = NULL;
mhd_gtls_rsa_params_t rsa_params = NULL;
MHD_gtls_dh_params_t dh_params = NULL;
MHD_gtls_rsa_params_t rsa_params = NULL;
int j;
cred_type = mhd_gtls_map_kx_get_cred (kx, 1);
cred_type = MHD_gtls_map_kx_get_cred (kx, 1);
/* Read the Diffie Hellman parameters, if any.
*/
if (cred_type == MHD_GNUTLS_CRD_CERTIFICATE)
{
int delete;
mhd_gtls_cert_credentials_t x509_cred =
(mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
MHD_gtls_cert_credentials_t x509_cred =
(MHD_gtls_cert_credentials_t) MHD_gtls_get_cred (session->key,
cred_type, NULL);
if (x509_cred != NULL)
{
dh_params =
mhd_gtls_get_dh_params (x509_cred->dh_params,
MHD_gtls_get_dh_params (x509_cred->dh_params,
x509_cred->params_func, session);
rsa_params =
mhd_gtls_certificate_get_rsa_params (x509_cred->rsa_params,
MHD_gtls_certificate_get_rsa_params (x509_cred->rsa_params,
x509_cred->params_func,
session);
}
@@ -2746,15 +2746,15 @@ check_server_params (mhd_gtls_session_t session,
}
else if (cred_type == MHD_GNUTLS_CRD_ANON)
{
mhd_gtls_anon_server_credentials_t anon_cred =
(mhd_gtls_anon_server_credentials_t) mhd_gtls_get_cred (session->key,
MHD_gtls_anon_server_credentials_t anon_cred =
(MHD_gtls_anon_server_credentials_t) MHD_gtls_get_cred (session->key,
cred_type,
NULL);
if (anon_cred != NULL)
{
dh_params =
mhd_gtls_get_dh_params (anon_cred->dh_params,
MHD_gtls_get_dh_params (anon_cred->dh_params,
anon_cred->params_func, session);
}
#endif
@@ -2762,14 +2762,14 @@ check_server_params (mhd_gtls_session_t session,
}
else if (cred_type == MHD_GNUTLS_CRD_PSK)
{
gnutls_psk_server_credentials_t psk_cred =
(gnutls_psk_server_credentials_t) mhd_gtls_get_cred (session->key,
MHD_gnutls_psk_server_credentials_t psk_cred =
(MHD_gnutls_psk_server_credentials_t) MHD_gtls_get_cred (session->key,
cred_type, NULL);
if (psk_cred != NULL)
{
dh_params =
mhd_gtls_get_dh_params (psk_cred->dh_params,
MHD_gtls_get_dh_params (psk_cred->dh_params,
psk_cred->params_func, session);
}
#endif
@@ -2781,22 +2781,22 @@ check_server_params (mhd_gtls_session_t session,
/* If the key exchange method needs RSA or DH params,
* but they are not set then remove it.
*/
if (mhd_gtls_kx_needs_rsa_params (kx) != 0)
if (MHD_gtls_kx_needs_rsa_params (kx) != 0)
{
/* needs rsa params. */
if (_gnutls_rsa_params_to_mpi (rsa_params) == NULL)
if (MHD__gnutls_rsa_params_to_mpi (rsa_params) == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return 1;
}
}
if (mhd_gtls_kx_needs_dh_params (kx) != 0)
if (MHD_gtls_kx_needs_dh_params (kx) != 0)
{
/* needs DH params. */
if (mhd_gtls_dh_params_to_mpi (dh_params) == NULL)
if (MHD_gtls_dh_params_to_mpi (dh_params) == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return 1;
}
}
@@ -2808,11 +2808,11 @@ check_server_params (mhd_gtls_session_t session,
* the requested authentication method. We remove an algorithm if
* we have a certificate with keyUsage bits set.
*
* This does a more high level check than gnutls_supported_ciphersuites(),
* This does a more high level check than MHD_gnutls_supported_ciphersuites(),
* by checking certificates etc.
*/
int
mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
MHD_gtls_remove_unwanted_ciphersuites (MHD_gtls_session_t session,
cipher_suite_st ** cipherSuites,
int numCipherSuites,
enum MHD_GNUTLS_PublicKeyAlgorithm
@@ -2822,7 +2822,7 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
int ret = 0;
cipher_suite_st *newSuite, cs;
int newSuiteSize = 0, i;
mhd_gtls_cert_credentials_t cert_cred;
MHD_gtls_cert_credentials_t cert_cred;
enum MHD_GNUTLS_KeyExchangeAlgorithm kx;
int server = session->security_parameters.entity == GNUTLS_SERVER ? 1 : 0;
enum MHD_GNUTLS_KeyExchangeAlgorithm *alg = NULL;
@@ -2835,7 +2835,7 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
*/
cert_cred =
(mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
(MHD_gtls_cert_credentials_t) MHD_gtls_get_cred (session->key,
MHD_GNUTLS_CRD_CERTIFICATE,
NULL);
@@ -2845,11 +2845,11 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
if (session->security_parameters.entity == GNUTLS_SERVER
&& cert_cred != NULL)
{
ret = mhd_gtls_server_select_cert (session, requested_pk_algo);
ret = MHD_gtls_server_select_cert (session, requested_pk_algo);
if (ret < 0)
{
gnutls_assert ();
_gnutls_x509_log ("Could not find an appropriate certificate: %s\n",
MHD_gnutls_assert ();
MHD__gnutls_x509_log ("Could not find an appropriate certificate: %s\n",
MHD_gtls_strerror (ret));
cert_cred = NULL;
}
@@ -2859,17 +2859,17 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
* supported by the X509 certificate parameters.
*/
if ((ret =
mhd_gtls_selected_cert_supported_kx (session, &alg, &alg_size)) < 0)
MHD_gtls_selected_cert_supported_kx (session, &alg, &alg_size)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
newSuite = gnutls_malloc (numCipherSuites * sizeof (cipher_suite_st));
newSuite = MHD_gnutls_malloc (numCipherSuites * sizeof (cipher_suite_st));
if (newSuite == NULL)
{
gnutls_assert ();
gnutls_free (alg);
MHD_gnutls_assert ();
MHD_gnutls_free (alg);
return GNUTLS_E_MEMORY_ERROR;
}
@@ -2882,11 +2882,11 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
/* finds the key exchange algorithm in
* the ciphersuite
*/
kx = mhd_gtls_cipher_suite_get_kx_algo (&(*cipherSuites)[i]);
kx = MHD_gtls_cipher_suite_get_kx_algo (&(*cipherSuites)[i]);
/* if it is defined but had no credentials
*/
if (mhd_gtls_get_kx_cred (session, kx, NULL) == NULL)
if (MHD_gtls_get_kx_cred (session, kx, NULL) == NULL)
{
delete = 1;
}
@@ -2899,12 +2899,12 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
}
/* These two SRP kx's are marked to require a CRD_CERTIFICATE,
(see cred_mappings in gnutls_algorithms.c), but it also
(see cred_mappings in MHD_gnutls_algorithms.c), but it also
requires a SRP credential. Don't use SRP kx unless we have a
SRP credential too. */
if (kx == MHD_GNUTLS_KX_SRP_RSA || kx == MHD_GNUTLS_KX_SRP_DSS)
{
if (!mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_SRP, NULL))
if (!MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_SRP, NULL))
delete = 1;
}
@@ -2913,24 +2913,24 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
if (delete == 0)
{
_gnutls_handshake_log ("HSK[%x]: Keeping ciphersuite: %s\n",
MHD__gnutls_handshake_log ("HSK[%x]: Keeping ciphersuite: %s\n",
session,
mhd_gtls_cipher_suite_get_name (&cs));
MHD_gtls_cipher_suite_get_name (&cs));
memcpy (newSuite[newSuiteSize].suite, (*cipherSuites)[i].suite, 2);
newSuiteSize++;
}
else
{
_gnutls_handshake_log ("HSK[%x]: Removing ciphersuite: %s\n",
MHD__gnutls_handshake_log ("HSK[%x]: Removing ciphersuite: %s\n",
session,
mhd_gtls_cipher_suite_get_name (&cs));
MHD_gtls_cipher_suite_get_name (&cs));
}
}
gnutls_free (alg);
gnutls_free (*cipherSuites);
MHD_gnutls_free (alg);
MHD_gnutls_free (*cipherSuites);
*cipherSuites = newSuite;
ret = newSuiteSize;
@@ -2940,8 +2940,8 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
}
/**
* MHD_gnutls_handshake_set_max_packet_length - This function will set the maximum length of a handshake message
* @session: is a #mhd_gtls_session_t structure.
* MHD__gnutls_handshake_set_max_packet_length - This function will set the maximum length of a handshake message
* @session: is a #MHD_gtls_session_t structure.
* @max: is the maximum number.
*
* This function will set the maximum size of a handshake message.
@@ -2951,63 +2951,63 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
*
**/
void
MHD_gnutls_handshake_set_max_packet_length (mhd_gtls_session_t session,
MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session,
size_t max)
{
session->internals.max_handshake_data_buffer_size = max;
}
void
mhd_gtls_set_adv_version (mhd_gtls_session_t session,
MHD_gtls_set_adv_version (MHD_gtls_session_t session,
enum MHD_GNUTLS_Protocol ver)
{
set_adv_version (session, mhd_gtls_version_get_major (ver),
mhd_gtls_version_get_minor (ver));
set_adv_version (session, MHD_gtls_version_get_major (ver),
MHD_gtls_version_get_minor (ver));
}
enum MHD_GNUTLS_Protocol
mhd_gtls_get_adv_version (mhd_gtls_session_t session)
MHD_gtls_get_adv_version (MHD_gtls_session_t session)
{
return mhd_gtls_version_get (_gnutls_get_adv_version_major (session),
_gnutls_get_adv_version_minor (session));
return MHD_gtls_version_get (MHD__gnutls_get_adv_version_major (session),
MHD__gnutls_get_adv_version_minor (session));
}
/**
* MHD_gtls_handshake_get_last_in - Returns the last handshake message received.
* @session: is a #mhd_gtls_session_t structure.
* @session: is a #MHD_gtls_session_t structure.
*
* This function is only useful to check where the last performed
* handshake failed. If the previous handshake succeed or was not
* performed at all then no meaningful value will be returned.
*
* Check %gnutls_handshake_description_t in gnutls.h for the
* Check %MHD_gnutls_handshake_description_t in gnutls.h for the
* available handshake descriptions.
*
* Returns: the last handshake message type received, a
* %gnutls_handshake_description_t.
* %MHD_gnutls_handshake_description_t.
**/
gnutls_handshake_description_t
MHD_gtls_handshake_get_last_in (mhd_gtls_session_t session)
MHD_gnutls_handshake_description_t
MHD_gtls_handshake_get_last_in (MHD_gtls_session_t session)
{
return session->internals.last_handshake_in;
}
/**
* MHD_gtls_handshake_get_last_out - Returns the last handshake message sent.
* @session: is a #mhd_gtls_session_t structure.
* @session: is a #MHD_gtls_session_t structure.
*
* This function is only useful to check where the last performed
* handshake failed. If the previous handshake succeed or was not
* performed at all then no meaningful value will be returned.
*
* Check %gnutls_handshake_description_t in gnutls.h for the
* Check %MHD_gnutls_handshake_description_t in gnutls.h for the
* available handshake descriptions.
*
* Returns: the last handshake message type sent, a
* %gnutls_handshake_description_t.
* %MHD_gnutls_handshake_description_t.
**/
gnutls_handshake_description_t
MHD_gtls_handshake_get_last_out (mhd_gtls_session_t session)
MHD_gnutls_handshake_description_t
MHD_gtls_handshake_get_last_out (MHD_gtls_session_t session)
{
return session->internals.last_handshake_out;
}
src/daemon/https/tls/gnutls_handshake.h
+19 -19
View File
@@ -25,39 +25,39 @@
typedef enum Optional
{ OPTIONAL_PACKET, MANDATORY_PACKET } Optional;
int mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
int MHD_gtls_send_handshake (MHD_gtls_session_t session, void *i_data,
uint32_t i_datasize,
gnutls_handshake_description_t type);
int mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
MHD_gnutls_handshake_description_t type);
int MHD_gtls_recv_hello_request (MHD_gtls_session_t session, void *data,
uint32_t data_size);
int mhd_gtls_send_hello (mhd_gtls_session_t session, int again);
int mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data,
int MHD_gtls_send_hello (MHD_gtls_session_t session, int again);
int MHD_gtls_recv_hello (MHD_gtls_session_t session, opaque * data,
int datalen);
int mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t **, int *,
gnutls_handshake_description_t,
int MHD_gtls_recv_handshake (MHD_gtls_session_t session, uint8_t **, int *,
MHD_gnutls_handshake_description_t,
Optional optional);
int mhd_gtls_generate_session_id (opaque * session_id, uint8_t * len);
int mhd_gtls_handshake_common (mhd_gtls_session_t session);
int mhd_gtls_handshake_server (mhd_gtls_session_t session);
void mhd_gtls_set_server_random (mhd_gtls_session_t session, uint8_t * rnd);
void mhd_gtls_set_client_random (mhd_gtls_session_t session, uint8_t * rnd);
int mhd_gtls_tls_create_random (opaque * dst);
int mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
int MHD_gtls_generate_session_id (opaque * session_id, uint8_t * len);
int MHD_gtls_handshake_common (MHD_gtls_session_t session);
int MHD_gtls_handshake_server (MHD_gtls_session_t session);
void MHD_gtls_set_server_random (MHD_gtls_session_t session, uint8_t * rnd);
void MHD_gtls_set_client_random (MHD_gtls_session_t session, uint8_t * rnd);
int MHD_gtls_tls_create_random (opaque * dst);
int MHD_gtls_remove_unwanted_ciphersuites (MHD_gtls_session_t session,
cipher_suite_st ** cipherSuites,
int numCipherSuites,
enum
MHD_GNUTLS_PublicKeyAlgorithm);
int mhd_gtls_find_pk_algos_in_ciphersuites (opaque * data, int datalen);
int mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
int MHD_gtls_find_pk_algos_in_ciphersuites (opaque * data, int datalen);
int MHD_gtls_server_select_suite (MHD_gtls_session_t session, opaque * data,
int datalen);
int mhd_gtls_negotiate_version (mhd_gtls_session_t session,
int MHD_gtls_negotiate_version (MHD_gtls_session_t session,
enum MHD_GNUTLS_Protocol adv_version);
int mhd_gtls_user_hello_func (mhd_gtls_session_t,
int MHD_gtls_user_hello_func (MHD_gtls_session_t,
enum MHD_GNUTLS_Protocol adv_version);
#if MHD_DEBUG_TLS
int mhd_gtls_handshake_client (mhd_gtls_session_t session);
int MHD_gtls_handshake_client (MHD_gtls_session_t session);
#endif
#define STATE session->internals.handshake_state
src/daemon/https/tls/gnutls_hash_int.c
+81 -81
View File
@@ -31,7 +31,7 @@
#include <gnutls_errors.h>
static inline Gc_hash
_gnutls_mac2gc (enum MHD_GNUTLS_HashAlgorithm mac)
MHD__gnutls_mac2gc (enum MHD_GNUTLS_HashAlgorithm mac)
{
switch (mac)
{
@@ -48,32 +48,32 @@ _gnutls_mac2gc (enum MHD_GNUTLS_HashAlgorithm mac)
return GC_MD5;
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return -1;
}
return -1;
}
GNUTLS_HASH_HANDLE
mhd_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm algorithm)
MHD_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm algorithm)
{
mac_hd_t ret;
int result;
ret = gnutls_malloc (sizeof (mac_hd_st));
ret = MHD_gnutls_malloc (sizeof (mac_hd_st));
if (ret == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_HASH_FAILED;
}
ret->algorithm = algorithm;
result = gc_hash_open (_gnutls_mac2gc (algorithm), 0, &ret->handle);
result = MHD_gc_hash_open (MHD__gnutls_mac2gc (algorithm), 0, &ret->handle);
if (result)
{
gnutls_assert ();
gnutls_free (ret);
MHD_gnutls_assert ();
MHD_gnutls_free (ret);
ret = GNUTLS_HASH_FAILED;
}
@@ -81,31 +81,31 @@ mhd_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm algorithm)
}
int
mhd_gnutls_hash_get_algo_len (enum MHD_GNUTLS_HashAlgorithm algorithm)
MHD_gnutls_hash_get_algo_len (enum MHD_GNUTLS_HashAlgorithm algorithm)
{
int ret;
ret = gc_hash_digest_length (_gnutls_mac2gc (algorithm));
ret = MHD_gc_hash_digest_length (MHD__gnutls_mac2gc (algorithm));
return ret;
}
int
mhd_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
MHD_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
{
if (textlen > 0)
gc_hash_write (handle->handle, textlen, text);
MHD_gc_hash_write (handle->handle, textlen, text);
return 0;
}
GNUTLS_HASH_HANDLE
mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
MHD_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
{
GNUTLS_HASH_HANDLE ret;
int result;
ret = gnutls_malloc (sizeof (mac_hd_st));
ret = MHD_gnutls_malloc (sizeof (mac_hd_st));
if (ret == NULL)
return GNUTLS_HASH_FAILED;
@@ -114,11 +114,11 @@ mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
ret->key = NULL; /* it's a hash anyway */
ret->keysize = 0;
result = gc_hash_clone (handle->handle, &ret->handle);
result = MHD_gc_hash_clone (handle->handle, &ret->handle);
if (result)
{
gnutls_free (ret);
MHD_gnutls_free (ret);
return GNUTLS_HASH_FAILED;
}
@@ -126,42 +126,42 @@ mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
}
void
mhd_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
MHD_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
{
const opaque *mac;
int maclen;
maclen = mhd_gnutls_hash_get_algo_len (handle->algorithm);
maclen = MHD_gnutls_hash_get_algo_len (handle->algorithm);
mac = gc_hash_read (handle->handle);
mac = MHD_gc_hash_read (handle->handle);
if (digest != NULL)
memcpy (digest, mac, maclen);
gc_hash_close (handle->handle);
MHD_gc_hash_close (handle->handle);
gnutls_free (handle);
MHD_gnutls_free (handle);
}
mac_hd_t
mhd_gtls_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
MHD_gtls_MHD_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
const void *key, int keylen)
{
mac_hd_t ret;
int result;
ret = gnutls_malloc (sizeof (mac_hd_st));
ret = MHD_gnutls_malloc (sizeof (mac_hd_st));
if (ret == NULL)
return GNUTLS_MAC_FAILED;
result = gc_hash_open (_gnutls_mac2gc (algorithm), GC_HMAC, &ret->handle);
result = MHD_gc_hash_open (MHD__gnutls_mac2gc (algorithm), GC_HMAC, &ret->handle);
if (result)
{
gnutls_free (ret);
MHD_gnutls_free (ret);
return GNUTLS_MAC_FAILED;
}
gc_hash_hmac_setkey (ret->handle, keylen, key);
MHD_gc_hash_MHD_hmac_setkey (ret->handle, keylen, key);
ret->algorithm = algorithm;
ret->key = key;
@@ -171,21 +171,21 @@ mhd_gtls_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
}
void
mhd_gnutls_hmac_deinit (mac_hd_t handle, void *digest)
MHD_gnutls_MHD_hmac_deinit (mac_hd_t handle, void *digest)
{
const opaque *mac;
int maclen;
maclen = mhd_gnutls_hash_get_algo_len (handle->algorithm);
maclen = MHD_gnutls_hash_get_algo_len (handle->algorithm);
mac = gc_hash_read (handle->handle);
mac = MHD_gc_hash_read (handle->handle);
if (digest != NULL)
memcpy (digest, mac, maclen);
gc_hash_close (handle->handle);
MHD_gc_hash_close (handle->handle);
gnutls_free (handle);
MHD_gnutls_free (handle);
}
inline static int
@@ -203,7 +203,7 @@ get_padsize (enum MHD_GNUTLS_HashAlgorithm algorithm)
}
mac_hd_t
mhd_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm, void *key,
MHD_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm, void *key,
int keylen)
{
mac_hd_t ret;
@@ -213,28 +213,28 @@ mhd_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm, void *key,
padsize = get_padsize (algorithm);
if (padsize == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_MAC_FAILED;
}
memset (ipad, 0x36, padsize);
ret = mhd_gtls_hash_init (algorithm);
ret = MHD_gtls_hash_init (algorithm);
if (ret != GNUTLS_HASH_FAILED)
{
ret->key = key;
ret->keysize = keylen;
if (keylen > 0)
mhd_gnutls_hash (ret, key, keylen);
mhd_gnutls_hash (ret, ipad, padsize);
MHD_gnutls_hash (ret, key, keylen);
MHD_gnutls_hash (ret, ipad, padsize);
}
return ret;
}
void
mhd_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
MHD_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
{
opaque ret[MAX_HASH_SIZE];
mac_hd_t td;
@@ -245,29 +245,29 @@ mhd_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
padsize = get_padsize (handle->algorithm);
if (padsize == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return;
}
memset (opad, 0x5C, padsize);
td = mhd_gtls_hash_init (handle->algorithm);
td = MHD_gtls_hash_init (handle->algorithm);
if (td != GNUTLS_MAC_FAILED)
{
if (handle->keysize > 0)
mhd_gnutls_hash (td, handle->key, handle->keysize);
MHD_gnutls_hash (td, handle->key, handle->keysize);
mhd_gnutls_hash (td, opad, padsize);
block = mhd_gnutls_hash_get_algo_len (handle->algorithm);
mhd_gnutls_hash_deinit (handle, ret); /* get the previous hash */
mhd_gnutls_hash (td, ret, block);
MHD_gnutls_hash (td, opad, padsize);
block = MHD_gnutls_hash_get_algo_len (handle->algorithm);
MHD_gnutls_hash_deinit (handle, ret); /* get the previous hash */
MHD_gnutls_hash (td, ret, block);
mhd_gnutls_hash_deinit (td, digest);
MHD_gnutls_hash_deinit (td, digest);
}
}
void
mhd_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
MHD_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
void *digest, opaque * key,
uint32_t key_size)
{
@@ -281,30 +281,30 @@ mhd_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
padsize = get_padsize (handle->algorithm);
if (padsize == 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return;
}
memset (opad, 0x5C, padsize);
memset (ipad, 0x36, padsize);
td = mhd_gtls_hash_init (handle->algorithm);
td = MHD_gtls_hash_init (handle->algorithm);
if (td != GNUTLS_HASH_FAILED)
{
if (key_size > 0)
mhd_gnutls_hash (td, key, key_size);
MHD_gnutls_hash (td, key, key_size);
mhd_gnutls_hash (td, opad, padsize);
block = mhd_gnutls_hash_get_algo_len (handle->algorithm);
MHD_gnutls_hash (td, opad, padsize);
block = MHD_gnutls_hash_get_algo_len (handle->algorithm);
if (key_size > 0)
mhd_gnutls_hash (handle, key, key_size);
mhd_gnutls_hash (handle, ipad, padsize);
mhd_gnutls_hash_deinit (handle, ret); /* get the previous hash */
MHD_gnutls_hash (handle, key, key_size);
MHD_gnutls_hash (handle, ipad, padsize);
MHD_gnutls_hash_deinit (handle, ret); /* get the previous hash */
mhd_gnutls_hash (td, ret, block);
MHD_gnutls_hash (td, ret, block);
mhd_gnutls_hash_deinit (td, digest);
MHD_gnutls_hash_deinit (td, digest);
}
}
@@ -322,18 +322,18 @@ ssl3_sha (int i, opaque * secret, int secret_len,
text1[j] = 65 + i; /* A==65 */
}
td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
td = MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
if (td == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
mhd_gnutls_hash (td, text1, i + 1);
mhd_gnutls_hash (td, secret, secret_len);
mhd_gnutls_hash (td, rnd, rnd_len);
MHD_gnutls_hash (td, text1, i + 1);
MHD_gnutls_hash (td, secret, secret_len);
MHD_gnutls_hash (td, rnd, rnd_len);
mhd_gnutls_hash_deinit (td, digest);
MHD_gnutls_hash_deinit (td, digest);
return 0;
}
@@ -345,54 +345,54 @@ ssl3_md5 (int i, opaque * secret, int secret_len,
mac_hd_t td;
int ret;
td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
td = MHD_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
if (td == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
mhd_gnutls_hash (td, secret, secret_len);
MHD_gnutls_hash (td, secret, secret_len);
ret = ssl3_sha (i, secret, secret_len, rnd, rnd_len, tmp);
if (ret < 0)
{
gnutls_assert ();
mhd_gnutls_hash_deinit (td, digest);
MHD_gnutls_assert ();
MHD_gnutls_hash_deinit (td, digest);
return ret;
}
mhd_gnutls_hash (td, tmp,
mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_SHA1));
MHD_gnutls_hash (td, tmp,
MHD_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_SHA1));
mhd_gnutls_hash_deinit (td, digest);
MHD_gnutls_hash_deinit (td, digest);
return 0;
}
int
mhd_gnutls_ssl3_hash_md5 (void *first, int first_len,
MHD_gnutls_ssl3_hash_md5 (void *first, int first_len,
void *second, int second_len, int ret_len,
opaque * ret)
{
opaque digest[MAX_HASH_SIZE];
mac_hd_t td;
int block = mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
int block = MHD_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
td = MHD_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
if (td == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_HASH_FAILED;
}
mhd_gnutls_hash (td, first, first_len);
mhd_gnutls_hash (td, second, second_len);
MHD_gnutls_hash (td, first, first_len);
MHD_gnutls_hash (td, second, second_len);
mhd_gnutls_hash_deinit (td, digest);
MHD_gnutls_hash_deinit (td, digest);
if (ret_len > block)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -403,13 +403,13 @@ mhd_gnutls_ssl3_hash_md5 (void *first, int first_len,
}
int
mhd_gnutls_ssl3_generate_random (void *secret, int secret_len,
MHD_gnutls_ssl3_generate_random (void *secret, int secret_len,
void *rnd, int rnd_len,
int ret_bytes, opaque * ret)
{
int i = 0, copy, output_bytes;
opaque digest[MAX_HASH_SIZE];
int block = mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
int block = MHD_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
int result, times;
output_bytes = 0;
@@ -427,7 +427,7 @@ mhd_gnutls_ssl3_generate_random (void *secret, int secret_len,
result = ssl3_md5 (i, secret, secret_len, rnd, rnd_len, digest);
if (result < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return result;
}
src/daemon/https/tls/gnutls_hash_int.h
+13 -13
View File
@@ -31,7 +31,7 @@
typedef struct
{
gc_hash_handle handle;
MHD_gc_hash_handle handle;
enum MHD_GNUTLS_HashAlgorithm algorithm;
const void *key;
int keysize;
@@ -42,31 +42,31 @@ typedef mac_hd_t GNUTLS_HASH_HANDLE;
#define GNUTLS_HASH_FAILED NULL
#define GNUTLS_MAC_FAILED NULL
mac_hd_t mhd_gtls_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
mac_hd_t MHD_gtls_MHD_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
const void *key, int keylen);
void mhd_gnutls_hmac_deinit (mac_hd_t handle, void *digest);
void MHD_gnutls_MHD_hmac_deinit (mac_hd_t handle, void *digest);
mac_hd_t mhd_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm,
mac_hd_t MHD_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm,
void *key, int keylen);
void mhd_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest);
void MHD_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest);
GNUTLS_HASH_HANDLE mhd_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm
GNUTLS_HASH_HANDLE MHD_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm
algorithm);
int mhd_gnutls_hash_get_algo_len (enum MHD_GNUTLS_HashAlgorithm algorithm);
int mhd_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text,
int MHD_gnutls_hash_get_algo_len (enum MHD_GNUTLS_HashAlgorithm algorithm);
int MHD_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text,
size_t textlen);
void mhd_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest);
void MHD_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest);
int mhd_gnutls_ssl3_generate_random (void *secret, int secret_len,
int MHD_gnutls_ssl3_generate_random (void *secret, int secret_len,
void *rnd, int random_len, int bytes,
opaque * ret);
int mhd_gnutls_ssl3_hash_md5 (void *first, int first_len, void *second,
int MHD_gnutls_ssl3_hash_md5 (void *first, int first_len, void *second,
int second_len, int ret_len, opaque * ret);
void mhd_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle, void *digest,
void MHD_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle, void *digest,
opaque * key, uint32_t key_size);
GNUTLS_HASH_HANDLE mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle);
GNUTLS_HASH_HANDLE MHD_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle);
#endif /* GNUTLS_HASH_INT_H */
src/daemon/https/tls/gnutls_int.h
+88 -88
View File
@@ -92,9 +92,9 @@
#define DEFAULT_VERIFY_DEPTH 32
#define DEFAULT_VERIFY_BITS 16*1024
#define DECR_LEN(len, x) do { len-=x; if (len<0) {gnutls_assert(); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;} } while (0)
#define DECR_LENGTH_RET(len, x, RET) do { len-=x; if (len<0) {gnutls_assert(); return RET;} } while (0)
#define DECR_LENGTH_COM(len, x, COM) do { len-=x; if (len<0) {gnutls_assert(); COM;} } while (0)
#define DECR_LEN(len, x) do { len-=x; if (len<0) {MHD_gnutls_assert(); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;} } while (0)
#define DECR_LENGTH_RET(len, x, RET) do { len-=x; if (len<0) {MHD_gnutls_assert(); return RET;} } while (0)
#define DECR_LENGTH_COM(len, x, COM) do { len-=x; if (len<0) {MHD_gnutls_assert(); COM;} } while (0)
#define HASH2MAC(x) ((enum MHD_GNUTLS_HashAlgorithm)x)
@@ -129,11 +129,11 @@ typedef enum handshake_state_t
#include <gnutls_str.h>
typedef mhd_gtls_string mhd_gtls_buffer;
typedef MHD_gtls_string MHD_gtls_buffer;
#define mhd_gtls_buffer_init(buf) mhd_gtls_string_init(buf, gnutls_malloc, gnutls_realloc, gnutls_free);
#define mhd_gtls_buffer_clear mhd_gtls_string_clear
#define mhd_gtls_buffer_append mhd_gtls_string_append_data
#define MHD_gtls_buffer_init(buf) MHD_gtls_string_init(buf, MHD_gnutls_malloc, MHD_gnutls_realloc, MHD_gnutls_free);
#define MHD_gtls_buffer_clear MHD_gtls_string_clear
#define MHD_gtls_buffer_append MHD_gtls_string_append_data
/* This is the maximum number of algorithms (ciphers or macs etc).
* keep it synced with GNUTLS_MAX_ALGORITHM_NUM in gnutls.h
@@ -179,20 +179,20 @@ typedef enum content_type_t
typedef void (*LOG_FUNC) (int, const char *);
/* Store & Retrieve functions defines: */
typedef struct mhd_gtls_auth_cred_st
typedef struct MHD_gtls_auth_cred_st
{
enum MHD_GNUTLS_CredentialsType algorithm;
/* the type of credentials depends on algorithm
*/
void *credentials;
struct mhd_gtls_auth_cred_st *next;
struct MHD_gtls_auth_cred_st *next;
} auth_cred_st;
struct mhd_gtls_key
struct MHD_gtls_key
{
/* For DH KX */
gnutls_datum_t key;
MHD_gnutls_datum_t key;
mpi_t KEY;
mpi_t client_Y;
mpi_t client_g;
@@ -212,7 +212,7 @@ struct mhd_gtls_key
/* this is used to hold the peers authentication data
*/
/* auth_info_t structures SHOULD NOT contain malloced
* elements. Check gnutls_session_pack.c, and gnutls_auth.c.
* elements. Check MHD_gnutls_session_pack.c, and MHD_gnutls_auth.c.
* Rememember that this should be calloced!
*/
void *auth_info;
@@ -233,7 +233,7 @@ struct mhd_gtls_key
* for a client certificate verify
*/
};
typedef struct mhd_gtls_key *mhd_gtls_key_st;
typedef struct MHD_gtls_key *MHD_gtls_key_st;
/* STATE (cont) */
#include <gnutls_hash_int.h>
@@ -254,7 +254,7 @@ typedef struct
{
opaque name[MAX_SERVER_NAME_SIZE];
unsigned name_length;
gnutls_server_name_type_t type;
MHD_gnutls_server_name_type_t type;
} server_name_st;
#define MAX_SERVER_NAME_EXTENSIONS 3
@@ -267,20 +267,20 @@ typedef struct
opaque srp_username[MAX_SRP_USERNAME + 1];
/* TLS/IA data. */
int gnutls_ia_enable, gnutls_ia_peer_enable;
int gnutls_ia_allowskip, gnutls_ia_peer_allowskip;
int MHD_gnutls_ia_enable, MHD_gnutls_ia_peer_enable;
int MHD_gnutls_ia_allowskip, MHD_gnutls_ia_peer_allowskip;
/* Used by extensions that enable supplemental data. */
int do_recv_supplemental, do_send_supplemental;
/* Opaque PRF input. */
gnutls_oprfi_callback_func oprfi_cb;
MHD_gnutls_oprfi_callback_func oprfi_cb;
void *oprfi_userdata;
opaque *oprfi_client;
uint16_t oprfi_client_len;
opaque *oprfi_server;
uint16_t oprfi_server_len;
} mhd_gtls_ext_st;
} MHD_gtls_ext_st;
/* This flag indicates for an extension whether
* it is useful to application level or TLS level only.
@@ -292,7 +292,7 @@ typedef enum tls_ext_parse_type_t
EXTENSION_ANY,
EXTENSION_APPLICATION,
EXTENSION_TLS
} mhd_gtls_ext_parse_type_t;
} MHD_gtls_ext_parse_type_t;
/* auth_info_t structures now MAY contain malloced
* elements.
@@ -305,7 +305,7 @@ typedef enum tls_ext_parse_type_t
*/
/* if you add anything in Security_Parameters struct, then
* also modify CPY_COMMON in gnutls_constate.c
* also modify CPY_COMMON in MHD_gnutls_constate.c
*/
/* Note that the security parameters structure is set up after the
@@ -314,7 +314,7 @@ typedef enum tls_ext_parse_type_t
*/
typedef struct
{
gnutls_connection_end_t entity;
MHD_gnutls_connection_end_t entity;
enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm;
/* we've got separate write/read bulk/macs because
* there is a time in handshake where the peer has
@@ -339,7 +339,7 @@ typedef struct
opaque session_id[TLS_MAX_SESSION_ID_SIZE];
uint8_t session_id_size;
time_t timestamp;
mhd_gtls_ext_st extensions;
MHD_gtls_ext_st extensions;
/* The send size is the one requested by the programmer.
* The recv size is the one negotiated with the peer.
@@ -351,23 +351,23 @@ typedef struct
enum MHD_GNUTLS_Protocol version; /* moved here */
/* For TLS/IA. XXX: Move to IA credential? */
opaque inner_secret[TLS_MASTER_SIZE];
} mhd_gtls_security_param_st;
} MHD_gtls_security_param_st;
/* This structure holds the generated keys
*/
typedef struct
{
gnutls_datum_t server_write_mac_secret;
gnutls_datum_t client_write_mac_secret;
gnutls_datum_t server_write_IV;
gnutls_datum_t client_write_IV;
gnutls_datum_t server_write_key;
gnutls_datum_t client_write_key;
MHD_gnutls_datum_t server_write_mac_secret;
MHD_gnutls_datum_t client_write_mac_secret;
MHD_gnutls_datum_t server_write_IV;
MHD_gnutls_datum_t client_write_IV;
MHD_gnutls_datum_t server_write_key;
MHD_gnutls_datum_t client_write_key;
int generated_keys; /* zero if keys have not
* been generated. Non zero
* otherwise.
*/
} mhd_gtls_cipher_specs_st;
} MHD_gtls_cipher_specs_st;
typedef struct
{
@@ -375,29 +375,29 @@ typedef struct
cipher_hd_t read_cipher_state;
comp_hd_t read_compression_state;
comp_hd_t write_compression_state;
gnutls_datum_t read_mac_secret;
gnutls_datum_t write_mac_secret;
MHD_gnutls_datum_t read_mac_secret;
MHD_gnutls_datum_t write_mac_secret;
uint64 read_sequence_number;
uint64 write_sequence_number;
} mhd_gtls_conn_stat_st;
} MHD_gtls_conn_stat_st;
typedef struct
{
unsigned int priority[MAX_ALGOS];
unsigned int num_algorithms;
} mhd_gtls_priority_st;
} MHD_gtls_priority_st;
/* For the external api */
struct MHD_gtls_priority_st
{
mhd_gtls_priority_st cipher;
mhd_gtls_priority_st mac;
mhd_gtls_priority_st kx;
mhd_gtls_priority_st compression;
mhd_gtls_priority_st protocol;
MHD_gtls_priority_st cipher;
MHD_gtls_priority_st mac;
MHD_gtls_priority_st kx;
MHD_gtls_priority_st compression;
MHD_gtls_priority_st protocol;
/* certificate type : x509, OpenPGP, etc. */
mhd_gtls_priority_st cert_type;
MHD_gtls_priority_st cert_type;
/* to disable record padding */
int no_padding;
@@ -410,15 +410,15 @@ typedef struct MHD_gtls_dh_params_int
/* [0] is the prime, [1] is the generator.
*/
mpi_t params[2];
} mhd_gtls_dh_params_st;
} MHD_gtls_dh_params_st;
typedef struct
{
mhd_gtls_dh_params_t dh_params;
MHD_gtls_dh_params_t dh_params;
int free_dh_params;
mhd_gtls_rsa_params_t rsa_params;
MHD_gtls_rsa_params_t rsa_params;
int free_rsa_params;
} mhd_gtls_internal_params_st;
} MHD_gtls_internal_params_st;
typedef struct
{
@@ -427,19 +427,19 @@ typedef struct
size_t header_size;
/* this holds the length of the handshake packet */
size_t packet_length;
gnutls_handshake_description_t recv_type;
} mhd_gtls_handshake_header_buffer_st;
MHD_gnutls_handshake_description_t recv_type;
} MHD_gtls_handshake_header_buffer_st;
typedef struct
{
mhd_gtls_buffer application_data_buffer; /* holds data to be delivered to application layer */
mhd_gtls_buffer handshake_hash_buffer; /* used to keep the last received handshake
MHD_gtls_buffer application_data_buffer; /* holds data to be delivered to application layer */
MHD_gtls_buffer handshake_hash_buffer; /* used to keep the last received handshake
* message */
mac_hd_t handshake_mac_handle_sha; /* hash of the handshake messages */
mac_hd_t handshake_mac_handle_md5; /* hash of the handshake messages */
mhd_gtls_buffer handshake_data_buffer; /* this is a buffer that holds the current handshake message */
mhd_gtls_buffer ia_data_buffer; /* holds inner application data (TLS/IA) */
MHD_gtls_buffer handshake_data_buffer; /* this is a buffer that holds the current handshake message */
MHD_gtls_buffer ia_data_buffer; /* holds inner application data (TLS/IA) */
resumable_session_t resumable; /* TRUE or FALSE - if we can resume that session */
handshake_state_t handshake_state; /* holds
* a number which indicates where
@@ -471,28 +471,28 @@ typedef struct
/* resumed session */
resumable_session_t resumed; /* RESUME_TRUE or FALSE - if we are resuming a session */
mhd_gtls_security_param_st resumed_security_parameters;
MHD_gtls_security_param_st resumed_security_parameters;
/* sockets internals */
int lowat;
/* These buffers are used in the handshake
* protocol only. freed using _gnutls_handshake_io_buffer_clear();
* protocol only. freed using MHD__gnutls_handshake_io_buffer_clear();
*/
mhd_gtls_buffer handshake_send_buffer;
MHD_gtls_buffer handshake_send_buffer;
size_t handshake_send_buffer_prev_size;
content_type_t handshake_send_buffer_type;
gnutls_handshake_description_t handshake_send_buffer_htype;
MHD_gnutls_handshake_description_t handshake_send_buffer_htype;
content_type_t handshake_recv_buffer_type;
gnutls_handshake_description_t handshake_recv_buffer_htype;
mhd_gtls_buffer handshake_recv_buffer;
MHD_gnutls_handshake_description_t handshake_recv_buffer_htype;
MHD_gtls_buffer handshake_recv_buffer;
/* this buffer holds a record packet -mostly used for
* non blocking IO.
*/
mhd_gtls_buffer record_recv_buffer;
mhd_gtls_buffer record_send_buffer; /* holds cached data
* for the gnutls_io_write_buffered()
MHD_gtls_buffer record_recv_buffer;
MHD_gtls_buffer record_send_buffer; /* holds cached data
* for the MHD_gnutls_io_write_buffered()
* function.
*/
size_t record_send_buffer_prev_size; /* holds the
@@ -508,7 +508,7 @@ typedef struct
int have_peeked_data;
int expire_time; /* after expire_time seconds this session will expire */
struct mhd_gtls_mod_auth_st_int *auth_struct; /* used in handshake packets and KX algorithms */
struct MHD_gtls_mod_auth_st_int *auth_struct; /* used in handshake packets and KX algorithms */
/* TODO rm */
int v2_hello; /* 0 if the client hello is v3+.
@@ -516,7 +516,7 @@ typedef struct
*/
/* keeps the headers of the handshake packet
*/
mhd_gtls_handshake_header_buffer_st handshake_header_buffer;
MHD_gtls_handshake_header_buffer_st handshake_header_buffer;
/* this is the highest version available
* to the peer. (advertized version).
@@ -533,7 +533,7 @@ typedef struct
int send_cert_req;
/* bits to use for DHE and DHA
* use _gnutls_dh_get_prime_bits() and MHD_gnutls_dh_set_prime_bits()
* use MHD__gnutls_dh_get_prime_bits() and MHD__gnutls_dh_set_prime_bits()
* to access it.
*/
uint16_t dh_prime_bits;
@@ -542,17 +542,17 @@ typedef struct
/* PUSH & PULL functions.
*/
mhd_gtls_pull_func _gnutls_pull_func;
mhd_gtls_push_func _gnutls_push_func;
MHD_gtls_pull_func MHD__gnutls_pull_func;
MHD_gtls_push_func MHD__gnutls_push_func;
/* Holds the first argument of PUSH and PULL
* functions;
*/
gnutls_transport_ptr_t transport_recv_ptr;
gnutls_transport_ptr_t transport_send_ptr;
MHD_gnutls_transport_ptr_t transport_recv_ptr;
MHD_gnutls_transport_ptr_t transport_send_ptr;
/* post client hello callback (server side only)
*/
gnutls_handshake_post_client_hello_func user_hello_func;
MHD_gnutls_handshake_post_client_hello_func user_hello_func;
/* Holds the record size requested by the
* user.
@@ -560,12 +560,12 @@ typedef struct
uint16_t proposed_record_size;
/* holds the selected certificate and key.
* use mhd_gtls_selected_certs_deinit() and mhd_gtls_selected_certs_set()
* use MHD_gtls_selected_certs_deinit() and MHD_gtls_selected_certs_set()
* to change them.
*/
gnutls_cert *selected_cert_list;
MHD_gnutls_cert *selected_cert_list;
int selected_cert_list_length;
gnutls_privkey *selected_key;
MHD_gnutls_privkey *selected_key;
int selected_need_free;
/* holds the extensions we sent to the peer
@@ -615,16 +615,16 @@ typedef struct
* credentials structure, or from a callback. That is to
* minimize external calls.
*/
mhd_gtls_internal_params_st params;
MHD_gtls_internal_params_st params;
/* This buffer is used by the record recv functions,
* as a temporary store buffer.
*/
gnutls_datum_t recv_buffer;
MHD_gnutls_datum_t recv_buffer;
/* To avoid using global variables, and especially on Windows where
* the application may use a different errno variable than GnuTLS,
* it is possible to use MHD_gnutls_transport_set_errno to set a
* it is possible to use MHD__gnutls_transport_set_errno to set a
* session-specific errno variable in the user-replaceable push/pull
* functions. This value is used by the send/recv functions. (The
* strange name of this variable is because 'errno' is typically
@@ -633,44 +633,44 @@ typedef struct
int errnum;
/* Function used to perform public-key signing operation during
handshake. Used by gnutls_sig.c:_gnutls_tls_sign(), see also
handshake. Used by MHD_gnutls_sig.c:MHD__gnutls_tls_sign(), see also
MHD_gtls_sign_callback_set(). */
gnutls_sign_func sign_func;
MHD_gnutls_sign_func sign_func;
void *sign_func_userdata;
/* If you add anything here, check mhd_gtls_handshake_internal_state_clear().
/* If you add anything here, check MHD_gtls_handshake_internal_state_clear().
*/
} mhd_gtls_internals_st;
} MHD_gtls_internals_st;
struct MHD_gtls_session_int
{
mhd_gtls_security_param_st security_parameters;
mhd_gtls_cipher_specs_st cipher_specs;
mhd_gtls_conn_stat_st connection_state;
mhd_gtls_internals_st internals;
mhd_gtls_key_st key;
MHD_gtls_security_param_st security_parameters;
MHD_gtls_cipher_specs_st cipher_specs;
MHD_gtls_conn_stat_st connection_state;
MHD_gtls_internals_st internals;
MHD_gtls_key_st key;
};
/* functions */
void mhd_gtls_set_current_version (mhd_gtls_session_t session,
void MHD_gtls_set_current_version (MHD_gtls_session_t session,
enum MHD_GNUTLS_Protocol version);
void mhd_gtls_free_auth_info (mhd_gtls_session_t session);
void MHD_gtls_free_auth_info (MHD_gtls_session_t session);
/* These two macros return the advertized TLS version of
* the peer.
*/
#define _gnutls_get_adv_version_major( session) \
#define MHD__gnutls_get_adv_version_major( session) \
session->internals.adv_version_major
#define _gnutls_get_adv_version_minor( session) \
#define MHD__gnutls_get_adv_version_minor( session) \
session->internals.adv_version_minor
#define set_adv_version( session, major, minor) \
session->internals.adv_version_major = major; \
session->internals.adv_version_minor = minor
void mhd_gtls_set_adv_version (mhd_gtls_session_t, enum MHD_GNUTLS_Protocol);
enum MHD_GNUTLS_Protocol mhd_gtls_get_adv_version (mhd_gtls_session_t);
void MHD_gtls_set_adv_version (MHD_gtls_session_t, enum MHD_GNUTLS_Protocol);
enum MHD_GNUTLS_Protocol MHD_gtls_get_adv_version (MHD_gtls_session_t);
#endif /* GNUTLS_INT_H */
src/daemon/https/tls/gnutls_kx.c
+114 -114
View File
@@ -23,7 +23,7 @@
*/
/* This file contains functions which are wrappers for the key exchange
* part of TLS. They are called by the handshake functions (MHD_gnutls_handshake)
* part of TLS. They are called by the handshake functions (MHD__gnutls_handshake)
*/
#include "gnutls_int.h"
@@ -42,10 +42,10 @@
*/
#define MASTER_SECRET "master secret"
static int generate_normal_master (mhd_gtls_session_t session, int);
static int generate_normal_master (MHD_gtls_session_t session, int);
int
mhd_gtls_generate_master (mhd_gtls_session_t session, int keep_premaster)
MHD_gtls_generate_master (MHD_gtls_session_t session, int keep_premaster)
{
if (session->internals.resumed == RESUME_FALSE)
return generate_normal_master (session, keep_premaster);
@@ -56,22 +56,22 @@ mhd_gtls_generate_master (mhd_gtls_session_t session, int keep_premaster)
*/
#define PREMASTER session->key->key
static int
generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
generate_normal_master (MHD_gtls_session_t session, int keep_premaster)
{
int ret = 0;
char buf[512];
_gnutls_hard_log ("INT: PREMASTER SECRET[%d]: %s\n", PREMASTER.size,
mhd_gtls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
MHD__gnutls_hard_log ("INT: PREMASTER SECRET[%d]: %s\n", PREMASTER.size,
MHD_gtls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
sizeof (buf)));
_gnutls_hard_log ("INT: CLIENT RANDOM[%d]: %s\n", 32,
mhd_gtls_bin2hex (session->security_parameters.
MHD__gnutls_hard_log ("INT: CLIENT RANDOM[%d]: %s\n", 32,
MHD_gtls_bin2hex (session->security_parameters.
client_random, 32, buf, sizeof (buf)));
_gnutls_hard_log ("INT: SERVER RANDOM[%d]: %s\n", 32,
mhd_gtls_bin2hex (session->security_parameters.
MHD__gnutls_hard_log ("INT: SERVER RANDOM[%d]: %s\n", 32,
MHD_gtls_bin2hex (session->security_parameters.
server_random, 32, buf, sizeof (buf)));
if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
{
opaque rnd[2 * TLS_RANDOM_SIZE + 1];
@@ -81,7 +81,7 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
session->security_parameters.server_random, TLS_RANDOM_SIZE);
ret =
mhd_gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
MHD_gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
rnd, 2 * TLS_RANDOM_SIZE,
TLS_MASTER_SIZE,
session->security_parameters.
@@ -97,25 +97,25 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
rndlen += session->security_parameters.extensions.oprfi_client_len;
rndlen += session->security_parameters.extensions.oprfi_server_len;
rnd = gnutls_malloc (rndlen + 1);
rnd = MHD_gnutls_malloc (rndlen + 1);
if (!rnd)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
_gnutls_hard_log ("INT: CLIENT OPRFI[%d]: %s\n",
MHD__gnutls_hard_log ("INT: CLIENT OPRFI[%d]: %s\n",
session->security_parameters.
extensions.oprfi_server_len,
mhd_gtls_bin2hex (session->security_parameters.
MHD_gtls_bin2hex (session->security_parameters.
extensions.oprfi_client,
session->security_parameters.
extensions.oprfi_client_len, buf,
sizeof (buf)));
_gnutls_hard_log ("INT: SERVER OPRFI[%d]: %s\n",
MHD__gnutls_hard_log ("INT: SERVER OPRFI[%d]: %s\n",
session->security_parameters.
extensions.oprfi_server_len,
mhd_gtls_bin2hex (session->security_parameters.
MHD_gtls_bin2hex (session->security_parameters.
extensions.oprfi_server,
session->security_parameters.
extensions.oprfi_server_len, buf,
@@ -135,12 +135,12 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
session->security_parameters.extensions.oprfi_server,
session->security_parameters.extensions.oprfi_server_len);
ret = mhd_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
ret = MHD_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
MASTER_SECRET, strlen (MASTER_SECRET),
rnd, rndlen, TLS_MASTER_SIZE,
session->security_parameters.master_secret);
gnutls_free (rnd);
MHD_gnutls_free (rnd);
}
else
{
@@ -152,7 +152,7 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
session->security_parameters.server_random, TLS_RANDOM_SIZE);
ret =
mhd_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
MHD_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
MASTER_SECRET, strlen (MASTER_SECRET),
rnd, 2 * TLS_RANDOM_SIZE, TLS_MASTER_SIZE,
session->security_parameters.master_secret);
@@ -163,13 +163,13 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
session->security_parameters.master_secret, TLS_MASTER_SIZE);
if (!keep_premaster)
_gnutls_free_datum (&PREMASTER);
MHD__gnutls_free_datum (&PREMASTER);
if (ret < 0)
return ret;
_gnutls_hard_log ("INT: MASTER SECRET: %s\n",
mhd_gtls_bin2hex (session->security_parameters.
MHD__gnutls_hard_log ("INT: MASTER SECRET: %s\n",
MHD_gtls_bin2hex (session->security_parameters.
master_secret, TLS_MASTER_SIZE, buf,
sizeof (buf)));
@@ -182,13 +182,13 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
* by the selected ciphersuite.
*/
int
mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again)
MHD_gtls_send_server_kx_message (MHD_gtls_session_t session, int again)
{
uint8_t *data = NULL;
int data_size = 0;
int ret = 0;
if (session->internals.auth_struct->mhd_gtls_gen_server_kx == NULL)
if (session->internals.auth_struct->MHD_gtls_gen_server_kx == NULL)
return 0;
data = NULL;
@@ -197,30 +197,30 @@ mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again)
if (again == 0)
{
data_size =
session->internals.auth_struct->mhd_gtls_gen_server_kx (session,
session->internals.auth_struct->MHD_gtls_gen_server_kx (session,
&data);
if (data_size == GNUTLS_E_INT_RET_0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
if (data_size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return data_size;
}
}
ret =
mhd_gtls_send_handshake (session, data, data_size,
MHD_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE);
gnutls_free (data);
MHD_gnutls_free (data);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
return data_size;
@@ -230,7 +230,7 @@ mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again)
* client.
*/
int
mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
MHD_gtls_send_server_certificate_request (MHD_gtls_session_t session,
int again)
{
uint8_t *data = NULL;
@@ -238,7 +238,7 @@ mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
int ret = 0;
if (session->internals.auth_struct->
mhd_gtls_gen_server_certificate_request == NULL)
MHD_gtls_gen_server_certificate_request == NULL)
return 0;
if (session->internals.send_cert_req <= 0)
@@ -251,22 +251,22 @@ mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
{
data_size =
session->internals.auth_struct->
mhd_gtls_gen_server_certificate_request (session, &data);
MHD_gtls_gen_server_certificate_request (session, &data);
if (data_size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return data_size;
}
}
ret =
mhd_gtls_send_handshake (session, data, data_size,
MHD_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST);
gnutls_free (data);
MHD_gnutls_free (data);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
return data_size;
@@ -277,13 +277,13 @@ mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
* exchange message
*/
int
mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again)
MHD_gtls_send_client_kx_message (MHD_gtls_session_t session, int again)
{
uint8_t *data;
int data_size;
int ret = 0;
if (session->internals.auth_struct->mhd_gtls_gen_client_kx == NULL)
if (session->internals.auth_struct->MHD_gtls_gen_client_kx == NULL)
return 0;
@@ -293,22 +293,22 @@ mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again)
if (again == 0)
{
data_size =
session->internals.auth_struct->mhd_gtls_gen_client_kx (session,
session->internals.auth_struct->MHD_gtls_gen_client_kx (session,
&data);
if (data_size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return data_size;
}
}
ret =
mhd_gtls_send_handshake (session, data, data_size,
MHD_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE);
gnutls_free (data);
MHD_gnutls_free (data);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -320,7 +320,7 @@ mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again)
* verify message
*/
int
mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
MHD_gtls_send_client_certificate_verify (MHD_gtls_session_t session,
int again)
{
uint8_t *data;
@@ -337,9 +337,9 @@ mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
if (session->key->certificate_requested == 0)
return 0;
if (session->internals.auth_struct->mhd_gtls_gen_client_cert_vrfy == NULL)
if (session->internals.auth_struct->MHD_gtls_gen_client_cert_vrfy == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return 0; /* this algorithm does not support cli_cert_vrfy
*/
}
@@ -351,10 +351,10 @@ mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
{
data_size =
session->internals.auth_struct->
mhd_gtls_gen_client_cert_vrfy (session, &data);
MHD_gtls_gen_client_cert_vrfy (session, &data);
if (data_size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return data_size;
}
if (data_size == 0)
@@ -362,53 +362,53 @@ mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
}
ret =
mhd_gtls_send_handshake (session, data,
MHD_gtls_send_handshake (session, data,
data_size, GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY);
gnutls_free (data);
MHD_gnutls_free (data);
return ret;
}
int
mhd_gtls_recv_server_kx_message (mhd_gtls_session_t session)
MHD_gtls_recv_server_kx_message (MHD_gtls_session_t session)
{
uint8_t *data = NULL;
int datasize;
int ret = 0;
if (session->internals.auth_struct->mhd_gtls_process_server_kx != NULL)
if (session->internals.auth_struct->MHD_gtls_process_server_kx != NULL)
{
/* EXCEPTION FOR RSA_EXPORT cipher suite
*/
if (mhd_gtls_session_is_export (session) != 0 &&
_gnutls_peers_cert_less_512 (session) != 0)
if (MHD_gtls_session_is_export (session) != 0 &&
MHD__gnutls_peers_cert_less_512 (session) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
ret =
mhd_gtls_recv_handshake (session, &data,
MHD_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE,
MANDATORY_PACKET);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret =
session->internals.auth_struct->mhd_gtls_process_server_kx (session,
session->internals.auth_struct->MHD_gtls_process_server_kx (session,
data,
datasize);
gnutls_free (data);
MHD_gnutls_free (data);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -417,18 +417,18 @@ mhd_gtls_recv_server_kx_message (mhd_gtls_session_t session)
}
int
mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session)
MHD_gtls_recv_server_certificate_request (MHD_gtls_session_t session)
{
uint8_t *data;
int datasize;
int ret = 0;
if (session->internals.auth_struct->
mhd_gtls_process_server_certificate_request != NULL)
MHD_gtls_process_server_certificate_request != NULL)
{
ret =
mhd_gtls_recv_handshake (session, &data,
MHD_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST,
OPTIONAL_PACKET);
@@ -440,8 +440,8 @@ mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session)
ret =
session->internals.auth_struct->
mhd_gtls_process_server_certificate_request (session, data, datasize);
gnutls_free (data);
MHD_gtls_process_server_certificate_request (session, data, datasize);
MHD_gnutls_free (data);
if (ret < 0)
return ret;
@@ -450,7 +450,7 @@ mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session)
}
int
mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
MHD_gtls_recv_client_kx_message (MHD_gtls_session_t session)
{
uint8_t *data;
int datasize;
@@ -458,11 +458,11 @@ mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
/* Do key exchange only if the algorithm permits it */
if (session->internals.auth_struct->mhd_gtls_process_client_kx != NULL)
if (session->internals.auth_struct->MHD_gtls_process_client_kx != NULL)
{
ret =
mhd_gtls_recv_handshake (session, &data,
MHD_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE,
MANDATORY_PACKET);
@@ -470,10 +470,10 @@ mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
return ret;
ret =
session->internals.auth_struct->mhd_gtls_process_client_kx (session,
session->internals.auth_struct->MHD_gtls_process_client_kx (session,
data,
datasize);
gnutls_free (data);
MHD_gnutls_free (data);
if (ret < 0)
return ret;
@@ -486,7 +486,7 @@ mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
/* This is called when we want send our certificate
*/
int
mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
MHD_gtls_send_client_certificate (MHD_gtls_session_t session, int again)
{
uint8_t *data = NULL;
int data_size = 0;
@@ -496,7 +496,7 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
if (session->key->certificate_requested == 0)
return 0;
if (session->internals.auth_struct->mhd_gtls_gen_client_certificate == NULL)
if (session->internals.auth_struct->MHD_gtls_gen_client_certificate == NULL)
return 0;
data = NULL;
@@ -504,18 +504,18 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
if (again == 0)
{
if (MHD_gnutls_protocol_get_version (session) != MHD_GNUTLS_PROTOCOL_SSL3 ||
if (MHD__gnutls_protocol_get_version (session) != MHD_GNUTLS_PROTOCOL_SSL3 ||
session->internals.selected_cert_list_length > 0)
{
/* TLS 1.0 or SSL 3.0 with a valid certificate
*/
data_size =
session->internals.auth_struct->
mhd_gtls_gen_client_certificate (session, &data);
MHD_gtls_gen_client_certificate (session, &data);
if (data_size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return data_size;
}
}
@@ -525,11 +525,11 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
* no certificate alert instead of an
* empty certificate.
*/
if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
session->internals.selected_cert_list_length == 0)
{
ret =
MHD_gnutls_alert_send (session, GNUTLS_AL_WARNING,
MHD__gnutls_alert_send (session, GNUTLS_AL_WARNING,
GNUTLS_A_SSL3_NO_CERTIFICATE);
}
@@ -537,14 +537,14 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
{ /* TLS 1.0 or SSL 3.0 with a valid certificate
*/
ret =
mhd_gtls_send_handshake (session, data, data_size,
MHD_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_CERTIFICATE_PKT);
gnutls_free (data);
MHD_gnutls_free (data);
}
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -555,14 +555,14 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
/* This is called when we want send our certificate
*/
int
mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again)
MHD_gtls_send_server_certificate (MHD_gtls_session_t session, int again)
{
uint8_t *data = NULL;
int data_size = 0;
int ret = 0;
if (session->internals.auth_struct->mhd_gtls_gen_server_certificate == NULL)
if (session->internals.auth_struct->MHD_gtls_gen_server_certificate == NULL)
return 0;
data = NULL;
@@ -572,22 +572,22 @@ mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again)
{
data_size =
session->internals.auth_struct->
mhd_gtls_gen_server_certificate (session, &data);
MHD_gtls_gen_server_certificate (session, &data);
if (data_size < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return data_size;
}
}
ret =
mhd_gtls_send_handshake (session, data, data_size,
MHD_gtls_send_handshake (session, data, data_size,
GNUTLS_HANDSHAKE_CERTIFICATE_PKT);
gnutls_free (data);
MHD_gnutls_free (data);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -596,14 +596,14 @@ mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again)
int
mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
MHD_gtls_recv_client_certificate (MHD_gtls_session_t session)
{
int datasize;
opaque *data;
int ret = 0;
int optional;
if (session->internals.auth_struct->mhd_gtls_process_client_certificate !=
if (session->internals.auth_struct->MHD_gtls_process_client_certificate !=
NULL)
{
@@ -620,7 +620,7 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
optional = OPTIONAL_PACKET;
ret =
mhd_gtls_recv_handshake (session, &data,
MHD_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CERTIFICATE_PKT, optional);
@@ -632,14 +632,14 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
*/
if (optional == OPTIONAL_PACKET &&
ret == GNUTLS_E_WARNING_ALERT_RECEIVED &&
MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
gnutls_alert_get (session) == GNUTLS_A_SSL3_NO_CERTIFICATE)
MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
MHD_gnutls_alert_get (session) == GNUTLS_A_SSL3_NO_CERTIFICATE)
{
/* SSL3 does not send an empty certificate,
* but this alert. So we just ignore it.
*/
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
@@ -649,7 +649,7 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
|| ret == GNUTLS_E_FATAL_ALERT_RECEIVED)
&& optional == MANDATORY_PACKET)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_CERTIFICATE_FOUND;
}
@@ -662,17 +662,17 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
* well I'm not sure we should accept this
* behaviour.
*/
gnutls_assert ();
MHD_gnutls_assert ();
return 0;
}
ret =
session->internals.auth_struct->
mhd_gtls_process_client_certificate (session, data, datasize);
MHD_gtls_process_client_certificate (session, data, datasize);
gnutls_free (data);
MHD_gnutls_free (data);
if (ret < 0 && ret != GNUTLS_E_NO_CERTIFICATE_FOUND)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -689,34 +689,34 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
}
int
mhd_gtls_recv_server_certificate (mhd_gtls_session_t session)
MHD_gtls_recv_server_certificate (MHD_gtls_session_t session)
{
int datasize;
opaque *data;
int ret = 0;
if (session->internals.auth_struct->mhd_gtls_process_server_certificate !=
if (session->internals.auth_struct->MHD_gtls_process_server_certificate !=
NULL)
{
ret =
mhd_gtls_recv_handshake (session, &data,
MHD_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CERTIFICATE_PKT,
MANDATORY_PACKET);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret =
session->internals.auth_struct->
mhd_gtls_process_server_certificate (session, data, datasize);
gnutls_free (data);
MHD_gtls_process_server_certificate (session, data, datasize);
MHD_gnutls_free (data);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
}
@@ -729,14 +729,14 @@ mhd_gtls_recv_server_certificate (mhd_gtls_session_t session)
* arrive if the peer did not send us a certificate.
*/
int
mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t session)
MHD_gtls_recv_client_certificate_verify_message (MHD_gtls_session_t session)
{
uint8_t *data;
int datasize;
int ret = 0;
if (session->internals.auth_struct->mhd_gtls_process_client_cert_vrfy !=
if (session->internals.auth_struct->MHD_gtls_process_client_cert_vrfy !=
NULL)
{
@@ -747,7 +747,7 @@ mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t session)
}
ret =
mhd_gtls_recv_handshake (session, &data,
MHD_gtls_recv_handshake (session, &data,
&datasize,
GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY,
OPTIONAL_PACKET);
@@ -758,14 +758,14 @@ mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t session)
&& session->internals.send_cert_req == GNUTLS_CERT_REQUIRE)
{
/* certificate was required */
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_NO_CERTIFICATE_FOUND;
}
ret =
session->internals.auth_struct->
mhd_gtls_process_client_cert_vrfy (session, data, datasize);
gnutls_free (data);
MHD_gtls_process_client_cert_vrfy (session, data, datasize);
MHD_gnutls_free (data);
if (ret < 0)
return ret;
src/daemon/https/tls/gnutls_kx.h
+13 -13
View File
@@ -22,19 +22,19 @@
*
*/
int mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again);
int mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again);
int mhd_gtls_recv_server_kx_message (mhd_gtls_session_t session);
int mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session);
int mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
int MHD_gtls_send_server_kx_message (MHD_gtls_session_t session, int again);
int MHD_gtls_send_client_kx_message (MHD_gtls_session_t session, int again);
int MHD_gtls_recv_server_kx_message (MHD_gtls_session_t session);
int MHD_gtls_recv_client_kx_message (MHD_gtls_session_t session);
int MHD_gtls_send_client_certificate_verify (MHD_gtls_session_t session,
int again);
int mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again);
int mhd_gtls_generate_master (mhd_gtls_session_t session, int keep_premaster);
int mhd_gtls_recv_client_certificate (mhd_gtls_session_t session);
int mhd_gtls_recv_server_certificate (mhd_gtls_session_t session);
int mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again);
int mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session);
int mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
int MHD_gtls_send_server_certificate (MHD_gtls_session_t session, int again);
int MHD_gtls_generate_master (MHD_gtls_session_t session, int keep_premaster);
int MHD_gtls_recv_client_certificate (MHD_gtls_session_t session);
int MHD_gtls_recv_server_certificate (MHD_gtls_session_t session);
int MHD_gtls_send_client_certificate (MHD_gtls_session_t session, int again);
int MHD_gtls_recv_server_certificate_request (MHD_gtls_session_t session);
int MHD_gtls_send_server_certificate_request (MHD_gtls_session_t session,
int again);
int mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t
int MHD_gtls_recv_client_certificate_verify_message (MHD_gtls_session_t
session);
src/daemon/https/tls/gnutls_mem.c
+21 -21
View File
@@ -26,40 +26,40 @@
#include <gnutls_errors.h>
#include <gnutls_num.h>
gnutls_alloc_function gnutls_secure_malloc = malloc;
gnutls_alloc_function gnutls_malloc = malloc;
gnutls_free_function gnutls_free = free;
gnutls_realloc_function gnutls_realloc = realloc;
MHD_gnutls_alloc_function MHD_gnutls_secure_malloc = malloc;
MHD_gnutls_alloc_function MHD_gnutls_malloc = malloc;
MHD_gnutls_free_function MHD_gnutls_free = free;
MHD_gnutls_realloc_function MHD_gnutls_realloc = realloc;
void *(*gnutls_calloc) (size_t, size_t) = calloc;
char *(*gnutls_strdup) (const char *) = mhd_gtls_strdup;
void *(*MHD_gnutls_calloc) (size_t, size_t) = calloc;
char *(*MHD_gnutls_strdup) (const char *) = MHD_gtls_strdup;
int
_gnutls_is_secure_mem_null (const void *ign)
MHD__gnutls_is_secure_mem_null (const void *ign)
{
return 0;
}
int (*_gnutls_is_secure_memory) (const void *) = _gnutls_is_secure_mem_null;
int (*MHD__gnutls_is_secure_memory) (const void *) = MHD__gnutls_is_secure_mem_null;
void *
mhd_gtls_calloc (size_t nmemb, size_t size)
MHD_gtls_calloc (size_t nmemb, size_t size)
{
void *ret;
size *= nmemb;
ret = gnutls_malloc (size);
ret = MHD_gnutls_malloc (size);
if (ret != NULL)
memset (ret, 0, size);
return ret;
}
svoid *
mhd_gtls_secure_calloc (size_t nmemb, size_t size)
MHD_gtls_secure_calloc (size_t nmemb, size_t size)
{
svoid *ret;
size *= nmemb;
ret = gnutls_secure_malloc (size);
ret = MHD_gnutls_secure_malloc (size);
if (ret != NULL)
memset (ret, 0, size);
return ret;
@@ -69,29 +69,29 @@ mhd_gtls_secure_calloc (size_t nmemb, size_t size)
* fails.
*/
void *
mhd_gtls_realloc_fast (void *ptr, size_t size)
MHD_gtls_realloc_fast (void *ptr, size_t size)
{
void *ret;
if (size == 0)
return ptr;
ret = gnutls_realloc (ptr, size);
ret = MHD_gnutls_realloc (ptr, size);
if (ret == NULL)
{
gnutls_free (ptr);
MHD_gnutls_free (ptr);
}
return ret;
}
char *
mhd_gtls_strdup (const char *str)
MHD_gtls_strdup (const char *str)
{
size_t siz = strlen (str) + 1;
char *ret;
ret = gnutls_malloc (siz);
ret = MHD_gnutls_malloc (siz);
if (ret != NULL)
memcpy (ret, str, siz);
return ret;
@@ -103,7 +103,7 @@ mhd_gtls_strdup (const char *str)
*/
/**
* gnutls_malloc - Allocates and returns data
* MHD_gnutls_malloc - Allocates and returns data
*
* This function will allocate 's' bytes data, and
* return a pointer to memory. This function is supposed
@@ -113,12 +113,12 @@ mhd_gtls_strdup (const char *str)
*
**/
void *
gnutls_malloc (size_t s)
MHD_gnutls_malloc (size_t s)
{
}
/**
* gnutls_free - Returns a free() like function
* MHD_gnutls_free - Returns a free() like function
* @d: pointer to memory
*
* This function will free data pointed by ptr.
@@ -127,7 +127,7 @@ gnutls_malloc (size_t s)
*
**/
void
gnutls_free (void *ptr)
MHD_gnutls_free (void *ptr)
{
}
src/daemon/https/tls/gnutls_mem.h
+15 -15
View File
@@ -29,42 +29,42 @@
# include <dmalloc.h>
#endif
typedef void svoid; /* for functions that allocate using gnutls_secure_malloc */
typedef void svoid; /* for functions that allocate using MHD_gnutls_secure_malloc */
/* Use gnutls_afree() when calling alloca, or
/* Use MHD_gnutls_afree() when calling alloca, or
* memory leaks may occur in systems which do not
* support alloca.
*/
#ifdef USE_EFENCE
# define gnutls_alloca gnutls_malloc
# define gnutls_afree gnutls_free
# define MHD_gnutls_alloca MHD_gnutls_malloc
# define MHD_gnutls_afree MHD_gnutls_free
#endif
#ifdef HAVE_ALLOCA
# ifdef HAVE_ALLOCA_H
# include <alloca.h>
# endif
# ifndef gnutls_alloca
# define gnutls_alloca alloca
# define gnutls_afree(x)
# ifndef MHD_gnutls_alloca
# define MHD_gnutls_alloca alloca
# define MHD_gnutls_afree(x)
# endif
#else
# ifndef gnutls_alloca
# define gnutls_alloca gnutls_malloc
# define gnutls_afree gnutls_free
# ifndef MHD_gnutls_alloca
# define MHD_gnutls_alloca MHD_gnutls_malloc
# define MHD_gnutls_afree MHD_gnutls_free
# endif
#endif /* HAVE_ALLOCA */
extern int (*_gnutls_is_secure_memory) (const void *);
extern int (*MHD__gnutls_is_secure_memory) (const void *);
/* this realloc function will return ptr if size==0, and
* will free the ptr if the new allocation failed.
*/
void *mhd_gtls_realloc_fast (void *ptr, size_t size);
void *MHD_gtls_realloc_fast (void *ptr, size_t size);
svoid *mhd_gtls_secure_calloc (size_t nmemb, size_t size);
svoid *MHD_gtls_secure_calloc (size_t nmemb, size_t size);
void *mhd_gtls_calloc (size_t nmemb, size_t size);
char *mhd_gtls_strdup (const char *);
void *MHD_gtls_calloc (size_t nmemb, size_t size);
char *MHD_gtls_strdup (const char *);
#endif /* GNUTLS_MEM_H */
src/daemon/https/tls/gnutls_mpi.c
+43 -43
View File
@@ -35,7 +35,7 @@
*/
void
mhd_gtls_mpi_release (mpi_t * x)
MHD_gtls_mpi_release (mpi_t * x)
{
if (*x == NULL)
return;
@@ -46,7 +46,7 @@ mhd_gtls_mpi_release (mpi_t * x)
/* returns zero on success
*/
int
mhd_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
MHD_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
{
int ret;
@@ -60,7 +60,7 @@ mhd_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
/* returns zero on success. Fails if the number is zero.
*/
int
mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
MHD_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
{
int ret;
@@ -70,9 +70,9 @@ mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
/* MPIs with 0 bits are illegal
*/
if (_gnutls_mpi_get_nbits (*ret_mpi) == 0)
if (MHD__gnutls_mpi_get_nbits (*ret_mpi) == 0)
{
mhd_gtls_mpi_release (ret_mpi);
MHD_gtls_mpi_release (ret_mpi);
return GNUTLS_E_MPI_SCAN_FAILED;
}
@@ -80,7 +80,7 @@ mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
}
int
mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
MHD_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
size_t * nbytes)
{
int ret;
@@ -90,9 +90,9 @@ mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
/* MPIs with 0 bits are illegal
*/
if (_gnutls_mpi_get_nbits (*ret_mpi) == 0)
if (MHD__gnutls_mpi_get_nbits (*ret_mpi) == 0)
{
mhd_gtls_mpi_release (ret_mpi);
MHD_gtls_mpi_release (ret_mpi);
return GNUTLS_E_MPI_SCAN_FAILED;
}
@@ -100,7 +100,7 @@ mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
}
int
mhd_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
MHD_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
{
int ret;
@@ -116,7 +116,7 @@ mhd_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
/* Always has the first bit zero */
int
mhd_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
MHD_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
{
int ret;
@@ -132,7 +132,7 @@ mhd_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
/* Always has the first bit zero */
int
mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
MHD_gtls_mpi_dprint_lz (MHD_gnutls_datum_t * dest, const mpi_t a)
{
int ret;
opaque *buf = NULL;
@@ -144,7 +144,7 @@ mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &bytes, a);
if (bytes != 0)
buf = gnutls_malloc (bytes);
buf = MHD_gnutls_malloc (bytes);
if (buf == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -156,12 +156,12 @@ mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
return 0;
}
gnutls_free (buf);
MHD_gnutls_free (buf);
return GNUTLS_E_MPI_PRINT_FAILED;
}
int
mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
MHD_gtls_mpi_dprint (MHD_gnutls_datum_t * dest, const mpi_t a)
{
int ret;
opaque *buf = NULL;
@@ -173,7 +173,7 @@ mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &bytes, a);
if (bytes != 0)
buf = gnutls_malloc (bytes);
buf = MHD_gnutls_malloc (bytes);
if (buf == NULL)
return GNUTLS_E_MEMORY_ERROR;
@@ -185,7 +185,7 @@ mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
return 0;
}
gnutls_free (buf);
MHD_gnutls_free (buf);
return GNUTLS_E_MPI_PRINT_FAILED;
}
@@ -195,7 +195,7 @@ mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
* steps.
*/
int
_gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
MHD__gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
{
int result;
size_t s_len;
@@ -203,37 +203,37 @@ _gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
int tmpstr_size;
tmpstr_size = 0;
result = asn1_read_value (node, value, NULL, &tmpstr_size);
result = MHD__asn1_read_value (node, value, NULL, &tmpstr_size);
if (result != ASN1_MEM_ERROR)
{
gnutls_assert ();
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
return MHD_gtls_asn2err (result);
}
tmpstr = gnutls_alloca (tmpstr_size);
tmpstr = MHD_gnutls_alloca (tmpstr_size);
if (tmpstr == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
result = asn1_read_value (node, value, tmpstr, &tmpstr_size);
result = MHD__asn1_read_value (node, value, tmpstr, &tmpstr_size);
if (result != ASN1_SUCCESS)
{
gnutls_assert ();
gnutls_afree (tmpstr);
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
MHD_gnutls_afree (tmpstr);
return MHD_gtls_asn2err (result);
}
s_len = tmpstr_size;
if (mhd_gtls_mpi_scan (ret_mpi, tmpstr, &s_len) != 0)
if (MHD_gtls_mpi_scan (ret_mpi, tmpstr, &s_len) != 0)
{
gnutls_assert ();
gnutls_afree (tmpstr);
MHD_gnutls_assert ();
MHD_gnutls_afree (tmpstr);
return GNUTLS_E_MPI_SCAN_FAILED;
}
gnutls_afree (tmpstr);
MHD_gnutls_afree (tmpstr);
return 0;
}
@@ -241,7 +241,7 @@ _gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
/* Writes the specified integer into the specified node.
*/
int
_gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
MHD__gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
{
opaque *tmpstr;
size_t s_len;
@@ -249,37 +249,37 @@ _gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
s_len = 0;
if (lz)
result = mhd_gtls_mpi_print_lz (NULL, &s_len, mpi);
result = MHD_gtls_mpi_print_lz (NULL, &s_len, mpi);
else
result = mhd_gtls_mpi_print (NULL, &s_len, mpi);
result = MHD_gtls_mpi_print (NULL, &s_len, mpi);
tmpstr = gnutls_alloca (s_len);
tmpstr = MHD_gnutls_alloca (s_len);
if (tmpstr == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
if (lz)
result = mhd_gtls_mpi_print_lz (tmpstr, &s_len, mpi);
result = MHD_gtls_mpi_print_lz (tmpstr, &s_len, mpi);
else
result = mhd_gtls_mpi_print (tmpstr, &s_len, mpi);
result = MHD_gtls_mpi_print (tmpstr, &s_len, mpi);
if (result != 0)
{
gnutls_assert ();
gnutls_afree (tmpstr);
MHD_gnutls_assert ();
MHD_gnutls_afree (tmpstr);
return GNUTLS_E_MPI_PRINT_FAILED;
}
result = asn1_write_value (node, value, tmpstr, s_len);
result = MHD__asn1_write_value (node, value, tmpstr, s_len);
gnutls_afree (tmpstr);
MHD_gnutls_afree (tmpstr);
if (result != ASN1_SUCCESS)
{
gnutls_assert ();
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
return MHD_gtls_asn2err (result);
}
return 0;
src/daemon/https/tls/gnutls_mpi.h
+33 -33
View File
@@ -33,46 +33,46 @@
typedef gcry_mpi_t mpi_t;
#define _gnutls_mpi_cmp gcry_mpi_cmp
#define _gnutls_mpi_cmp_ui gcry_mpi_cmp_ui
#define _gnutls_mpi_mod gcry_mpi_mod
#define _gnutls_mpi_new gcry_mpi_new
#define _gnutls_mpi_snew gcry_mpi_snew
#define _gnutls_mpi_copy gcry_mpi_copy
#define _gnutls_mpi_set_ui gcry_mpi_set_ui
#define _gnutls_mpi_set gcry_mpi_set
#define _gnutls_mpi_randomize gcry_mpi_randomize
#define _gnutls_mpi_get_nbits gcry_mpi_get_nbits
#define _gnutls_mpi_powm gcry_mpi_powm
#define _gnutls_mpi_invm gcry_mpi_invm
#define _gnutls_mpi_addm gcry_mpi_addm
#define _gnutls_mpi_subm gcry_mpi_subm
#define _gnutls_mpi_sub_ui gcry_mpi_sub_ui
#define _gnutls_mpi_mulm gcry_mpi_mulm
#define _gnutls_mpi_mul gcry_mpi_mul
#define _gnutls_mpi_add gcry_mpi_add
#define _gnutls_mpi_add_ui gcry_mpi_add_ui
#define _gnutls_mpi_sub_ui gcry_mpi_sub_ui
#define _gnutls_mpi_mul_ui gcry_mpi_mul_ui
#define _gnutls_prime_check gcry_prime_check
#define _gnutls_mpi_div gcry_mpi_div
#define MHD__gnutls_mpi_cmp gcry_mpi_cmp
#define MHD__gnutls_mpi_cmp_ui gcry_mpi_cmp_ui
#define MHD__gnutls_mpi_mod gcry_mpi_mod
#define MHD__gnutls_mpi_new gcry_mpi_new
#define MHD__gnutls_mpi_snew gcry_mpi_snew
#define MHD__gnutls_mpi_copy gcry_mpi_copy
#define MHD__gnutls_mpi_set_ui gcry_mpi_set_ui
#define MHD__gnutls_mpi_set gcry_mpi_set
#define MHD__gnutls_mpi_randomize gcry_mpi_randomize
#define MHD__gnutls_mpi_get_nbits gcry_mpi_get_nbits
#define MHD__gnutls_mpi_powm gcry_mpi_powm
#define MHD__gnutls_mpi_invm gcry_mpi_invm
#define MHD__gnutls_mpi_addm gcry_mpi_addm
#define MHD__gnutls_mpi_subm gcry_mpi_subm
#define MHD__gnutls_mpi_sub_ui gcry_mpi_sub_ui
#define MHD__gnutls_mpi_mulm gcry_mpi_mulm
#define MHD__gnutls_mpi_mul gcry_mpi_mul
#define MHD__gnutls_mpi_add gcry_mpi_add
#define MHD__gnutls_mpi_add_ui gcry_mpi_add_ui
#define MHD__gnutls_mpi_sub_ui gcry_mpi_sub_ui
#define MHD__gnutls_mpi_mul_ui gcry_mpi_mul_ui
#define MHD__gnutls_prime_check gcry_prime_check
#define MHD__gnutls_mpi_div gcry_mpi_div
#define _gnutls_mpi_alloc_like(x) _gnutls_mpi_new(_gnutls_mpi_get_nbits(x))
#define _gnutls_mpi_salloc_like(x) _gnutls_mpi_snew(_gnutls_mpi_get_nbits(x))
#define MHD__gnutls_mpi_alloc_like(x) MHD__gnutls_mpi_new(MHD__gnutls_mpi_get_nbits(x))
#define MHD__gnutls_mpi_salloc_like(x) MHD__gnutls_mpi_snew(MHD__gnutls_mpi_get_nbits(x))
void mhd_gtls_mpi_release (mpi_t * x);
void MHD_gtls_mpi_release (mpi_t * x);
int mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer,
int MHD_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer,
size_t * nbytes);
int mhd_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer,
int MHD_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer,
size_t * nbytes);
int mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
int MHD_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
size_t * nbytes);
int mhd_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a);
int mhd_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a);
int MHD_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a);
int MHD_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a);
int mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a);
int mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a);
int MHD_gtls_mpi_dprint_lz (MHD_gnutls_datum_t * dest, const mpi_t a);
int MHD_gtls_mpi_dprint (MHD_gnutls_datum_t * dest, const mpi_t a);
#endif
src/daemon/https/tls/gnutls_num.c
+14 -14
View File
@@ -35,7 +35,7 @@
* has been reached.
*/
int
mhd_gtls_uint64pp (uint64 * x)
MHD_gtls_uint64pp (uint64 * x)
{
register int i, y = 0;
@@ -60,7 +60,7 @@ mhd_gtls_uint64pp (uint64 * x)
}
uint32_t
mhd_gtls_uint24touint32 (uint24 num)
MHD_gtls_uint24touint32 (uint24 num)
{
uint32_t ret = 0;
@@ -71,7 +71,7 @@ mhd_gtls_uint24touint32 (uint24 num)
}
uint24
mhd_gtls_uint32touint24 (uint32_t num)
MHD_gtls_uint32touint24 (uint32_t num)
{
uint24 ret;
@@ -84,7 +84,7 @@ mhd_gtls_uint32touint24 (uint32_t num)
/* data should be at least 3 bytes */
uint32_t
mhd_gtls_read_uint24 (const opaque * data)
MHD_gtls_read_uint24 (const opaque * data)
{
uint32_t res;
uint24 num;
@@ -93,7 +93,7 @@ mhd_gtls_read_uint24 (const opaque * data)
num.pint[1] = data[1];
num.pint[2] = data[2];
res = mhd_gtls_uint24touint32 (num);
res = MHD_gtls_uint24touint32 (num);
#ifndef WORDS_BIGENDIAN
res = byteswap32 (res);
#endif
@@ -101,14 +101,14 @@ mhd_gtls_read_uint24 (const opaque * data)
}
void
mhd_gtls_write_uint24 (uint32_t num, opaque * data)
MHD_gtls_write_uint24 (uint32_t num, opaque * data)
{
uint24 tmp;
#ifndef WORDS_BIGENDIAN
num = byteswap32 (num);
#endif
tmp = mhd_gtls_uint32touint24 (num);
tmp = MHD_gtls_uint32touint24 (num);
data[0] = tmp.pint[0];
data[1] = tmp.pint[1];
@@ -116,7 +116,7 @@ mhd_gtls_write_uint24 (uint32_t num, opaque * data)
}
uint32_t
mhd_gtls_read_uint32 (const opaque * data)
MHD_gtls_read_uint32 (const opaque * data)
{
uint32_t res;
@@ -128,7 +128,7 @@ mhd_gtls_read_uint32 (const opaque * data)
}
void
mhd_gtls_write_uint32 (uint32_t num, opaque * data)
MHD_gtls_write_uint32 (uint32_t num, opaque * data)
{
#ifndef WORDS_BIGENDIAN
@@ -138,7 +138,7 @@ mhd_gtls_write_uint32 (uint32_t num, opaque * data)
}
uint16_t
mhd_gtls_read_uint16 (const opaque * data)
MHD_gtls_read_uint16 (const opaque * data)
{
uint16_t res;
memcpy (&res, data, sizeof (uint16_t));
@@ -149,7 +149,7 @@ mhd_gtls_read_uint16 (const opaque * data)
}
void
mhd_gtls_write_uint16 (uint16_t num, opaque * data)
MHD_gtls_write_uint16 (uint16_t num, opaque * data)
{
#ifndef WORDS_BIGENDIAN
@@ -159,7 +159,7 @@ mhd_gtls_write_uint16 (uint16_t num, opaque * data)
}
uint32_t
mhd_gtls_conv_uint32 (uint32_t data)
MHD_gtls_conv_uint32 (uint32_t data)
{
#ifndef WORDS_BIGENDIAN
return byteswap32 (data);
@@ -169,7 +169,7 @@ mhd_gtls_conv_uint32 (uint32_t data)
}
uint16_t
mhd_gtls_conv_uint16 (uint16_t data)
MHD_gtls_conv_uint16 (uint16_t data)
{
#ifndef WORDS_BIGENDIAN
return byteswap16 (data);
@@ -179,7 +179,7 @@ mhd_gtls_conv_uint16 (uint16_t data)
}
uint32_t
mhd_gtls_uint64touint32 (const uint64 * num)
MHD_gtls_uint64touint32 (const uint64 * num)
{
uint32_t ret;
src/daemon/https/tls/gnutls_num.h
+13 -13
View File
@@ -32,18 +32,18 @@
#define byteswap16(x) ((rotl16(x, 8) & 0x00ff) | (rotr16(x, 8) & 0xff00))
#define byteswap32(x) ((rotl32(x, 8) & 0x00ff00ffUL) | (rotr32(x, 8) & 0xff00ff00UL))
uint32_t mhd_gtls_uint24touint32 (uint24 num);
uint24 mhd_gtls_uint32touint24 (uint32_t num);
uint32_t mhd_gtls_read_uint32 (const opaque * data);
uint16_t mhd_gtls_read_uint16 (const opaque * data);
uint32_t mhd_gtls_conv_uint32 (uint32_t data);
uint16_t mhd_gtls_conv_uint16 (uint16_t data);
uint32_t mhd_gtls_read_uint24 (const opaque * data);
void mhd_gtls_write_uint24 (uint32_t num, opaque * data);
void mhd_gtls_write_uint32 (uint32_t num, opaque * data);
void mhd_gtls_write_uint16 (uint16_t num, opaque * data);
uint32_t mhd_gtls_uint64touint32 (const uint64 *);
uint32_t MHD_gtls_uint24touint32 (uint24 num);
uint24 MHD_gtls_uint32touint24 (uint32_t num);
uint32_t MHD_gtls_read_uint32 (const opaque * data);
uint16_t MHD_gtls_read_uint16 (const opaque * data);
uint32_t MHD_gtls_conv_uint32 (uint32_t data);
uint16_t MHD_gtls_conv_uint16 (uint16_t data);
uint32_t MHD_gtls_read_uint24 (const opaque * data);
void MHD_gtls_write_uint24 (uint32_t num, opaque * data);
void MHD_gtls_write_uint32 (uint32_t num, opaque * data);
void MHD_gtls_write_uint16 (uint16_t num, opaque * data);
uint32_t MHD_gtls_uint64touint32 (const uint64 *);
int mhd_gtls_uint64pp (uint64 *);
# define _gnutls_uint64zero(x) x.i[0] = x.i[1] = x.i[2] = x.i[3] = x.i[4] = x.i[5] = x.i[6] = x.i[7] = 0
int MHD_gtls_uint64pp (uint64 *);
# define MHD__gnutls_uint64zero(x) x.i[0] = x.i[1] = x.i[2] = x.i[3] = x.i[4] = x.i[5] = x.i[6] = x.i[7] = 0
# define UINT64DATA(x) x.i
src/daemon/https/tls/gnutls_pk.c
+158 -158
View File
@@ -40,13 +40,13 @@
#include "common.h"
#include "mpi.h"
static int _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
static int MHD__gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
mpi_t * pkey, int pkey_len);
static int _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash,
static int MHD__gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash,
mpi_t * pkey, int);
static int _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
static int MHD__gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
mpi_t * pkey, int);
static int _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data,
static int MHD__gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data,
mpi_t * pkey, int);
@@ -54,8 +54,8 @@ static int _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data,
* params is modulus, public exp.
*/
int
mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
const gnutls_datum_t * plaintext,
MHD_gtls_pkcs1_rsa_encrypt (MHD_gnutls_datum_t * ciphertext,
const MHD_gnutls_datum_t * plaintext,
mpi_t * params, unsigned params_len,
unsigned btype)
{
@@ -66,21 +66,21 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
size_t k, psize;
size_t mod_bits;
mod_bits = _gnutls_mpi_get_nbits (params[0]);
mod_bits = MHD__gnutls_mpi_get_nbits (params[0]);
k = mod_bits / 8;
if (mod_bits % 8 != 0)
k++;
if (plaintext->size > k - 11)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PK_ENCRYPTION_FAILED;
}
edata = gnutls_alloca (k);
edata = MHD_gnutls_alloca (k);
if (edata == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -99,24 +99,24 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
/* using public key */
if (params_len < RSA_PUBLIC_PARAMS)
{
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_INTERNAL_ERROR;
}
if (gc_pseudo_random (ps, psize) != GC_OK)
if (MHD_gc_pseudo_random (ps, psize) != GC_OK)
{
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_RANDOM_FAILED;
}
for (i = 0; i < psize; i++)
while (ps[i] == 0)
{
if (gc_pseudo_random (&ps[i], 1) != GC_OK)
if (MHD_gc_pseudo_random (&ps[i], 1) != GC_OK)
{
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_RANDOM_FAILED;
}
}
@@ -126,8 +126,8 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
if (params_len < RSA_PRIVATE_PARAMS)
{
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -135,36 +135,36 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
ps[i] = 0xff;
break;
default:
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_INTERNAL_ERROR;
}
ps[psize] = 0;
memcpy (&ps[psize + 1], plaintext->data, plaintext->size);
if (mhd_gtls_mpi_scan_nz (&m, edata, &k) != 0)
if (MHD_gtls_mpi_scan_nz (&m, edata, &k) != 0)
{
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_MPI_SCAN_FAILED;
}
gnutls_afree (edata);
MHD_gnutls_afree (edata);
if (btype == 2) /* encrypt */
ret = _gnutls_pk_encrypt (GCRY_PK_RSA, &res, m, params, params_len);
ret = MHD__gnutls_pk_encrypt (GCRY_PK_RSA, &res, m, params, params_len);
else /* sign */
ret = _gnutls_pk_sign (GCRY_PK_RSA, &res, m, params, params_len);
ret = MHD__gnutls_pk_sign (GCRY_PK_RSA, &res, m, params, params_len);
mhd_gtls_mpi_release (&m);
MHD_gtls_mpi_release (&m);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
mhd_gtls_mpi_print (NULL, &psize, res);
MHD_gtls_mpi_print (NULL, &psize, res);
if (psize < k)
{
@@ -179,25 +179,25 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
else
{ /* psize > k !!! */
/* This is an impossible situation */
gnutls_assert ();
mhd_gtls_mpi_release (&res);
MHD_gnutls_assert ();
MHD_gtls_mpi_release (&res);
return GNUTLS_E_INTERNAL_ERROR;
}
ciphertext->data = gnutls_malloc (psize);
ciphertext->data = MHD_gnutls_malloc (psize);
if (ciphertext->data == NULL)
{
gnutls_assert ();
mhd_gtls_mpi_release (&res);
MHD_gnutls_assert ();
MHD_gtls_mpi_release (&res);
return GNUTLS_E_MEMORY_ERROR;
}
mhd_gtls_mpi_print (&ciphertext->data[pad], &psize, res);
MHD_gtls_mpi_print (&ciphertext->data[pad], &psize, res);
for (i = 0; i < pad; i++)
ciphertext->data[i] = 0;
ciphertext->size = k;
mhd_gtls_mpi_release (&res);
MHD_gtls_mpi_release (&res);
return 0;
}
@@ -208,8 +208,8 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
* Can decrypt block type 1 and type 2 packets.
*/
int
mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
const gnutls_datum_t * ciphertext,
MHD_gtls_pkcs1_rsa_decrypt (MHD_gnutls_datum_t * plaintext,
const MHD_gnutls_datum_t * ciphertext,
mpi_t * params, unsigned params_len,
unsigned btype)
{
@@ -219,7 +219,7 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
opaque *edata;
size_t esize, mod_bits;
mod_bits = _gnutls_mpi_get_nbits (params[0]);
mod_bits = MHD__gnutls_mpi_get_nbits (params[0]);
k = mod_bits / 8;
if (mod_bits % 8 != 0)
k++;
@@ -228,13 +228,13 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
if (esize != k)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PK_DECRYPTION_FAILED;
}
if (mhd_gtls_mpi_scan_nz (&c, ciphertext->data, &esize) != 0)
if (MHD_gtls_mpi_scan_nz (&c, ciphertext->data, &esize) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
@@ -242,30 +242,30 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
* available.
*/
if (btype == 2)
ret = _gnutls_pk_decrypt (GCRY_PK_RSA, &res, c, params, params_len);
ret = MHD__gnutls_pk_decrypt (GCRY_PK_RSA, &res, c, params, params_len);
else
{
ret = _gnutls_pk_encrypt (GCRY_PK_RSA, &res, c, params, params_len);
ret = MHD__gnutls_pk_encrypt (GCRY_PK_RSA, &res, c, params, params_len);
}
mhd_gtls_mpi_release (&c);
MHD_gtls_mpi_release (&c);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
mhd_gtls_mpi_print (NULL, &esize, res);
edata = gnutls_alloca (esize + 1);
MHD_gtls_mpi_print (NULL, &esize, res);
edata = MHD_gnutls_alloca (esize + 1);
if (edata == NULL)
{
gnutls_assert ();
mhd_gtls_mpi_release (&res);
MHD_gnutls_assert ();
MHD_gtls_mpi_release (&res);
return GNUTLS_E_MEMORY_ERROR;
}
mhd_gtls_mpi_print (&edata[1], &esize, res);
MHD_gtls_mpi_print (&edata[1], &esize, res);
mhd_gtls_mpi_release (&res);
MHD_gtls_mpi_release (&res);
/* EB = 00||BT||PS||00||D
* (use block type 'btype')
@@ -282,8 +282,8 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
if (edata[0] != 0 || edata[1] != btype)
{
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_DECRYPTION_FAILED;
}
@@ -310,7 +310,7 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
}
if (edata[i] != 0xff)
{
_gnutls_handshake_log ("PKCS #1 padding error");
MHD__gnutls_handshake_log ("PKCS #1 padding error");
/* PKCS #1 padding error. Don't use
GNUTLS_E_PKCS1_WRONG_PAD here. */
break;
@@ -318,65 +318,65 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
}
break;
default:
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_DECRYPTION_FAILED;
}
i++;
if (ret < 0)
{
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_DECRYPTION_FAILED;
}
if (_gnutls_sset_datum (plaintext, &edata[i], esize - i) < 0)
if (MHD__gnutls_sset_datum (plaintext, &edata[i], esize - i) < 0)
{
gnutls_assert ();
gnutls_afree (edata);
MHD_gnutls_assert ();
MHD_gnutls_afree (edata);
return GNUTLS_E_MEMORY_ERROR;
}
gnutls_afree (edata);
MHD_gnutls_afree (edata);
return 0;
}
int
mhd_gtls_rsa_verify (const gnutls_datum_t * vdata,
const gnutls_datum_t * ciphertext, mpi_t * params,
MHD_gtls_rsa_verify (const MHD_gnutls_datum_t * vdata,
const MHD_gnutls_datum_t * ciphertext, mpi_t * params,
int params_len, int btype)
{
gnutls_datum_t plain;
MHD_gnutls_datum_t plain;
int ret;
/* decrypt signature */
if ((ret =
mhd_gtls_pkcs1_rsa_decrypt (&plain, ciphertext, params, params_len,
MHD_gtls_pkcs1_rsa_decrypt (&plain, ciphertext, params, params_len,
btype)) < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
if (plain.size != vdata->size)
{
gnutls_assert ();
_gnutls_free_datum (&plain);
MHD_gnutls_assert ();
MHD__gnutls_free_datum (&plain);
return GNUTLS_E_PK_SIG_VERIFY_FAILED;
}
if (memcmp (plain.data, vdata->data, plain.size) != 0)
{
gnutls_assert ();
_gnutls_free_datum (&plain);
MHD_gnutls_assert ();
MHD__gnutls_free_datum (&plain);
return GNUTLS_E_PK_SIG_VERIFY_FAILED;
}
_gnutls_free_datum (&plain);
MHD__gnutls_free_datum (&plain);
return 0; /* ok */
}
@@ -384,45 +384,45 @@ mhd_gtls_rsa_verify (const gnutls_datum_t * vdata,
/* encodes the Dss-Sig-Value structure
*/
static int
encode_ber_rs (gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
encode_ber_rs (MHD_gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
{
ASN1_TYPE sig;
int result, tot_len;
if ((result =
asn1_create_element (_gnutls_get_gnutls_asn (),
MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
"GNUTLS.DSASignatureValue",
&sig)) != ASN1_SUCCESS)
{
gnutls_assert ();
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
return MHD_gtls_asn2err (result);
}
result = _gnutls_x509_write_int (sig, "r", r, 1);
result = MHD__gnutls_x509_write_int (sig, "r", r, 1);
if (result < 0)
{
gnutls_assert ();
asn1_delete_structure (&sig);
MHD_gnutls_assert ();
MHD__asn1_delete_structure (&sig);
return result;
}
result = _gnutls_x509_write_int (sig, "s", s, 1);
result = MHD__gnutls_x509_write_int (sig, "s", s, 1);
if (result < 0)
{
gnutls_assert ();
asn1_delete_structure (&sig);
MHD_gnutls_assert ();
MHD__asn1_delete_structure (&sig);
return result;
}
tot_len = 0;
result = _gnutls_x509_der_encode (sig, "", sig_value, 0);
result = MHD__gnutls_x509_der_encode (sig, "", sig_value, 0);
asn1_delete_structure (&sig);
MHD__asn1_delete_structure (&sig);
if (result < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return result;
}
@@ -433,8 +433,8 @@ encode_ber_rs (gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
/* Do DSA signature calculation. params is p, q, g, y, x in that order.
*/
int
mhd_gtls_dsa_sign (gnutls_datum_t * signature,
const gnutls_datum_t * hash, mpi_t * params,
MHD_gtls_dsa_sign (MHD_gnutls_datum_t * signature,
const MHD_gnutls_datum_t * hash, mpi_t * params,
unsigned params_len)
{
mpi_t rs[2], mdata;
@@ -444,35 +444,35 @@ mhd_gtls_dsa_sign (gnutls_datum_t * signature,
k = hash->size;
if (k < 20)
{ /* SHA1 or better only */
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PK_SIGN_FAILED;
}
if (mhd_gtls_mpi_scan_nz (&mdata, hash->data, &k) != 0)
if (MHD_gtls_mpi_scan_nz (&mdata, hash->data, &k) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
ret = _gnutls_pk_sign (GCRY_PK_DSA, rs, mdata, params, params_len);
ret = MHD__gnutls_pk_sign (GCRY_PK_DSA, rs, mdata, params, params_len);
/* rs[0], rs[1] now hold r,s */
mhd_gtls_mpi_release (&mdata);
MHD_gtls_mpi_release (&mdata);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
ret = encode_ber_rs (signature, rs[0], rs[1]);
/* free r,s */
mhd_gtls_mpi_release (&rs[0]);
mhd_gtls_mpi_release (&rs[1]);
MHD_gtls_mpi_release (&rs[0]);
MHD_gtls_mpi_release (&rs[1]);
if (ret != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
@@ -482,46 +482,46 @@ mhd_gtls_dsa_sign (gnutls_datum_t * signature,
/* decodes the Dss-Sig-Value structure
*/
static int
decode_ber_rs (const gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
decode_ber_rs (const MHD_gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
{
ASN1_TYPE sig;
int result;
if ((result =
asn1_create_element (_gnutls_get_gnutls_asn (),
MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
"GNUTLS.DSASignatureValue",
&sig)) != ASN1_SUCCESS)
{
gnutls_assert ();
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
return MHD_gtls_asn2err (result);
}
result = asn1_der_decoding (&sig, sig_value->data, sig_value->size, NULL);
result = MHD__asn1_der_decoding (&sig, sig_value->data, sig_value->size, NULL);
if (result != ASN1_SUCCESS)
{
gnutls_assert ();
asn1_delete_structure (&sig);
return mhd_gtls_asn2err (result);
MHD_gnutls_assert ();
MHD__asn1_delete_structure (&sig);
return MHD_gtls_asn2err (result);
}
result = _gnutls_x509_read_int (sig, "r", r);
result = MHD__gnutls_x509_read_int (sig, "r", r);
if (result < 0)
{
gnutls_assert ();
asn1_delete_structure (&sig);
MHD_gnutls_assert ();
MHD__asn1_delete_structure (&sig);
return result;
}
result = _gnutls_x509_read_int (sig, "s", s);
result = MHD__gnutls_x509_read_int (sig, "s", s);
if (result < 0)
{
gnutls_assert ();
mhd_gtls_mpi_release (s);
asn1_delete_structure (&sig);
MHD_gnutls_assert ();
MHD_gtls_mpi_release (s);
MHD__asn1_delete_structure (&sig);
return result;
}
asn1_delete_structure (&sig);
MHD__asn1_delete_structure (&sig);
return 0;
}
@@ -529,8 +529,8 @@ decode_ber_rs (const gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
/* params is p, q, g, y in that order
*/
int
mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
const gnutls_datum_t * sig_value, mpi_t * params,
MHD_gtls_dsa_verify (const MHD_gnutls_datum_t * vdata,
const MHD_gnutls_datum_t * sig_value, mpi_t * params,
int params_len)
{
@@ -541,34 +541,34 @@ mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
if (vdata->size != 20)
{ /* sha-1 only */
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PK_SIG_VERIFY_FAILED;
}
if (decode_ber_rs (sig_value, &rs[0], &rs[1]) != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
k = vdata->size;
if (mhd_gtls_mpi_scan_nz (&mdata, vdata->data, &k) != 0)
if (MHD_gtls_mpi_scan_nz (&mdata, vdata->data, &k) != 0)
{
gnutls_assert ();
mhd_gtls_mpi_release (&rs[0]);
mhd_gtls_mpi_release (&rs[1]);
MHD_gnutls_assert ();
MHD_gtls_mpi_release (&rs[0]);
MHD_gtls_mpi_release (&rs[1]);
return GNUTLS_E_MPI_SCAN_FAILED;
}
/* decrypt signature */
ret = _gnutls_pk_verify (GCRY_PK_DSA, mdata, rs, params, params_len);
mhd_gtls_mpi_release (&mdata);
mhd_gtls_mpi_release (&rs[0]);
mhd_gtls_mpi_release (&rs[1]);
ret = MHD__gnutls_pk_verify (GCRY_PK_DSA, mdata, rs, params, params_len);
MHD_gtls_mpi_release (&mdata);
MHD_gtls_mpi_release (&rs[0]);
MHD_gtls_mpi_release (&rs[1]);
if (ret < 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return ret;
}
@@ -584,7 +584,7 @@ mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
* change the internal design to directly fit to libgcrypt.
*/
static int
_gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
MHD__gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
mpi_t * pkey, int pkey_len)
{
gcry_sexp_t s_ciph, s_data, s_pkey;
@@ -601,20 +601,20 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
/* put the data into a simple list */
if (gcry_sexp_build (&s_data, NULL, "%m", data))
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_pkey);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -626,7 +626,7 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PK_ENCRYPTION_FAILED;
}
@@ -635,7 +635,7 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
gcry_sexp_t list = gcry_sexp_find_token (s_ciph, "a", 0);
if (list == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_ciph);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -645,7 +645,7 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
if (resarr[0] == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_ciph);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -656,7 +656,7 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
}
static int
_gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
MHD__gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
int pkey_len)
{
gcry_sexp_t s_plain, s_data, s_pkey;
@@ -674,20 +674,20 @@ _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
/* put the data into a simple list */
if (gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))", data))
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_pkey);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -699,7 +699,7 @@ _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PK_DECRYPTION_FAILED;
}
@@ -709,7 +709,7 @@ _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
if (resarr[0] == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_plain);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -723,7 +723,7 @@ _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
/* in case of DSA puts into data, r,s
*/
static int
_gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
MHD__gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
int pkey_len)
{
gcry_sexp_t s_hash, s_key, s_sig;
@@ -739,7 +739,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
pkey[0], pkey[1], pkey[2], pkey[3], pkey[4]);
else
{
gnutls_assert ();
MHD_gnutls_assert ();
}
break;
@@ -751,25 +751,25 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
pkey[4], pkey[5]);
else
{
gnutls_assert ();
MHD_gnutls_assert ();
}
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
/* put the data into a simple list */
if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -780,7 +780,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PK_SIGN_FAILED;
}
@@ -793,7 +793,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
list = gcry_sexp_find_token (s_sig, "r", 0);
if (list == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_sig);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -804,7 +804,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
list = gcry_sexp_find_token (s_sig, "s", 0);
if (list == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_sig);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -817,7 +817,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
list = gcry_sexp_find_token (s_sig, "s", 0);
if (list == NULL)
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_sig);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -833,7 +833,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
static int
_gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
MHD__gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
mpi_t * pkey, int pkey_len)
{
gcry_sexp_t s_sig, s_hash, s_pkey;
@@ -856,20 +856,20 @@ _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_INTERNAL_ERROR;
}
/* put the data into a simple list */
if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_pkey);
return GNUTLS_E_INTERNAL_ERROR;
}
@@ -885,7 +885,7 @@ _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
break;
default:
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_pkey);
gcry_sexp_release (s_hash);
return GNUTLS_E_INTERNAL_ERROR;
@@ -893,7 +893,7 @@ _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
gcry_sexp_release (s_pkey);
gcry_sexp_release (s_hash);
return GNUTLS_E_INTERNAL_ERROR;
@@ -907,7 +907,7 @@ _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
if (rc != 0)
{
gnutls_assert ();
MHD_gnutls_assert ();
return GNUTLS_E_PK_SIG_VERIFY_FAILED;
}
src/daemon/https/tls/gnutls_pk.h
+10 -10
View File
@@ -25,22 +25,22 @@
#ifndef GNUTLS_PK_H
#define GNUTLS_PK_H
int mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
const gnutls_datum_t * plaintext,
int MHD_gtls_pkcs1_rsa_encrypt (MHD_gnutls_datum_t * ciphertext,
const MHD_gnutls_datum_t * plaintext,
mpi_t * params, unsigned params_len,
unsigned btype);
int mhd_gtls_dsa_sign (gnutls_datum_t * signature,
const gnutls_datum_t * plaintext, mpi_t * params,
int MHD_gtls_dsa_sign (MHD_gnutls_datum_t * signature,
const MHD_gnutls_datum_t * plaintext, mpi_t * params,
unsigned params_len);
int mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
const gnutls_datum_t * ciphertext,
int MHD_gtls_pkcs1_rsa_decrypt (MHD_gnutls_datum_t * plaintext,
const MHD_gnutls_datum_t * ciphertext,
mpi_t * params, unsigned params_len,
unsigned btype);
int mhd_gtls_rsa_verify (const gnutls_datum_t * vdata,
const gnutls_datum_t * ciphertext, mpi_t * params,
int MHD_gtls_rsa_verify (const MHD_gnutls_datum_t * vdata,
const MHD_gnutls_datum_t * ciphertext, mpi_t * params,
int params_len, int btype);
int mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
const gnutls_datum_t * sig_value, mpi_t * params,
int MHD_gtls_dsa_verify (const MHD_gnutls_datum_t * vdata,
const MHD_gnutls_datum_t * sig_value, mpi_t * params,
int params_len);
#endif /* GNUTLS_PK_H */
Loaded 100 of 156 files, more files were not shown because too many files have changed in this diff. Show more