done
gl_WARN_ADD([-Wno-missing-field-initializers]) # We need this one
- gl_WARN_ADD([-Wno-sign-compare]) # Too many warnings for now
gl_WARN_ADD([-Wno-format-y2k]) # Too many warnings for now
gl_WARN_ADD([-Wno-suggest-attribute=pure]) # Too many warnings for now
gl_WARN_ADD([-Wno-suggest-attribute=const]) # Too many warnings for now
gl_WARN_ADD([-Wno-suggest-attribute=noreturn]) # Too many warnings for now
- gl_WARN_ADD([-Wno-pointer-sign]) # Too many warnings for now
gl_WARN_ADD([-Wno-unused-value]) # warnings for things we don't want to get
gl_WARN_ADD([-Wno-unused-result]) # warnings for things we don't want to get
gl_WARN_ADD([-Wno-unused-parameter]) # Too many warnings for now
char buffer[MAX_BUF + 1];
const char *err;
gnutls_psk_client_credentials_t pskcred;
- const gnutls_datum_t key = { (char *) "DEADBEEF", 8 };
+ const gnutls_datum_t key = { (void *) "DEADBEEF", 8 };
gnutls_global_init ();
gnutls_x509_crt_t xcrt;
unsigned int obj_list_size = 0;
gnutls_datum_t cinfo;
- int i, ret;
+ int ret;
+ unsigned int i;
obj_list_size = 0;
ret = gnutls_pkcs11_obj_list_import_url (NULL, &obj_list_size, URL,
/* A good idea might be to use gnutls_x509_privkey_get_key_id()
* to obtain a unique ID.
*/
- gnutls_datum_t key_id = { (char *) "\x00\x00\x07", 3 };
+ gnutls_datum_t key_id = { (void *) "\x00\x00\x07", 3 };
gnutls_global_init ();
*/
-#define SA struct sockaddr
#define SOCKET_ERR(err,s) if(err==-1) {perror(s);return(1);}
#define MAX_BUF 1024
#define PORT 5556 /* listen to 5556 port */
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
- int client_len;
+ socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
setsockopt (listen_sd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval,
sizeof (int));
- err = bind (listen_sd, (SA *) & sa_serv, sizeof (sa_serv));
+ err = bind (listen_sd, (struct sockaddr *) & sa_serv, sizeof (sa_serv));
SOCKET_ERR (err, "bind");
err = listen (listen_sd, 1024);
SOCKET_ERR (err, "listen");
{
session = initialize_tls_session ();
- sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
+ sd = accept (listen_sd, (struct sockaddr *) & sa_cli, &client_len);
printf ("- connection from %s, port %d\n",
inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
*/
-#define SA struct sockaddr
#define SOCKET_ERR(err,s) if(err==-1) {perror(s);return(1);}
#define MAX_BUF 1024
#define PORT 5556 /* listen to 5556 port */
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
- int client_len;
+ socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
setsockopt (listen_sd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval,
sizeof (int));
- err = bind (listen_sd, (SA *) & sa_serv, sizeof (sa_serv));
+ err = bind (listen_sd, (struct sockaddr *) & sa_serv, sizeof (sa_serv));
SOCKET_ERR (err, "bind");
err = listen (listen_sd, 1024);
SOCKET_ERR (err, "listen");
{
session = initialize_tls_session ();
- sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
+ sd = accept (listen_sd, (struct sockaddr *) & sa_cli, &client_len);
printf ("- connection from %s, port %d\n",
inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
authentication.
*/
-#define SA struct sockaddr
#define SOCKET_ERR(err,s) if(err==-1) {perror(s);return(1);}
#define MAX_BUF 1024
#define PORT 5556 /* listen to 5556 port */
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
- int client_len;
+ socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
setsockopt (listen_sd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval,
sizeof (int));
- err = bind (listen_sd, (SA *) & sa_serv, sizeof (sa_serv));
+ err = bind (listen_sd, (struct sockaddr *) & sa_serv, sizeof (sa_serv));
SOCKET_ERR (err, "bind");
err = listen (listen_sd, 1024);
SOCKET_ERR (err, "listen");
{
session = initialize_tls_session ();
- sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
+ sd = accept (listen_sd, (struct sockaddr *) & sa_cli, &client_len);
printf ("- connection from %s, port %d\n",
inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
/* This is a sample TLS-SRP echo server.
*/
-#define SA struct sockaddr
#define SOCKET_ERR(err,s) if(err==-1) {perror(s);return(1);}
#define MAX_BUF 1024
#define PORT 5556 /* listen to 5556 port */
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
- int client_len;
+ socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
setsockopt (listen_sd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval,
sizeof (int));
- err = bind (listen_sd, (SA *) & sa_serv, sizeof (sa_serv));
+ err = bind (listen_sd, (struct sockaddr *) & sa_serv, sizeof (sa_serv));
SOCKET_ERR (err, "bind");
err = listen (listen_sd, 1024);
SOCKET_ERR (err, "listen");
{
session = initialize_tls_session ();
- sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
+ sd = accept (listen_sd, (struct sockaddr *) & sa_cli, &client_len);
printf ("- connection from %s, port %d\n",
inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
- int client_len;
+ socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
#include <netinet/in.h>
#include <unistd.h>
-#define SA struct sockaddr
-
/* tcp.c */
int tcp_connect (void);
void tcp_close (int sd);
sa.sin_port = htons (atoi (PORT));
inet_pton (AF_INET, SERVER, &sa.sin_addr);
- err = connect (sd, (SA *) & sa, sizeof (sa));
+ err = connect (sd, (struct sockaddr *) & sa, sizeof (sa));
if (err < 0)
{
fprintf (stderr, "Connect error\n");
gnutls_digest_algorithm_t _gnutls_dsa_q_to_hash (gnutls_pk_algorithm_t algo,
- const gnutls_pk_params_st* params, int* hash_len);
+ const gnutls_pk_params_st* params, unsigned int* hash_len);
#endif
{
struct session_op sess;
struct crypt_op cryp;
- opaque iv[EALG_MAX_BLOCK_LEN];
- opaque key[CRYPTO_CIPHER_MAX_KEY_LEN];
+ uint8_t iv[EALG_MAX_BLOCK_LEN];
+ uint8_t key[CRYPTO_CIPHER_MAX_KEY_LEN];
int cfd;
};
/* Functions for cipher suites. */
int _gnutls_supported_ciphersuites (gnutls_session_t session,
- uint8_t* cipher_suites, int max_cipher_suite_size);
+ uint8_t* cipher_suites,
+ unsigned int max_cipher_suite_size);
const char *_gnutls_cipher_suite_get_name (const uint8_t suite[2]);
gnutls_mac_algorithm_t _gnutls_cipher_suite_get_prf (const uint8_t suite[2]);
gnutls_cipher_algorithm_t _gnutls_cipher_suite_get_cipher_algo (const
-*/
int
_gnutls_supported_ciphersuites (gnutls_session_t session,
- uint8_t *cipher_suites, int max_cipher_suite_size)
+ uint8_t *cipher_suites, unsigned int max_cipher_suite_size)
{
unsigned int i, ret_count, j, z, k=0;
const gnutls_cipher_suite_entry * ce;
- int version = gnutls_protocol_get_version( session);
+ unsigned int version = gnutls_protocol_get_version( session);
for (i = 0; i < session->internals.priorities.kx.algorithms; i++)
for (j = 0; j < session->internals.priorities.cipher.algorithms; j++)
int
gnutls_priority_get_cipher_suite_index (gnutls_priority_t pcache, unsigned int idx, unsigned int *sidx)
{
-int mac_idx, cipher_idx, kx_idx, i;
-int total = pcache->mac.algorithms * pcache->cipher.algorithms * pcache->kx.algorithms;
+int mac_idx, cipher_idx, kx_idx;
+unsigned int i;
+unsigned int total = pcache->mac.algorithms * pcache->cipher.algorithms * pcache->kx.algorithms;
if (idx >= total)
return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
{
const char *name;
gnutls_sec_param_t sec_param;
- int bits; /* security level */
- int pk_bits; /* DH, RSA, SRP */
- int dsa_bits; /* bits for DSA. Handled differently since
+ unsigned int bits; /* security level */
+ unsigned int pk_bits; /* DH, RSA, SRP */
+ unsigned int dsa_bits; /* bits for DSA. Handled differently since
* choice of key size in DSA is political.
*/
- int subgroup_bits; /* subgroup bits */
- int ecc_bits; /* bits for ECC keys */
+ unsigned int subgroup_bits; /* subgroup bits */
+ unsigned int ecc_bits; /* bits for ECC keys */
} gnutls_sec_params_entry;
static const gnutls_sec_params_entry sec_params[] = {
#include <auth/dh_common.h>
static int gen_anon_server_kx (gnutls_session_t, gnutls_buffer_st*);
-static int proc_anon_client_kx (gnutls_session_t, opaque *, size_t);
-static int proc_anon_server_kx (gnutls_session_t, opaque *, size_t);
+static int proc_anon_client_kx (gnutls_session_t, uint8_t *, size_t);
+static int proc_anon_server_kx (gnutls_session_t, uint8_t *, size_t);
const mod_auth_st anon_auth_struct = {
"ANON",
static int
-proc_anon_client_kx (gnutls_session_t session, opaque * data,
+proc_anon_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
gnutls_anon_server_credentials_t cred;
}
int
-proc_anon_server_kx (gnutls_session_t session, opaque * data,
+proc_anon_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
#include <ext/ecc.h>
static int gen_anon_ecdh_server_kx (gnutls_session_t, gnutls_buffer_st*);
-static int proc_anon_ecdh_client_kx (gnutls_session_t, opaque *, size_t);
-static int proc_anon_ecdh_server_kx (gnutls_session_t, opaque *, size_t);
+static int proc_anon_ecdh_client_kx (gnutls_session_t, uint8_t *, size_t);
+static int proc_anon_ecdh_server_kx (gnutls_session_t, uint8_t *, size_t);
const mod_auth_st anon_ecdh_auth_struct = {
"ANON ECDH",
static int
-proc_anon_ecdh_client_kx (gnutls_session_t session, opaque * data,
+proc_anon_ecdh_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
gnutls_anon_server_credentials_t cred;
}
int
-proc_anon_ecdh_server_kx (gnutls_session_t session, opaque * data,
+proc_anon_ecdh_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
*/
static int
_find_x509_cert (const gnutls_certificate_credentials_t cred,
- opaque * _data, size_t _data_size,
+ uint8_t * _data, size_t _data_size,
const gnutls_pk_algorithm_t * pk_algos,
int pk_algos_length, int *indx)
{
unsigned size;
gnutls_datum_t odn = { NULL, 0 };
- opaque *data = _data;
+ uint8_t *data = _data;
ssize_t data_size = _data_size;
unsigned i, j;
int result, cert_pk;
* certificate request packet.
*/
static int
-get_issuers_num (gnutls_session_t session, opaque * data, ssize_t data_size)
+get_issuers_num (gnutls_session_t session, uint8_t * data, ssize_t data_size)
{
int issuers_dn_len = 0, result;
unsigned size;
static int
get_issuers (gnutls_session_t session,
gnutls_datum_t * issuers_dn, int issuers_len,
- opaque * data, size_t data_size)
+ uint8_t * data, size_t data_size)
{
int i;
unsigned size;
*/
static int
_select_client_cert (gnutls_session_t session,
- opaque * _data, size_t _data_size,
+ uint8_t * _data, size_t _data_size,
gnutls_pk_algorithm_t * pk_algos, int pk_algos_length)
{
int result;
int indx = -1;
gnutls_certificate_credentials_t cred;
- opaque *data = _data;
+ uint8_t *data = _data;
ssize_t data_size = _data_size;
int issuers_dn_length;
gnutls_datum_t *issuers_dn = NULL;
#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) gnutls_pcert_deinit(&peer_certificate_list[x])
static int
_gnutls_proc_x509_server_certificate (gnutls_session_t session,
- opaque * data, size_t data_size)
+ uint8_t * data, size_t data_size)
{
int size, len, ret;
- opaque *p = data;
+ uint8_t *p = data;
cert_auth_info_t info;
gnutls_certificate_credentials_t cred;
ssize_t dsize = data_size;
#ifdef ENABLE_OPENPGP
static int
_gnutls_proc_openpgp_server_certificate (gnutls_session_t session,
- opaque * data, size_t data_size)
+ uint8_t * data, size_t data_size)
{
int size, ret, len;
- opaque *p = data;
+ uint8_t *p = data;
cert_auth_info_t info;
gnutls_certificate_credentials_t cred;
ssize_t dsize = data_size;
int
_gnutls_proc_certificate (gnutls_session_t session,
- opaque * data, size_t data_size)
+ uint8_t * data, size_t data_size)
{
int ret;
gnutls_certificate_credentials_t cred;
}
int
-_gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
+_gnutls_proc_cert_cert_req (gnutls_session_t session, uint8_t * data,
size_t data_size)
{
int size, ret;
- opaque *p;
+ uint8_t *p;
gnutls_certificate_credentials_t cred;
ssize_t dsize;
int i;
int
_gnutls_proc_cert_client_cert_vrfy (gnutls_session_t session,
- opaque * data, size_t data_size)
+ uint8_t * data, size_t data_size)
{
int size, ret;
ssize_t dsize = data_size;
- opaque *pdata = data;
+ uint8_t *pdata = data;
gnutls_datum_t sig;
cert_auth_info_t info = _gnutls_get_auth_info (session);
gnutls_pcert_st peer_cert;
/* Otherwise... */
- get_server_name(session, server_name, sizeof(server_name));
+ get_server_name(session, (unsigned char*)server_name, sizeof(server_name));
idx = -1; /* default is use no certificate */
int _gnutls_gen_cert_client_certificate (gnutls_session_t, gnutls_buffer_st *);
int _gnutls_gen_cert_client_cert_vrfy (gnutls_session_t, gnutls_buffer_st *);
int _gnutls_gen_cert_server_cert_req (gnutls_session_t, gnutls_buffer_st *);
-int _gnutls_proc_cert_cert_req (gnutls_session_t, opaque *, size_t);
-int _gnutls_proc_cert_client_cert_vrfy (gnutls_session_t, opaque *, size_t);
-int _gnutls_proc_certificate (gnutls_session_t, opaque *, size_t);
+int _gnutls_proc_cert_cert_req (gnutls_session_t, uint8_t *, size_t);
+int _gnutls_proc_cert_client_cert_vrfy (gnutls_session_t, uint8_t *, size_t);
+int _gnutls_proc_certificate (gnutls_session_t, uint8_t *, size_t);
int _gnutls_get_selected_cert (gnutls_session_t session,
gnutls_pcert_st ** apr_cert_list,
int *apr_cert_list_length,
int
_gnutls_proc_dh_common_client_kx (gnutls_session_t session,
- opaque * data, size_t _data_size,
+ uint8_t * data, size_t _data_size,
bigint_t g, bigint_t p,
gnutls_datum_t* psk_key)
{
/* Returns the bytes parsed */
int
_gnutls_proc_dh_common_server_kx (gnutls_session_t session,
- opaque * data, size_t _data_size)
+ uint8_t * data, size_t _data_size)
{
uint16_t n_Y, n_g, n_p;
size_t _n_Y, _n_g, _n_p;
int _gnutls_gen_dh_common_client_kx_int (gnutls_session_t, gnutls_buffer_st*, gnutls_datum_t *pskkey);
int _gnutls_gen_dh_common_client_kx (gnutls_session_t, gnutls_buffer_st*);
int _gnutls_proc_dh_common_client_kx (gnutls_session_t session,
- opaque * data, size_t _data_size,
+ uint8_t * data, size_t _data_size,
bigint_t p, bigint_t g,
gnutls_datum_t* psk_key);
int _gnutls_dh_common_print_server_kx (gnutls_session_t, bigint_t g,
bigint_t p, unsigned int q_bits,
gnutls_buffer_st* data);
-int _gnutls_proc_dh_common_server_kx (gnutls_session_t session, opaque * data,
+int _gnutls_proc_dh_common_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size);
#endif
#include <auth/ecdh_common.h>
static int gen_dhe_server_kx (gnutls_session_t, gnutls_buffer_st*);
-static int proc_dhe_server_kx (gnutls_session_t, opaque *, size_t);
-static int proc_dhe_client_kx (gnutls_session_t, opaque *, size_t);
+static int proc_dhe_server_kx (gnutls_session_t, uint8_t *, size_t);
+static int proc_dhe_client_kx (gnutls_session_t, uint8_t *, size_t);
const mod_auth_st ecdhe_ecdsa_auth_struct = {
"ECDHE_ECDSA",
}
static int
-proc_dhe_server_kx (gnutls_session_t session, opaque * data,
+proc_dhe_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
int sigsize;
- opaque *sigdata;
+ uint8_t *sigdata;
gnutls_datum_t vparams, signature;
int ret;
cert_auth_info_t info = _gnutls_get_auth_info (session);
static int
-proc_dhe_client_kx (gnutls_session_t session, opaque * data,
+proc_dhe_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
gnutls_certificate_credentials_t cred;
static int gen_psk_server_kx (gnutls_session_t, gnutls_buffer_st*);
static int gen_psk_client_kx (gnutls_session_t, gnutls_buffer_st*);
-static int proc_psk_client_kx (gnutls_session_t, opaque *, size_t);
-static int proc_psk_server_kx (gnutls_session_t, opaque *, size_t);
+static int proc_psk_client_kx (gnutls_session_t, uint8_t *, size_t);
+static int proc_psk_server_kx (gnutls_session_t, uint8_t *, size_t);
static int gen_ecdhe_psk_server_kx (gnutls_session_t session, gnutls_buffer_st* data);
-static int proc_ecdhe_psk_client_kx (gnutls_session_t session, opaque * data,
+static int proc_ecdhe_psk_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size);
const mod_auth_st dhe_psk_auth_struct = {
static int
-proc_psk_client_kx (gnutls_session_t session, opaque * data,
+proc_psk_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
int ret;
}
static int
-proc_ecdhe_psk_client_kx (gnutls_session_t session, opaque * data,
+proc_ecdhe_psk_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
int ret;
}
int
-proc_psk_server_kx (gnutls_session_t session, opaque * data,
+proc_psk_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
int
_gnutls_proc_ecdh_common_client_kx (gnutls_session_t session,
- opaque * data, size_t _data_size,
+ uint8_t * data, size_t _data_size,
gnutls_ecc_curve_t curve,
gnutls_datum_t *psk_key)
{
/* Returns the bytes parsed */
int
_gnutls_proc_ecdh_common_server_kx (gnutls_session_t session,
- opaque * data, size_t _data_size)
+ uint8_t * data, size_t _data_size)
{
int i, ret, point_size;
gnutls_ecc_curve_t curve;
int _gnutls_ecdh_common_print_server_kx (gnutls_session_t session, gnutls_buffer_st* data,
gnutls_ecc_curve_t curve)
{
- opaque p;
+ uint8_t p;
int ret;
gnutls_datum_t out;
int
_gnutls_proc_ecdh_common_client_kx (gnutls_session_t session,
- opaque * data, size_t _data_size,
+ uint8_t * data, size_t _data_size,
gnutls_ecc_curve_t curve,
gnutls_datum_t *psk_key);
int _gnutls_ecdh_common_print_server_kx (gnutls_session_t, gnutls_buffer_st* data,
gnutls_ecc_curve_t curve);
-int _gnutls_proc_ecdh_common_server_kx (gnutls_session_t session, opaque * data,
+int _gnutls_proc_ecdh_common_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size);
int _gnutls_gen_psk_server_kx (gnutls_session_t session, gnutls_buffer_st* data);
int _gnutls_gen_psk_client_kx (gnutls_session_t, gnutls_buffer_st*);
-int _gnutls_proc_psk_client_kx (gnutls_session_t, opaque *, size_t);
+int _gnutls_proc_psk_client_kx (gnutls_session_t, uint8_t *, size_t);
-int _gnutls_proc_psk_server_kx (gnutls_session_t session, opaque * data,
+int _gnutls_proc_psk_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size);
const mod_auth_st psk_auth_struct = {
if (ret)
return gnutls_assert_val(ret);
- username->data = user_p;
+ username->data = (uint8_t*)user_p;
username->size = strlen(user_p);
*free = 1;
*
* struct {
* select (KeyExchangeAlgorithm) {
- * opaque psk_identity<0..2^16-1>;
+ * uint8_t psk_identity<0..2^16-1>;
* } exchange_keys;
* } ClientKeyExchange;
*
/* just read the username from the client key exchange.
*/
int
-_gnutls_proc_psk_client_kx (gnutls_session_t session, opaque * data,
+_gnutls_proc_psk_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
ssize_t data_size = _data_size;
* select (KeyExchangeAlgorithm) {
* // other cases for rsa, diffie_hellman, etc.
* case psk: // NEW
- * opaque psk_identity_hint<0..2^16-1>;
+ * uint8_t psk_identity_hint<0..2^16-1>;
* };
* } ServerKeyExchange;
*
return GNUTLS_E_INT_RET_0;
}
- hint.data = cred->hint;
+ hint.data = (uint8_t*)cred->hint;
hint.size = strlen (cred->hint);
return _gnutls_buffer_append_data_prefix(data, 16, hint.data, hint.size);
/* just read the hint from the server key exchange.
*/
int
-_gnutls_proc_psk_server_kx (gnutls_session_t session, opaque * data,
+_gnutls_proc_psk_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
ssize_t data_size = _data_size;
return GNUTLS_E_MEMORY_ERROR;
}
- ret = _gnutls_hex2bin ((opaque *) p, len, psk->data, &size);
+ ret = _gnutls_hex2bin (p, len, psk->data, &size);
psk->size = (unsigned int) size;
if (ret < 0)
{
#include <abstract_int.h>
int _gnutls_gen_rsa_client_kx (gnutls_session_t, gnutls_buffer_st*);
-static int proc_rsa_client_kx (gnutls_session_t, opaque *, size_t);
+static int proc_rsa_client_kx (gnutls_session_t, uint8_t *, size_t);
const mod_auth_st rsa_auth_struct = {
"RSA",
int ret;
cert_auth_info_t info;
gnutls_pcert_st peer_cert;
- int i;
+ unsigned int i;
/* normal non export case */
}
static int
-proc_rsa_client_kx (gnutls_session_t session, opaque * data,
+proc_rsa_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
gnutls_datum_t plaintext;
int _gnutls_gen_rsa_client_kx (gnutls_session_t, gnutls_buffer_st*);
static int gen_rsa_export_server_kx (gnutls_session_t, gnutls_buffer_st*);
-static int proc_rsa_export_server_kx (gnutls_session_t, opaque *, size_t);
-static int proc_rsa_export_client_kx (gnutls_session_t session, opaque * data,
+static int proc_rsa_export_server_kx (gnutls_session_t, uint8_t *, size_t);
+static int proc_rsa_export_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size);
const mod_auth_st rsa_export_auth_struct = {
}
int
-proc_rsa_export_client_kx (gnutls_session_t session, opaque * data,
+proc_rsa_export_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
gnutls_datum_t plaintext;
static int
proc_rsa_export_server_kx (gnutls_session_t session,
- opaque * data, size_t _data_size)
+ uint8_t * data, size_t _data_size)
{
uint16_t n_m, n_e;
size_t _n_m, _n_e;
/* just read A and put it to session */
int
-_gnutls_proc_srp_client_kx (gnutls_session_t session, opaque * data,
+_gnutls_proc_srp_client_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
size_t _n_A;
/* Check if G and N are parameters from the SRP draft.
*/
static int
-check_g_n (const opaque * g, size_t n_g, const opaque * n, size_t n_n)
+check_g_n (const uint8_t * g, size_t n_g, const uint8_t * n, size_t n_n)
{
if ((n_n == sizeof (srp_params_3072) &&
/* receive the key exchange message ( n, g, s, B)
*/
int
-_gnutls_proc_srp_server_kx (gnutls_session_t session, opaque * data,
+_gnutls_proc_srp_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
uint8_t n_s;
const uint8_t *data_s;
const uint8_t *data_b;
int i, ret;
- opaque hd[SRP_MAX_HASH_SIZE];
+ uint8_t hd[SRP_MAX_HASH_SIZE];
char *username, *password;
ssize_t data_size = _data_size;
gnutls_srp_client_credentials_t cred;
* (or the equivalent using bcrypt)
*/
if ((ret =
- _gnutls_calc_srp_x (username, password, (opaque *) data_s, n_s,
+ _gnutls_calc_srp_x (username, password, (uint8_t *) data_s, n_s,
&_n_g, hd)) < 0)
{
gnutls_assert ();
#ifdef ENABLE_SRP
int _gnutls_proc_srp_server_hello (gnutls_session_t state,
- const opaque * data, size_t data_size);
-int _gnutls_gen_srp_server_hello (gnutls_session_t state, opaque * data,
+ const uint8_t * data, size_t data_size);
+int _gnutls_gen_srp_server_hello (gnutls_session_t state, uint8_t * data,
size_t data_size);
int _gnutls_gen_srp_server_kx (gnutls_session_t, gnutls_buffer_st*);
int _gnutls_gen_srp_client_kx (gnutls_session_t, gnutls_buffer_st*);
-int _gnutls_proc_srp_server_kx (gnutls_session_t, opaque *, size_t);
-int _gnutls_proc_srp_client_kx (gnutls_session_t, opaque *, size_t);
+int _gnutls_proc_srp_server_kx (gnutls_session_t, uint8_t *, size_t);
+int _gnutls_proc_srp_client_kx (gnutls_session_t, uint8_t *, size_t);
typedef struct srp_server_auth_info_st srp_server_auth_info_st;
{
char *p;
int len, ret;
- opaque *verifier;
+ uint8_t *verifier;
size_t verifier_size;
int indx;
{
char *p;
int len;
- opaque *tmp;
+ uint8_t *tmp;
int ret;
p = strrchr (str, ':'); /* we have g */
int _gnutls_srp_pwd_read_entry (gnutls_session_t state, char *username,
SRP_PWD_ENTRY **);
void _gnutls_srp_entry_free (SRP_PWD_ENTRY * entry);
-int _gnutls_sbase64_decode (uint8_t * data, size_t data_size,
+int _gnutls_sbase64_decode (char * data, size_t data_size,
uint8_t ** result);
#endif /* ENABLE_SRP */
#include <gnutls_x509.h>
static int gen_srp_cert_server_kx (gnutls_session_t, gnutls_buffer_st*);
-static int proc_srp_cert_server_kx (gnutls_session_t, opaque *, size_t);
+static int proc_srp_cert_server_kx (gnutls_session_t, uint8_t *, size_t);
const mod_auth_st srp_rsa_auth_struct = {
"SRP",
}
static int
-proc_srp_cert_server_kx (gnutls_session_t session, opaque * data,
+proc_srp_cert_server_kx (gnutls_session_t session, uint8_t * data,
size_t _data_size)
{
ssize_t ret;
ssize_t data_size;
cert_auth_info_t info;
gnutls_pcert_st peer_cert;
- opaque *p;
+ uint8_t *p;
ret = _gnutls_proc_srp_server_kx (session, data, _data_size);
if (ret < 0)
* The result_size is the return value
*/
static int
-_gnutls_sbase64_encode (uint8_t * data, size_t data_size, uint8_t ** result)
+_gnutls_sbase64_encode (uint8_t * data, size_t data_size, char ** result)
{
unsigned i, j;
int ret, tmp;
- opaque tmpres[4];
+ uint8_t tmpres[4];
int mod = data_size % 3;
ret = mod;
* before calling it.
*/
int
-_gnutls_sbase64_decode (uint8_t * data, size_t idata_size, uint8_t ** result)
+_gnutls_sbase64_decode (char * data, size_t idata_size, uint8_t ** result)
{
unsigned i, j;
int ret, left;
/* rest data */
for (i = left, j = tmp; i < idata_size; i += 4)
{
- tmp = decode (tmpres, &data[i]);
+ tmp = decode (tmpres, (uint8_t*)&data[i]);
if (tmp < 0)
{
gnutls_free ((*result));
gnutls_srp_base64_encode (const gnutls_datum_t * data, char *result,
size_t * result_size)
{
- opaque *ret;
+ char *res;
int size;
- size = _gnutls_sbase64_encode (data->data, data->size, &ret);
+ size = _gnutls_sbase64_encode (data->data, data->size, &res);
if (size < 0)
return size;
if (result == NULL || *result_size < (size_t) size)
{
- gnutls_free (ret);
+ gnutls_free (res);
*result_size = size;
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
else
{
- memcpy (result, ret, size);
- gnutls_free (ret);
+ memcpy (result, res, size);
+ gnutls_free (res);
*result_size = size;
}
gnutls_srp_base64_encode_alloc (const gnutls_datum_t * data,
gnutls_datum_t * result)
{
- opaque *ret;
+ char *res;
int size;
- size = _gnutls_sbase64_encode (data->data, data->size, &ret);
+ size = _gnutls_sbase64_encode (data->data, data->size, &res);
if (size < 0)
return size;
if (result == NULL)
{
- gnutls_free (ret);
+ gnutls_free (res);
return GNUTLS_E_INVALID_REQUEST;
}
else
{
- result->data = ret;
+ result->data = (uint8_t*)res;
result->size = size;
}
gnutls_srp_base64_decode (const gnutls_datum_t * b64_data, char *result,
size_t * result_size)
{
- opaque *ret;
+ uint8_t *res;
int size;
- size = _gnutls_sbase64_decode (b64_data->data, b64_data->size, &ret);
+ size = _gnutls_sbase64_decode ((char*)b64_data->data, b64_data->size, &res);
if (size < 0)
return size;
if (result == NULL || *result_size < (size_t) size)
{
- gnutls_free (ret);
+ gnutls_free (res);
*result_size = size;
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
else
{
- memcpy (result, ret, size);
- gnutls_free (ret);
+ memcpy (result, res, size);
+ gnutls_free (res);
*result_size = size;
}
gnutls_srp_base64_decode_alloc (const gnutls_datum_t * b64_data,
gnutls_datum_t * result)
{
- opaque *ret;
+ uint8_t *ret;
int size;
- size = _gnutls_sbase64_decode (b64_data->data, b64_data->size, &ret);
+ size = _gnutls_sbase64_decode ((char*)b64_data->data, b64_data->size, &ret);
if (size < 0)
return size;
inline static int _gnutls_num2cert_type (int num);
inline static int _gnutls_cert_type2num (int record_size);
static int _gnutls_cert_type_recv_params (gnutls_session_t session,
- const opaque * data,
+ const uint8_t * data,
size_t data_size);
static int _gnutls_cert_type_send_params (gnutls_session_t session,
gnutls_buffer_st * extdata);
static int
_gnutls_cert_type_recv_params (gnutls_session_t session,
- const opaque * data, size_t _data_size)
+ const uint8_t * data, size_t _data_size)
{
int new_type = -1, ret, i;
ssize_t data_size = _data_size;
*/
static int _gnutls_supported_ecc_recv_params (gnutls_session_t session,
- const opaque * data,
+ const uint8_t * data,
size_t data_size);
static int _gnutls_supported_ecc_send_params (gnutls_session_t session,
gnutls_buffer_st * extdata);
static int _gnutls_supported_ecc_pf_recv_params (gnutls_session_t session,
- const opaque * data,
+ const uint8_t * data,
size_t data_size);
static int _gnutls_supported_ecc_pf_send_params (gnutls_session_t session,
gnutls_buffer_st * extdata);
*/
static int
_gnutls_supported_ecc_recv_params (gnutls_session_t session,
- const opaque * data, size_t _data_size)
+ const uint8_t * data, size_t _data_size)
{
int new_type = -1, ret, i;
ssize_t data_size = _data_size;
uint16_t len;
- const opaque* p = data;
+ const uint8_t* p = data;
if (session->security_parameters.entity == GNUTLS_CLIENT)
{
*/
static int
_gnutls_supported_ecc_pf_recv_params (gnutls_session_t session,
- const opaque * data, size_t _data_size)
+ const uint8_t * data, size_t _data_size)
{
int len, i;
int uncompressed = 0;
static int
_gnutls_supported_ecc_pf_send_params (gnutls_session_t session, gnutls_buffer_st* extdata)
{
- const opaque p[2] = {0x01, 0x00}; /* only support uncompressed point format */
+ const uint8_t p[2] = {0x01, 0x00}; /* only support uncompressed point format */
if (session->security_parameters.entity == GNUTLS_SERVER && !_gnutls_session_is_ecc(session))
return 0;
* session. A negative error value is returned otherwise.
*/
int
-_gnutls_session_supports_ecc_curve (gnutls_session_t session, int ecc_type)
+_gnutls_session_supports_ecc_curve (gnutls_session_t session, unsigned int ecc_type)
{
unsigned i;
extern extension_entry_st ext_mod_supported_ecc_pf;
int
-_gnutls_session_supports_ecc_curve (gnutls_session_t session, int ecc_type);
+_gnutls_session_supports_ecc_curve (gnutls_session_t session, unsigned int ecc_type);
#endif
#include <ext/max_record.h>
static int _gnutls_max_record_recv_params (gnutls_session_t session,
- const opaque * data,
+ const uint8_t * data,
size_t data_size);
static int _gnutls_max_record_send_params (gnutls_session_t session,
gnutls_buffer_st* extdata);
static int
_gnutls_max_record_recv_params (gnutls_session_t session,
- const opaque * data, size_t _data_size)
+ const uint8_t * data, size_t _data_size)
{
ssize_t new_size;
ssize_t data_size = _data_size;
static int _gnutls_sr_recv_params (gnutls_session_t state,
- const opaque * data, size_t data_size);
+ const uint8_t * data, size_t data_size);
static int _gnutls_sr_send_params (gnutls_session_t state, gnutls_buffer_st*);
static void _gnutls_sr_deinit_data (extension_priv_data_t priv);
static int
_gnutls_sr_recv_params (gnutls_session_t session,
- const opaque * data, size_t _data_size)
+ const uint8_t * data, size_t _data_size)
{
- int len = data[0];
+ unsigned int len = data[0];
ssize_t data_size = _data_size;
sr_ext_st *priv;
extension_priv_data_t epriv;
#include <ext/server_name.h>
static int _gnutls_server_name_recv_params (gnutls_session_t session,
- const opaque * data,
+ const uint8_t * data,
size_t data_size);
static int _gnutls_server_name_send_params (gnutls_session_t session,
gnutls_buffer_st* extdata);
*/
static int
_gnutls_server_name_recv_params (gnutls_session_t session,
- const opaque * data, size_t _data_size)
+ const uint8_t * data, size_t _data_size)
{
int i;
const unsigned char *p;
_gnutls_server_name_pack (extension_priv_data_t epriv, gnutls_buffer_st * ps)
{
server_name_ext_st *priv = epriv.ptr;
- int i, ret;
+ unsigned int i;
+ int ret;
BUFFER_APPEND_NUM (ps, priv->server_names_size);
for (i = 0; i < priv->server_names_size; i++)
extension_priv_data_t * _priv)
{
server_name_ext_st *priv;
- int i, ret;
+ unsigned int i;
+ int ret;
extension_priv_data_t epriv;
priv = gnutls_calloc (1, sizeof (*priv));
typedef struct
{
- opaque name[MAX_SERVER_NAME_SIZE];
+ uint8_t name[MAX_SERVER_NAME_SIZE];
unsigned name_length;
gnutls_server_name_type_t type;
} server_name_st;
#define MAC_SIZE 32
static int session_ticket_recv_params (gnutls_session_t session,
- const opaque * data, size_t data_size);
+ const uint8_t * data, size_t data_size);
static int session_ticket_send_params (gnutls_session_t session,
gnutls_buffer_st* extdata);
static int session_ticket_unpack (gnutls_buffer_st * ps,
{
int session_ticket_enable;
int session_ticket_renew;
- opaque session_ticket_IV[SESSION_TICKET_IV_SIZE];
+ uint8_t session_ticket_IV[SESSION_TICKET_IV_SIZE];
- opaque *session_ticket;
+ uint8_t *session_ticket;
int session_ticket_len;
- opaque key[SESSION_KEY_SIZE];
+ uint8_t key[SESSION_KEY_SIZE];
} session_ticket_ext_st;
struct ticket
{
- opaque key_name[KEY_NAME_SIZE];
- opaque IV[IV_SIZE];
- opaque *encrypted_state;
+ uint8_t key_name[KEY_NAME_SIZE];
+ uint8_t IV[IV_SIZE];
+ uint8_t *encrypted_state;
uint16_t encrypted_state_len;
- opaque mac[MAC_SIZE];
+ uint8_t mac[MAC_SIZE];
};
static int
digest_ticket (const gnutls_datum_t * key, struct ticket *ticket,
- opaque * digest)
+ uint8_t * digest)
{
digest_hd_st digest_hd;
uint16_t length16;
{
cipher_hd_st cipher_hd;
gnutls_datum_t key, IV, mac_secret, state;
- opaque final[MAC_SECRET_SIZE];
+ uint8_t final[MAC_SECRET_SIZE];
time_t timestamp = gnutls_time (0);
int ret;
static int
session_ticket_recv_params (gnutls_session_t session,
- const opaque * data, size_t _data_size)
+ const uint8_t * data, size_t _data_size)
{
ssize_t data_size = _data_size;
session_ticket_ext_st *priv = NULL;
if (session->security_parameters.entity == GNUTLS_SERVER)
{
struct ticket ticket;
- const opaque *encrypted_state;
+ const uint8_t *encrypted_state;
int ret;
/* The client requested a new session ticket. */
#include <abstract_int.h>
static int _gnutls_signature_algorithm_recv_params (gnutls_session_t session,
- const opaque * data,
+ const uint8_t * data,
size_t data_size);
static int _gnutls_signature_algorithm_send_params (gnutls_session_t session,
gnutls_buffer_st * extdata);
* by using the setup priorities.
*/
int
-_gnutls_sign_algorithm_write_params (gnutls_session_t session, opaque * data,
+_gnutls_sign_algorithm_write_params (gnutls_session_t session, uint8_t * data,
size_t max_data_size)
{
- opaque *p = data, *len_p;
- int len, i, j;
+ uint8_t *p = data, *len_p;
+ unsigned int len, i, j;
const sign_algorithm_st *aid;
if (max_data_size < (session->internals.priorities.sign_algo.algorithms*2) + 2)
*/
int
_gnutls_sign_algorithm_parse_data (gnutls_session_t session,
- const opaque * data, size_t data_size)
+ const uint8_t * data, size_t data_size)
{
- int sig, i;
+ unsigned int sig, i;
sig_ext_st *priv;
extension_priv_data_t epriv;
static int
_gnutls_signature_algorithm_recv_params (gnutls_session_t session,
- const opaque * data,
+ const uint8_t * data,
size_t _data_size)
{
ssize_t data_size = _data_size;
gnutls_protocol_t ver = gnutls_protocol_get_version (session);
sig_ext_st *priv;
extension_priv_data_t epriv;
- int cert_algo;
+ unsigned int cert_algo;
cert_algo = gnutls_pubkey_get_pk_algorithm(cert->pubkey, NULL);
gnutls_sign_algorithm_t
_gnutls_session_get_sign_algo (gnutls_session_t session, gnutls_pcert_st* cert);
int _gnutls_sign_algorithm_parse_data (gnutls_session_t session,
- const opaque * data, size_t data_size);
+ const uint8_t * data, size_t data_size);
int _gnutls_sign_algorithm_write_params (gnutls_session_t session,
- opaque * data, size_t max_data_size);
+ uint8_t * data, size_t max_data_size);
int _gnutls_session_sign_algo_enabled (gnutls_session_t session,
gnutls_sign_algorithm_t sig);
#endif
gnutls_buffer_st * ps);
static void _gnutls_srp_deinit_data (extension_priv_data_t epriv);
static int _gnutls_srp_recv_params (gnutls_session_t state,
- const opaque * data, size_t data_size);
+ const uint8_t * data, size_t data_size);
static int _gnutls_srp_send_params (gnutls_session_t state, gnutls_buffer_st * extdata);
extension_entry_st ext_mod_srp = {
static int
-_gnutls_srp_recv_params (gnutls_session_t session, const opaque * data,
+_gnutls_srp_recv_params (gnutls_session_t session, const uint8_t * data,
size_t _data_size)
{
uint8_t len;
srp_ext_st *priv;
int ret;
extension_priv_data_t epriv;
- gnutls_datum_t username = { NULL, 0 }, password =
- {
- NULL, 0};
+ gnutls_datum_t username = { NULL, 0 };
+ gnutls_datum_t password = { NULL, 0 };
priv = gnutls_calloc (1, sizeof (*priv));
if (priv == NULL)
BUFFER_POP_DATUM (ps, &username);
BUFFER_POP_DATUM (ps, &password);
- priv->username = username.data;
- priv->password = password.data;
+ priv->username = (char*)username.data;
+ priv->password = (char*)password.data;
epriv.ptr = priv;
*_priv = epriv;
const char augmentation_string[] = " .o+=*BOX@%&#/^SE";
char *retval, *p;
uint8_t field[FLDSIZE_X][FLDSIZE_Y];
- u_int i, b;
+ unsigned int i, b;
int x, y;
const size_t len = sizeof(augmentation_string) - 2;
- int prefix_len = 0;
+ unsigned int prefix_len = 0;
if (prefix)
prefix_len = strlen(prefix);
int (*gnutls_generate_server_certificate_request) (gnutls_session_t,
gnutls_buffer_st *);
- int (*gnutls_process_server_certificate) (gnutls_session_t, opaque *,
+ int (*gnutls_process_server_certificate) (gnutls_session_t, uint8_t *,
size_t);
- int (*gnutls_process_client_certificate) (gnutls_session_t, opaque *,
+ int (*gnutls_process_client_certificate) (gnutls_session_t, uint8_t *,
size_t);
- int (*gnutls_process_server_kx) (gnutls_session_t, opaque *, size_t);
- int (*gnutls_process_client_kx) (gnutls_session_t, opaque *, size_t);
- int (*gnutls_process_client_cert_vrfy) (gnutls_session_t, opaque *, size_t);
+ int (*gnutls_process_server_kx) (gnutls_session_t, uint8_t *, size_t);
+ int (*gnutls_process_client_kx) (gnutls_session_t, uint8_t *, size_t);
+ int (*gnutls_process_client_cert_vrfy) (gnutls_session_t, uint8_t *, size_t);
int (*gnutls_process_server_certificate_request) (gnutls_session_t,
- opaque *, size_t);
+ uint8_t *, size_t);
} mod_auth_st;
const void *_gnutls_get_cred (gnutls_key_st key,
int
_gnutls_record_buffer_get (content_type_t type,
- gnutls_session_t session, opaque * data,
- size_t length, opaque seq[8])
+ gnutls_session_t session, uint8_t * data,
+ size_t length, uint8_t seq[8])
{
gnutls_datum_t msg;
mbuffer_st* bufel;
gnutls_pull_func pull_func)
{
ssize_t i, ret;
- char *ptr;
+ uint8_t *ptr;
size_t max_size = _gnutls_get_max_decrypted_data(session);
size_t recv_size = MAX_RECV_SIZE(session);
gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
size_t left;
ssize_t i = 0;
size_t max_size = _gnutls_get_max_decrypted_data(session);
- char *ptr;
+ uint8_t *ptr;
gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
*bufel = _mbuffer_alloc (0, MAX(max_size, size));
static ssize_t
_gnutls_writev_emu (gnutls_session_t session, gnutls_transport_ptr_t fd, const giovec_t * giovec,
- int giovec_cnt)
+ unsigned int giovec_cnt)
{
- int ret = 0, j = 0;
+ unsigned int j = 0;
size_t total = 0;
+ ssize_t ret = 0;
for (j = 0; j < giovec_cnt; j++)
{
total += ret;
- if (ret != giovec[j].iov_len)
+ if ((size_t)ret != giovec[j].iov_len)
break;
}
}
int _gnutls_record_buffer_get (content_type_t type,
- gnutls_session_t session, opaque * data,
- size_t length, opaque seq[8]);
+ gnutls_session_t session, uint8_t * data,
+ size_t length, uint8_t seq[8]);
ssize_t _gnutls_io_read_buffered (gnutls_session_t, size_t n, content_type_t);
int _gnutls_io_clear_peeked_data (gnutls_session_t session);
#include <random.h>
static int compressed_to_ciphertext (gnutls_session_t session,
- opaque * cipher_data, int cipher_size,
+ uint8_t * cipher_data, int cipher_size,
gnutls_datum_t *compressed,
content_type_t _type,
record_parameters_st * params);
static int ciphertext_to_compressed (gnutls_session_t session,
gnutls_datum_t *ciphertext,
- opaque * compress_data,
+ uint8_t * compress_data,
int compress_size,
uint8_t type,
record_parameters_st * params, uint64* sequence);
* If random pad != 0 then the random pad data will be appended.
*/
int
-_gnutls_encrypt (gnutls_session_t session, const opaque * headers,
- size_t headers_size, const opaque * data,
- size_t data_size, opaque * ciphertext,
+_gnutls_encrypt (gnutls_session_t session, const uint8_t * headers,
+ size_t headers_size, const uint8_t * data,
+ size_t data_size, uint8_t * ciphertext,
size_t ciphertext_size, content_type_t type,
record_parameters_st * params)
{
if (data_size == 0 || is_write_comp_null (params) == 0)
{
- comp.data = (opaque*)data;
+ comp.data = (uint8_t*)data;
comp.size = data_size;
}
else
* Returns the decrypted data length.
*/
int
-_gnutls_decrypt (gnutls_session_t session, opaque * ciphertext,
+_gnutls_decrypt (gnutls_session_t session, uint8_t * ciphertext,
size_t ciphertext_size, uint8_t * data,
size_t max_data_size, content_type_t type,
record_parameters_st * params, uint64 *sequence)
}
else
{
- opaque* tmp_data;
+ uint8_t* tmp_data;
tmp_data = gnutls_malloc(max_data_size);
if (tmp_data == NULL)
* and are not to be sent). Returns their size.
*/
static inline int
-make_preamble (opaque * uint64_data, opaque type, unsigned int length,
- opaque ver, opaque * preamble)
+make_preamble (uint8_t * uint64_data, uint8_t type, unsigned int length,
+ uint8_t ver, uint8_t * preamble)
{
- opaque minor = _gnutls_version_get_minor (ver);
- opaque major = _gnutls_version_get_major (ver);
- opaque *p = preamble;
+ uint8_t minor = _gnutls_version_get_minor (ver);
+ uint8_t major = _gnutls_version_get_major (ver);
+ uint8_t *p = preamble;
uint16_t c_length;
c_length = _gnutls_conv_uint16 (length);
*/
static int
compressed_to_ciphertext (gnutls_session_t session,
- opaque * cipher_data, int cipher_size,
+ uint8_t * cipher_data, int cipher_size,
gnutls_datum_t *compressed,
content_type_t type,
record_parameters_st * params)
uint8_t * tag_ptr = NULL;
uint8_t pad;
int length, length_to_encrypt, ret;
- opaque preamble[MAX_PREAMBLE_SIZE];
+ uint8_t preamble[MAX_PREAMBLE_SIZE];
int preamble_size;
int tag_size = _gnutls_auth_cipher_tag_len (¶ms->write.cipher_state);
int blocksize = gnutls_cipher_get_block_size (params->cipher_algorithm);
unsigned block_algo =
_gnutls_cipher_is_block (params->cipher_algorithm);
- opaque *data_ptr;
+ uint8_t *data_ptr;
int ver = gnutls_protocol_get_version (session);
int explicit_iv = _gnutls_version_has_explicit_iv (session->security_parameters.version);
int auth_cipher = _gnutls_auth_cipher_is_aead(¶ms->write.cipher_state);
static int
ciphertext_to_compressed (gnutls_session_t session,
gnutls_datum_t *ciphertext,
- opaque * compress_data,
+ uint8_t * compress_data,
int compress_size,
uint8_t type, record_parameters_st * params,
uint64* sequence)
int length, length_to_decrypt;
uint16_t blocksize;
int ret, i, pad_failed = 0;
- opaque preamble[MAX_PREAMBLE_SIZE];
- int preamble_size;
- int ver = gnutls_protocol_get_version (session);
- int tag_size = _gnutls_auth_cipher_tag_len (¶ms->read.cipher_state);
- int explicit_iv = _gnutls_version_has_explicit_iv (session->security_parameters.version);
+ uint8_t preamble[MAX_PREAMBLE_SIZE];
+ unsigned int preamble_size;
+ unsigned int ver = gnutls_protocol_get_version (session);
+ unsigned int tag_size = _gnutls_auth_cipher_tag_len (¶ms->read.cipher_state);
+ unsigned int explicit_iv = _gnutls_version_has_explicit_iv (session->security_parameters.version);
blocksize = gnutls_cipher_get_block_size (params->cipher_algorithm);
*
*/
-int _gnutls_encrypt (gnutls_session_t session, const opaque * headers,
- size_t headers_size, const opaque * data,
- size_t data_size, opaque * ciphertext,
+int _gnutls_encrypt (gnutls_session_t session, const uint8_t * headers,
+ size_t headers_size, const uint8_t * data,
+ size_t data_size, uint8_t * ciphertext,
size_t ciphertext_size, content_type_t type,
record_parameters_st * params);
-int _gnutls_decrypt (gnutls_session_t session, opaque * ciphertext,
+int _gnutls_decrypt (gnutls_session_t session, uint8_t * ciphertext,
size_t ciphertext_size, uint8_t * data, size_t data_size,
content_type_t type, record_parameters_st * params,
uint64* sequence);
cipher_setiv_func setiv;
cipher_deinit_func deinit;
- int tag_size;
- int is_aead:1;
+ size_t tag_size;
+ unsigned int is_aead:1;
} cipher_hd_st;
int _gnutls_cipher_init (cipher_hd_st *, gnutls_cipher_algorithm_t cipher,
const gnutls_datum_t * iv, int enc);
inline static void _gnutls_cipher_setiv (const cipher_hd_st * handle,
- const void *iv, int ivlen)
+ const void *iv, size_t ivlen)
{
handle->setiv(handle->handle, iv, ivlen);
}
inline static int
_gnutls_cipher_encrypt2 (const cipher_hd_st * handle, const void *text,
- int textlen, void *ciphertext, int ciphertextlen)
+ size_t textlen, void *ciphertext, size_t ciphertextlen)
{
if (handle != NULL && handle->handle != NULL)
{
inline static int
_gnutls_cipher_decrypt2 (const cipher_hd_st * handle, const void *ciphertext,
- int ciphertextlen, void *text, int textlen)
+ size_t ciphertextlen, void *text, size_t textlen)
{
if (handle != NULL && handle->handle != NULL)
{
}
int _gnutls_cipher_exists(gnutls_cipher_algorithm_t cipher);
-inline static unsigned int _gnutls_cipher_tag_len( cipher_hd_st * handle)
+inline static size_t _gnutls_cipher_tag_len( cipher_hd_st * handle)
{
return handle->tag_size;
}
}
/* returns the tag in AUTHENC ciphers */
-inline static void _gnutls_cipher_tag( const cipher_hd_st * handle, void* tag, int tag_size)
+inline static void _gnutls_cipher_tag( const cipher_hd_st * handle, void* tag, size_t tag_size)
{
if (handle != NULL && handle->handle != NULL)
{
/* Add auth data for AUTHENC ciphers
*/
inline static int _gnutls_cipher_auth (const cipher_hd_st * handle, const void *text,
- int textlen)
+ size_t textlen)
{
if (handle != NULL && handle->handle != NULL)
{
unsigned int is_mac:1;
unsigned int ssl_hmac:1;
unsigned int is_null:1;
- int tag_size;
+ size_t tag_size;
} auth_cipher_hd_st;
int _gnutls_auth_cipher_init (auth_cipher_hd_st * handle,
int _gnutls_auth_cipher_tag( auth_cipher_hd_st * handle, void* tag, int tag_size);
inline static void _gnutls_auth_cipher_setiv (const auth_cipher_hd_st * handle,
- const void *iv, int ivlen)
+ const void *iv, size_t ivlen)
{
_gnutls_cipher_setiv(&handle->cipher, iv, ivlen);
}
-inline static unsigned int _gnutls_auth_cipher_tag_len( auth_cipher_hd_st * handle)
+inline static size_t _gnutls_auth_cipher_tag_len( auth_cipher_hd_st * handle)
{
return handle->tag_size;
}
*/
int
-_gnutls_compress (comp_hd_st *handle, const opaque * plain,
- size_t plain_size, opaque * compressed,
+_gnutls_compress (comp_hd_st *handle, const uint8_t * plain,
+ size_t plain_size, uint8_t * compressed,
size_t max_comp_size)
{
int compressed_size = GNUTLS_E_COMPRESSION_FAILED;
int
-_gnutls_decompress (comp_hd_st *handle, opaque * compressed,
- size_t compressed_size, opaque * plain,
+_gnutls_decompress (comp_hd_st *handle, uint8_t * compressed,
+ size_t compressed_size, uint8_t * plain,
size_t max_plain_size)
{
int plain_size = GNUTLS_E_DECOMPRESSION_FAILED;
int _gnutls_comp_init (comp_hd_st*, gnutls_compression_method_t, int d);
void _gnutls_comp_deinit (comp_hd_st* handle, int d);
-int _gnutls_decompress (comp_hd_st* handle, opaque * compressed,
- size_t compressed_size, opaque * plain,
+int _gnutls_decompress (comp_hd_st* handle, uint8_t * compressed,
+ size_t compressed_size, uint8_t * plain,
size_t max_plain_size);
-int _gnutls_compress (comp_hd_st*, const opaque * plain, size_t plain_size,
- opaque * compressed, size_t max_comp_size);
+int _gnutls_compress (comp_hd_st*, const uint8_t * plain, size_t plain_size,
+ uint8_t * compressed, size_t max_comp_size);
struct gnutls_compression_entry
{
{
/* FIXME: This function is too long
*/
- opaque rnd[2 * GNUTLS_RANDOM_SIZE];
- opaque rrnd[2 * GNUTLS_RANDOM_SIZE];
+ uint8_t rnd[2 * GNUTLS_RANDOM_SIZE];
+ uint8_t rrnd[2 * GNUTLS_RANDOM_SIZE];
int pos, ret;
int block_size;
char buf[65];
/* avoid using malloc */
- opaque key_block[2 * MAX_HASH_SIZE + 2 * MAX_CIPHER_KEY_SIZE +
+ uint8_t key_block[2 * MAX_HASH_SIZE + 2 * MAX_CIPHER_KEY_SIZE +
2 * MAX_CIPHER_BLOCK_SIZE];
record_state_st *client_write, *server_write;
if (key_size > 0)
{
- opaque key1[EXPORT_FINAL_KEY_SIZE];
- opaque key2[EXPORT_FINAL_KEY_SIZE];
- opaque *client_write_key, *server_write_key;
+ uint8_t key1[EXPORT_FINAL_KEY_SIZE];
+ uint8_t key2[EXPORT_FINAL_KEY_SIZE];
+ uint8_t *client_write_key, *server_write_key;
int client_write_key_size, server_write_key_size;
if (export_flag == 0)
}
else if (IV_size > 0 && export_flag != 0)
{
- opaque iv_block[MAX_CIPHER_BLOCK_SIZE * 2];
+ uint8_t iv_block[MAX_CIPHER_BLOCK_SIZE * 2];
if (session->security_parameters.version == GNUTLS_SSL3)
{ /* SSL 3 */
}
else
{ /* TLS 1.0 */
- ret = _gnutls_PRF (session, "", 0,
+ ret = _gnutls_PRF (session, (uint8_t*)"", 0,
ivblock, ivblock_length, rrnd,
2 * GNUTLS_RANDOM_SIZE, IV_size * 2, iv_block);
}
void
-_gnutls_write_datum16 (opaque * dest, gnutls_datum_t dat)
+_gnutls_write_datum16 (uint8_t * dest, gnutls_datum_t dat)
{
_gnutls_write_uint16 (dat.size, dest);
if (dat.data != NULL)
}
void
-_gnutls_write_datum24 (opaque * dest, gnutls_datum_t dat)
+_gnutls_write_datum24 (uint8_t * dest, gnutls_datum_t dat)
{
_gnutls_write_uint24 (dat.size, dest);
if (dat.data != NULL)
}
void
-_gnutls_write_datum32 (opaque * dest, gnutls_datum_t dat)
+_gnutls_write_datum32 (uint8_t * dest, gnutls_datum_t dat)
{
_gnutls_write_uint32 (dat.size, dest);
if (dat.data != NULL)
}
void
-_gnutls_write_datum8 (opaque * dest, gnutls_datum_t dat)
+_gnutls_write_datum8 (uint8_t * dest, gnutls_datum_t dat)
{
dest[0] = (uint8_t) dat.size;
if (dat.data != NULL)
#ifndef GNUTLS_DATUM_H
#define GNUTLS_DATUM_H
-void _gnutls_write_datum16 (opaque * dest, gnutls_datum_t dat);
-void _gnutls_write_datum24 (opaque * dest, gnutls_datum_t dat);
-void _gnutls_write_datum32 (opaque * dest, gnutls_datum_t dat);
-void _gnutls_write_datum8 (opaque * dest, gnutls_datum_t dat);
+void _gnutls_write_datum16 (uint8_t * dest, gnutls_datum_t dat);
+void _gnutls_write_datum24 (uint8_t * dest, gnutls_datum_t dat);
+void _gnutls_write_datum32 (uint8_t * dest, gnutls_datum_t dat);
+void _gnutls_write_datum8 (uint8_t * dest, gnutls_datum_t dat);
int _gnutls_set_datum_m (gnutls_datum_t * dat, const void *data,
size_t data_size, gnutls_alloc_function);
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
result = _gnutls_fbase64_decode ("DH PARAMETERS",
pkcs3_params->data,
ASN1_TYPE c2;
int result, _params_data_size;
size_t g_size, p_size;
- opaque *p_data, *g_data;
- opaque *all_data;
+ uint8_t *p_data, *g_data;
+ uint8_t *all_data;
_gnutls_mpi_print_lz (params->params[1], NULL, &g_size);
_gnutls_mpi_print_lz (params->params[0], NULL, &p_size);
}
else
{ /* PEM */
- opaque *tmp;
- opaque *out;
+ uint8_t *tmp;
+ uint8_t *out;
int len;
len = 0;
transmit_message (gnutls_session_t session,
mbuffer_st *bufel)
{
- opaque *data, *mtu_data;
+ uint8_t *data, *mtu_data;
int ret = 0;
unsigned int offset, frag_len, data_size;
const unsigned int mtu = gnutls_dtls_get_data_mtu(session) - DTLS_HANDSHAKE_HEADER_SIZE;
gnutls_dtls_prestate_st* prestate,
gnutls_transport_ptr_t ptr, gnutls_push_func push_func)
{
-opaque hvr[20+DTLS_HANDSHAKE_HEADER_SIZE+COOKIE_SIZE];
+uint8_t hvr[20+DTLS_HANDSHAKE_HEADER_SIZE+COOKIE_SIZE];
int hvr_size = 0, ret;
uint8_t digest[C_HASH_SIZE];
* uint16 epoch; - 2 bytes (0, 0)
* uint48 sequence_number; - 4 bytes (0,0,0,0)
* uint16 length; - 2 bytes (COOKIE_SIZE+1+2)+DTLS_HANDSHAKE_HEADER_SIZE
- * opaque fragment[DTLSPlaintext.length];
+ * uint8_t fragment[DTLSPlaintext.length];
* } DTLSPlaintext;
*
*
*
* struct {
* ProtocolVersion server_version;
- * opaque cookie<0..32>;
+ * uint8_t cookie<0..32>;
* } HelloVerifyRequest;
*/
void* _msg, size_t msg_size, gnutls_dtls_prestate_st* prestate)
{
gnutls_datum_t cookie;
-int sid_size;
-int pos, ret;
+int ret;
+unsigned int pos, sid_size;
uint8_t * msg = _msg;
uint8_t digest[C_HASH_SIZE];
int
-_gnutls_ecc_ansi_x963_import (const opaque * in,
+_gnutls_ecc_ansi_x963_import (const uint8_t * in,
unsigned long inlen, bigint_t * x, bigint_t * y)
{
int ret;
#ifndef GNUTLS_ECC_H
# define GNUTLS_ECC_H
-int _gnutls_ecc_ansi_x963_import(const opaque *in, unsigned long inlen, bigint_t* x, bigint_t* y);
+int _gnutls_ecc_ansi_x963_import(const uint8_t *in, unsigned long inlen, bigint_t* x, bigint_t* y);
int _gnutls_ecc_ansi_x963_export(gnutls_ecc_curve_t curve, bigint_t x, bigint_t y, gnutls_datum_t * out);
int _gnutls_ecc_curve_fill_params(gnutls_ecc_curve_t curve, gnutls_pk_params_st* params);
#endif
int
_gnutls_parse_extensions (gnutls_session_t session,
gnutls_ext_parse_type_t parse_type,
- const opaque * data, int data_size)
+ const uint8_t * data, int data_size)
{
int next, ret;
int pos = 0;
uint16_t type;
- const opaque *sdata;
+ const uint8_t *sdata;
gnutls_ext_recv_func ext_recv;
uint16_t size;
int
_gnutls_ext_pack (gnutls_session_t session, gnutls_buffer_st * packed)
{
- int i, ret;
+ unsigned int i;
+ int ret;
extension_priv_data_t data;
int cur_size;
int size_offset;
void
_gnutls_ext_free_session_data (gnutls_session_t session)
{
- int i;
+ unsigned int i;
for (i = 0; i < extfunc_size; i++)
{
_gnutls_ext_set_session_data (gnutls_session_t session, uint16_t type,
extension_priv_data_t data)
{
- int i;
+ unsigned int i;
gnutls_ext_deinit_data_func deinit;
deinit = _gnutls_ext_func_deinit (type);
int _gnutls_parse_extensions (gnutls_session_t session,
gnutls_ext_parse_type_t parse_type,
- const opaque * data, int data_size);
+ const uint8_t * data, int data_size);
int _gnutls_gen_extensions (gnutls_session_t session, gnutls_buffer_st * extdata,
gnutls_ext_parse_type_t);
int _gnutls_ext_init (void);
#define FALSE 0
static int _gnutls_server_select_comp_method (gnutls_session_t session,
- opaque * data, int datalen);
+ uint8_t * data, int datalen);
static int
_gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
uint8_t * cipher_suites,
static int
_gnutls_handshake_hash_add_recvd (gnutls_session_t session,
gnutls_handshake_description_t recv_type,
- opaque * header, uint16_t header_size,
- opaque * dataptr, uint32_t datalen);
+ uint8_t * header, uint16_t header_size,
+ uint8_t * dataptr, uint32_t datalen);
static int
_gnutls_handshake_hash_add_sent (gnutls_session_t session,
gnutls_handshake_description_t type,
- opaque * dataptr, uint32_t datalen);
+ uint8_t * dataptr, uint32_t datalen);
static int
_gnutls_recv_hello_verify_request (gnutls_session_t session,
- opaque * data, int datalen);
+ uint8_t * data, int datalen);
/* Clears the handshake hash buffers and handles.
#define SSL3_SERVER_MSG "SRVR"
#define SSL_MSG_LEN 4
static int
-_gnutls_ssl3_finished (gnutls_session_t session, int type, opaque * ret, int sending)
+_gnutls_ssl3_finished (gnutls_session_t session, int type, uint8_t * ret, int sending)
{
digest_hd_st td_md5;
digest_hd_st td_sha;
_gnutls_finished (gnutls_session_t session, int type, void *ret, int sending)
{
const int siz = TLS_MSG_LEN;
- opaque concat[MAX_HASH_SIZE + 16 /*MD5 */ ];
+ uint8_t concat[MAX_HASH_SIZE + 16 /*MD5 */ ];
size_t hash_len;
const char *mesg;
int rc, len;
* and put it to dst.
*/
int
-_gnutls_tls_create_random (opaque * dst)
+_gnutls_tls_create_random (uint8_t * dst)
{
uint32_t tim;
int ret;
* since SSL version 2.0 is not supported).
*/
static int
-_gnutls_read_client_hello (gnutls_session_t session, opaque * data,
+_gnutls_read_client_hello (gnutls_session_t session, uint8_t * data,
int datalen)
{
uint8_t session_id_len;
gnutls_protocol_t adv_version;
int neg_version;
int len = datalen;
- opaque rnd[GNUTLS_RANDOM_SIZE], *suite_ptr, *comp_ptr, *session_id;
+ uint8_t rnd[GNUTLS_RANDOM_SIZE], *suite_ptr, *comp_ptr, *session_id;
DECR_LEN (len, 2);
_gnutls_send_finished (gnutls_session_t session, int again)
{
mbuffer_st *bufel;
- opaque *data;
+ uint8_t *data;
int ret;
size_t vdata_size = 0;
* RSA algorithms, PK_DSA if DSS, and PK_ANY for both or PK_NONE for none.
*/
static int
-server_find_pk_algos_in_ciphersuites (const opaque *
+server_find_pk_algos_in_ciphersuites (const uint8_t *
data, unsigned int datalen,
gnutls_pk_algorithm_t * algos,
size_t* algos_size)
{
unsigned int j;
gnutls_kx_algorithm_t kx;
- int max = *algos_size;
+ unsigned int max = *algos_size;
if (datalen % 2 != 0)
{
* it adds the suite to the session and performs some checks.
*/
int
-_gnutls_server_select_suite (gnutls_session_t session, opaque * data,
+_gnutls_server_select_suite (gnutls_session_t session, uint8_t * data,
unsigned int datalen)
{
- int i, j, ret, cipher_suites_size;
+ int ret;
+ unsigned int i, j, cipher_suites_size;
size_t pk_algos_size;
uint8_t cipher_suites[MAX_CIPHERSUITE_SIZE];
int retval, err;
*/
if (session->internals.priorities.sr != SR_DISABLED)
{
- int offset;
+ unsigned int offset;
for (offset = 0; offset < datalen; offset += 2)
{
*/
static int
_gnutls_server_select_comp_method (gnutls_session_t session,
- opaque * data, int datalen)
+ uint8_t * data, int datalen)
{
int x, i, j;
uint8_t comps[MAX_ALGOS];
static int
_gnutls_handshake_hash_add_recvd (gnutls_session_t session,
gnutls_handshake_description_t recv_type,
- opaque * header, uint16_t header_size,
- opaque * dataptr, uint32_t datalen)
+ uint8_t * header, uint16_t header_size,
+ uint8_t * dataptr, uint32_t datalen)
{
int ret;
static int
_gnutls_handshake_hash_add_sent (gnutls_session_t session,
gnutls_handshake_description_t type,
- opaque * dataptr, uint32_t datalen)
+ uint8_t * dataptr, uint32_t datalen)
{
int ret;
* to the session;
*/
static int
-_gnutls_client_set_ciphersuite (gnutls_session_t session, opaque suite[2])
+_gnutls_client_set_ciphersuite (gnutls_session_t session, uint8_t suite[2])
{
uint8_t z;
uint8_t cipher_suites[MAX_CIPHERSUITE_SIZE];
/* This function sets the given comp method to the session.
*/
static int
-_gnutls_client_set_comp_method (gnutls_session_t session, opaque comp_method)
+_gnutls_client_set_comp_method (gnutls_session_t session, uint8_t comp_method)
{
int comp_methods_num;
uint8_t compression_methods[MAX_ALGOS];
*/
static int
_gnutls_client_check_if_resuming (gnutls_session_t session,
- opaque * session_id, int session_id_len)
+ uint8_t * session_id, int session_id_len)
{
- opaque buf[2 * TLS_MAX_SESSION_ID_SIZE + 1];
+ char buf[2 * TLS_MAX_SESSION_ID_SIZE + 1];
_gnutls_handshake_log ("HSK[%p]: SessionID length: %d\n", session,
session_id_len);
*/
static int
_gnutls_read_server_hello (gnutls_session_t session,
- opaque * data, int datalen)
+ uint8_t * data, int datalen)
{
uint8_t session_id_len = 0;
int pos = 0;
_gnutls_send_client_hello (gnutls_session_t session, int again)
{
mbuffer_st *bufel = NULL;
- opaque *data = NULL;
+ uint8_t *data = NULL;
int pos = 0, type;
int datalen = 0, ret = 0;
- opaque rnd[GNUTLS_RANDOM_SIZE];
+ uint8_t rnd[GNUTLS_RANDOM_SIZE];
gnutls_protocol_t hver;
gnutls_buffer_st extdata;
int rehandshake = 0;
_gnutls_send_server_hello (gnutls_session_t session, int again)
{
mbuffer_st *bufel = NULL;
- opaque *data = NULL;
+ uint8_t *data = NULL;
gnutls_buffer_st extdata;
int pos = 0;
int datalen, ret = 0;
uint8_t comp;
uint8_t session_id_len = session->security_parameters.session_id_size;
- opaque buf[2 * TLS_MAX_SESSION_ID_SIZE + 1];
+ char buf[2 * TLS_MAX_SESSION_ID_SIZE + 1];
datalen = 0;
* and internals.compression_method.
*/
int
-_gnutls_recv_hello (gnutls_session_t session, opaque * data, int datalen)
+_gnutls_recv_hello (gnutls_session_t session, uint8_t * data, int datalen)
{
int ret;
static int
_gnutls_recv_hello_verify_request (gnutls_session_t session,
- opaque * data, int datalen)
+ uint8_t * data, int datalen)
{
ssize_t len = datalen;
size_t pos = 0;
static ssize_t
send_change_cipher_spec (gnutls_session_t session, int again)
{
- opaque* data;
+ uint8_t* data;
mbuffer_st * bufel;
int ret;
}
int
-_gnutls_generate_session_id (opaque * session_id, uint8_t * len)
+_gnutls_generate_session_id (uint8_t * session_id, uint8_t * len)
{
int ret;
int _gnutls_recv_hello_request (gnutls_session_t session, void *data,
uint32_t data_size);
int _gnutls_send_hello (gnutls_session_t session, int again);
-int _gnutls_recv_hello (gnutls_session_t session, opaque * data, int datalen);
+int _gnutls_recv_hello (gnutls_session_t session, uint8_t * data, int datalen);
int _gnutls_recv_handshake (gnutls_session_t session,
gnutls_handshake_description_t type,
optional_t optional, gnutls_buffer_st* buf);
-int _gnutls_generate_session_id (opaque * session_id, uint8_t * len);
+int _gnutls_generate_session_id (uint8_t * session_id, uint8_t * len);
int _gnutls_handshake_common (gnutls_session_t session);
int _gnutls_handshake_client (gnutls_session_t session);
int _gnutls_handshake_server (gnutls_session_t session);
void _gnutls_set_server_random (gnutls_session_t session, uint8_t * rnd);
void _gnutls_set_client_random (gnutls_session_t session, uint8_t * rnd);
-int _gnutls_tls_create_random (opaque * dst);
+int _gnutls_tls_create_random (uint8_t * dst);
-int _gnutls_find_pk_algos_in_ciphersuites (opaque * data, int datalen);
-int _gnutls_server_select_suite (gnutls_session_t session, opaque * data,
+int _gnutls_find_pk_algos_in_ciphersuites (uint8_t * data, int datalen);
+int _gnutls_server_select_suite (gnutls_session_t session, uint8_t * data,
unsigned int datalen);
int _gnutls_negotiate_version (gnutls_session_t session,
#include <gnutls_hash_int.h>
#include <gnutls_errors.h>
-static int
+static size_t
digest_length (int algo)
{
switch (algo)
/* returns the output size of the given hash/mac algorithm
*/
-int
+size_t
_gnutls_hash_get_algo_len (gnutls_digest_algorithm_t algorithm)
{
return digest_length (algorithm);
_gnutls_mac_init_ssl3 (digest_hd_st * ret, gnutls_mac_algorithm_t algorithm,
void *key, int keylen)
{
- opaque ipad[48];
+ uint8_t ipad[48];
int padsize, result;
padsize = get_padsize (algorithm);
void
_gnutls_mac_reset_ssl3 (digest_hd_st * handle)
{
- opaque ipad[48];
+ uint8_t ipad[48];
int padsize;
padsize = get_padsize (handle->algorithm);
int
_gnutls_mac_output_ssl3 (digest_hd_st * handle, void *digest)
{
- opaque ret[MAX_HASH_SIZE];
+ uint8_t ret[MAX_HASH_SIZE];
digest_hd_st td;
- opaque opad[48];
+ uint8_t opad[48];
int padsize;
int block, rc;
int
_gnutls_mac_deinit_ssl3_handshake (digest_hd_st * handle,
- void *digest, opaque * key,
+ void *digest, uint8_t * key,
uint32_t key_size)
{
- opaque ret[MAX_HASH_SIZE];
+ uint8_t ret[MAX_HASH_SIZE];
digest_hd_st td;
- opaque opad[48];
- opaque ipad[48];
+ uint8_t opad[48];
+ uint8_t ipad[48];
int padsize;
int block, rc;
}
static int
-ssl3_sha (int i, opaque * secret, int secret_len,
- opaque * rnd, int rnd_len, void *digest)
+ssl3_sha (int i, uint8_t * secret, int secret_len,
+ uint8_t * rnd, int rnd_len, void *digest)
{
int j, ret;
- opaque text1[26];
+ uint8_t text1[26];
digest_hd_st td;
#define MD5_DIGEST_OUTPUT 16
static int
-ssl3_md5 (int i, opaque * secret, int secret_len,
- opaque * rnd, int rnd_len, void *digest)
+ssl3_md5 (int i, uint8_t * secret, int secret_len,
+ uint8_t * rnd, int rnd_len, void *digest)
{
- opaque tmp[MAX_HASH_SIZE];
+ uint8_t tmp[MAX_HASH_SIZE];
digest_hd_st td;
int ret;
int
_gnutls_ssl3_hash_md5 (const void *first, int first_len,
const void *second, int second_len,
- int ret_len, opaque * ret)
+ int ret_len, uint8_t * ret)
{
- opaque digest[MAX_HASH_SIZE];
+ uint8_t digest[MAX_HASH_SIZE];
digest_hd_st td;
int block = MD5_DIGEST_OUTPUT;
int rc;
int
_gnutls_ssl3_generate_random (void *secret, int secret_len,
void *rnd, int rnd_len,
- int ret_bytes, opaque * ret)
+ int ret_bytes, uint8_t * ret)
{
int i = 0, copy, output_bytes;
- opaque digest[MAX_HASH_SIZE];
+ uint8_t digest[MAX_HASH_SIZE];
int block = MD5_DIGEST_OUTPUT;
int result, times;
int _gnutls_hmac_exists(gnutls_mac_algorithm_t algorithm);
int _gnutls_hmac_init (digest_hd_st *, gnutls_mac_algorithm_t algorithm,
const void *key, int keylen);
-int _gnutls_hash_get_algo_len (gnutls_digest_algorithm_t algorithm);
+size_t _gnutls_hash_get_algo_len (gnutls_digest_algorithm_t algorithm);
#define _gnutls_hmac_get_algo_len _gnutls_hash_get_algo_len
int _gnutls_hmac_fast (gnutls_mac_algorithm_t algorithm, const void *key,
int keylen, const void *text, size_t textlen,
inline static void
_gnutls_hmac_output (digest_hd_st * handle, void *digest)
{
- int maclen;
+ size_t maclen;
maclen = _gnutls_hmac_get_algo_len (handle->algorithm);
int _gnutls_ssl3_generate_random (void *secret, int secret_len,
void *rnd, int random_len, int bytes,
- opaque * ret);
+ uint8_t * ret);
int _gnutls_ssl3_hash_md5 (const void *first, int first_len,
const void *second, int second_len,
- int ret_len, opaque * ret);
+ int ret_len, uint8_t * ret);
void _gnutls_mac_reset_ssl3 (digest_hd_st * handle);
int _gnutls_mac_deinit_ssl3_handshake (digest_hd_st * handle, void *digest,
- opaque * key, uint32_t key_size);
+ uint8_t * key, uint32_t key_size);
int _gnutls_hash_copy (digest_hd_st * dst_handle, digest_hd_st * src_handle);
#define GNUTLS_POINTER_TO_INT(_) ((int) GNUTLS_POINTER_TO_INT_CAST (_))
#define GNUTLS_INT_TO_POINTER(_) ((void*) GNUTLS_POINTER_TO_INT_CAST (_))
-typedef unsigned char opaque;
typedef struct
{
- opaque pint[3];
+ uint8_t pint[3];
} uint24;
#include <gnutls_mpi.h>
uint32_t start_offset;
uint32_t end_offset;
- opaque header[MAX_HANDSHAKE_HEADER_SIZE];
+ uint8_t header[MAX_HANDSHAKE_HEADER_SIZE];
int header_size;
gnutls_buffer_st data;
*/
uint8_t cipher_suite[2];
gnutls_compression_method_t compression_method;
- opaque master_secret[GNUTLS_MASTER_SIZE];
- opaque client_random[GNUTLS_RANDOM_SIZE];
- opaque server_random[GNUTLS_RANDOM_SIZE];
- opaque session_id[TLS_MAX_SESSION_ID_SIZE];
+ uint8_t master_secret[GNUTLS_MASTER_SIZE];
+ uint8_t client_random[GNUTLS_RANDOM_SIZE];
+ uint8_t server_random[GNUTLS_RANDOM_SIZE];
+ uint8_t session_id[TLS_MAX_SESSION_ID_SIZE];
uint8_t session_id_size;
time_t timestamp;
typedef struct
{
/* HelloVerifyRequest DOS prevention cookie */
- opaque cookie[DTLS_MAX_COOKIE_SIZE];
+ uint8_t cookie[DTLS_MAX_COOKIE_SIZE];
uint8_t cookie_len;
/* For DTLS handshake fragmentation and reassembly. */
/* This holds the default version that our first
* record packet will have. */
- opaque default_record_version[2];
+ uint8_t default_record_version[2];
void *user_ptr;
* PMS secret. Can be used by clients to test whether the
* server checks that version. (** only used in gnutls-cli-debug)
*/
- opaque rsa_pms_version[2];
+ uint8_t rsa_pms_version[2];
/* Here we cache the DH or RSA parameters got from the
* credentials structure, or from a callback. That is to
internal API is changed to use mbuffers. For now we don't avoid the
extra alloc + memcpy. */
static inline int
-send_handshake (gnutls_session_t session, opaque * data, size_t size,
+send_handshake (gnutls_session_t session, uint8_t * data, size_t size,
gnutls_handshake_description_t type)
{
mbuffer_st *bufel;
if (gnutls_protocol_get_version (session) == GNUTLS_SSL3)
{
- opaque rnd[2 * GNUTLS_RANDOM_SIZE + 1];
+ uint8_t rnd[2 * GNUTLS_RANDOM_SIZE + 1];
memcpy (rnd, session->security_parameters.client_random,
GNUTLS_RANDOM_SIZE);
}
else
{
- opaque rnd[2 * GNUTLS_RANDOM_SIZE + 1];
+ uint8_t rnd[2 * GNUTLS_RANDOM_SIZE + 1];
memcpy (rnd, session->security_parameters.client_random,
GNUTLS_RANDOM_SIZE);
}
/* payload points after the mbuffer_st structure */
- st->msg.data = (opaque *) st + sizeof (mbuffer_st);
+ st->msg.data = (uint8_t *) st + sizeof (mbuffer_st);
st->msg.size = payload_size;
st->maximum_size = maximum_size;
int ret;
int rem, i;
bigint_t tmp;
- char tmpbuf[512];
- opaque *buf;
+ uint8_t tmpbuf[512];
+ uint8_t *buf;
int buf_release = 0;
if (size < sizeof (tmpbuf))
_gnutls_mpi_dprint_lz (const bigint_t a, gnutls_datum_t * dest)
{
int ret;
- opaque *buf = NULL;
+ uint8_t *buf = NULL;
size_t bytes = 0;
if (dest == NULL || a == NULL)
_gnutls_mpi_dprint (const bigint_t a, gnutls_datum_t * dest)
{
int ret;
- opaque *buf = NULL;
+ uint8_t *buf = NULL;
size_t bytes = 0;
if (dest == NULL || a == NULL)
_gnutls_mpi_dprint_size (const bigint_t a, gnutls_datum_t * dest, size_t size)
{
int ret;
- opaque *buf = NULL;
+ uint8_t *buf = NULL;
size_t bytes = 0;
unsigned int i;
_gnutls_x509_read_int (ASN1_TYPE node, const char *value, bigint_t * ret_mpi)
{
int result;
- opaque *tmpstr = NULL;
+ uint8_t *tmpstr = NULL;
int tmpstr_size;
tmpstr_size = 0;
_gnutls_x509_write_int (ASN1_TYPE node, const char *value, bigint_t mpi,
int lz)
{
- opaque *tmpstr;
+ uint8_t *tmpstr;
size_t s_len;
int result;
/* data should be at least 3 bytes */
uint32_t
-_gnutls_read_uint24 (const opaque * data)
+_gnutls_read_uint24 (const uint8_t * data)
{
uint32_t res;
uint24 num;
}
void
-_gnutls_write_uint64 (uint64_t num, opaque * data)
+_gnutls_write_uint64 (uint64_t num, uint8_t * data)
{
#ifndef WORDS_BIGENDIAN
num = bswap_64 (num);
}
void
-_gnutls_write_uint24 (uint32_t num, opaque * data)
+_gnutls_write_uint24 (uint32_t num, uint8_t * data)
{
uint24 tmp;
}
uint32_t
-_gnutls_read_uint32 (const opaque * data)
+_gnutls_read_uint32 (const uint8_t * data)
{
uint32_t res;
}
void
-_gnutls_write_uint32 (uint32_t num, opaque * data)
+_gnutls_write_uint32 (uint32_t num, uint8_t * data)
{
#ifndef WORDS_BIGENDIAN
}
uint16_t
-_gnutls_read_uint16 (const opaque * data)
+_gnutls_read_uint16 (const uint8_t * data)
{
uint16_t res;
memcpy (&res, data, sizeof (uint16_t));
}
void
-_gnutls_write_uint16 (uint16_t num, opaque * data)
+_gnutls_write_uint16 (uint16_t num, uint8_t * data)
{
#ifndef WORDS_BIGENDIAN
uint32_t _gnutls_uint24touint32 (uint24 num);
uint24 _gnutls_uint32touint24 (uint32_t num);
-uint64_t _gnutls_read_uint48 (const opaque * data);
-uint32_t _gnutls_read_uint32 (const opaque * data);
-uint16_t _gnutls_read_uint16 (const opaque * data);
+uint64_t _gnutls_read_uint48 (const uint8_t * data);
+uint32_t _gnutls_read_uint32 (const uint8_t * data);
+uint16_t _gnutls_read_uint16 (const uint8_t * data);
uint32_t _gnutls_conv_uint32 (uint32_t data);
uint16_t _gnutls_conv_uint16 (uint16_t data);
-uint32_t _gnutls_read_uint24 (const opaque * data);
-void _gnutls_write_uint64 (uint64_t num, opaque * data);
-void _gnutls_write_uint24 (uint32_t num, opaque * data);
-void _gnutls_write_uint32 (uint32_t num, opaque * data);
-void _gnutls_write_uint16 (uint16_t num, opaque * data);
+uint32_t _gnutls_read_uint24 (const uint8_t * data);
+void _gnutls_write_uint64 (uint64_t num, uint8_t * data);
+void _gnutls_write_uint24 (uint32_t num, uint8_t * data);
+void _gnutls_write_uint32 (uint32_t num, uint8_t * data);
+void _gnutls_write_uint16 (uint16_t num, uint8_t * data);
uint32_t _gnutls_uint64touint32 (const uint64 *);
int _gnutls_uint64pp (uint64 *);
const gnutls_datum_t * data,
gnutls_x509_crt_fmt_t format, unsigned int flags)
{
-int ret, i = 0, j;
+int ret;
+unsigned int i = 0, j;
gnutls_x509_crt_t *crt;
crt = gnutls_malloc((*pcert_max) * sizeof(gnutls_x509_crt_t));
{
unsigned int i, pad;
int ret;
- opaque *edata, *ps;
+ uint8_t *edata, *ps;
size_t k, psize;
size_t mod_bits;
gnutls_datum_t to_encrypt, encrypted;
int _gnutls_pk_params_copy (gnutls_pk_params_st * dst, const gnutls_pk_params_st * src)
{
- int i, j;
+ unsigned int i, j;
dst->params_nr = 0;
if (src == NULL || src->params_nr == 0)
* long enough, or 0 on success.
**/
int
-gnutls_hex_decode (const gnutls_datum_t * hex_data, char *result,
+gnutls_hex_decode (const gnutls_datum_t * hex_data, void *result,
size_t * result_size)
{
int ret;
ret =
- _gnutls_hex2bin (hex_data->data, hex_data->size, (opaque *) result,
+ _gnutls_hex2bin ((char*)hex_data->data, hex_data->size, (uint8_t *) result,
result_size);
if (ret < 0)
return ret;
*/
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
/* Try the first header */
result =
int _gnutls_pubkey_compatible_with_sig(gnutls_pubkey_t pubkey, gnutls_protocol_t ver,
gnutls_sign_algorithm_t sign)
{
-int hash_size;
-int hash_algo;
+unsigned int hash_size;
+unsigned int hash_algo;
if (pubkey->pk_algorithm == GNUTLS_PK_DSA)
{
{
gnutls_mac_algorithm_t hash = GNUTLS_MAC_UNKNOWN;
int ret;
- opaque digest[MAX_HASH_SIZE], md[MAX_HASH_SIZE], *cmp;
- int digest_size;
+ uint8_t digest[MAX_HASH_SIZE], md[MAX_HASH_SIZE], *cmp;
+ unsigned int digest_size;
digest_hd_st hd;
gnutls_datum_t decrypted;
gnutls_pk_params_st* params)
{
gnutls_datum_t digest;
- gnutls_digest_algorithm_t algo;
- int hash_len;
+ unsigned int algo;
+ unsigned int hash_len;
algo = _gnutls_dsa_q_to_hash (pk, params, &hash_len);
gnutls_pk_params_st* params)
{
int ret;
- opaque _digest[MAX_HASH_SIZE];
+ uint8_t _digest[MAX_HASH_SIZE];
gnutls_datum_t digest;
digest_hd_st hd;
}
gnutls_digest_algorithm_t
-_gnutls_dsa_q_to_hash (gnutls_pk_algorithm_t algo, const gnutls_pk_params_st* params, int* hash_len)
+_gnutls_dsa_q_to_hash (gnutls_pk_algorithm_t algo, const gnutls_pk_params_st* params,
+ unsigned int* hash_len)
{
int bits = 0;
*/
inline static void
copy_record_version (gnutls_session_t session,
- gnutls_handshake_description_t htype, opaque version[2])
+ gnutls_handshake_description_t htype, uint8_t version[2])
{
gnutls_protocol_t lver;
*/
static int
check_buffers (gnutls_session_t session, content_type_t type,
- opaque * data, int data_size, void* seq)
+ uint8_t * data, int data_size, void* seq)
{
if ((type == GNUTLS_APPLICATION_DATA ||
type == GNUTLS_HANDSHAKE ||
*/
inline static int
record_check_version (gnutls_session_t session,
- gnutls_handshake_description_t htype, opaque version[2])
+ gnutls_handshake_description_t htype, uint8_t version[2])
{
if (htype == GNUTLS_HANDSHAKE_CLIENT_HELLO)
{
if (decrypted == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
- ciphertext = (opaque*)_mbuffer_get_udata_ptr(bufel) + record.header_size;
+ ciphertext = (uint8_t*)_mbuffer_get_udata_ptr(bufel) + record.header_size;
/* decrypt the data we got.
*/
ssize_t
_gnutls_recv_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
- opaque * data, size_t data_size, void* seq)
+ uint8_t * data, size_t data_size, void* seq)
{
int ret;
unsigned int epoch_rel, const void *data,
size_t sizeofdata, unsigned int mflags);
ssize_t _gnutls_recv_int (gnutls_session_t session, content_type_t type,
- gnutls_handshake_description_t, opaque * data,
+ gnutls_handshake_description_t, uint8_t * data,
size_t sizeofdata, void* seq);
int _gnutls_get_max_decrypted_data(gnutls_session_t session);
int ret;
gnutls_datum_t psession;
- psession.data = (opaque *) session_data;
+ psession.data = (uint8_t *) session_data;
psession.size = session_data_size;
if (session_data == NULL || session_data_size == 0)
{
int ret;
gnutls_buffer_st sb;
- opaque id;
+ uint8_t id;
if (packed_session == NULL)
{
{
int ret;
gnutls_buffer_st sb;
- opaque id;
+ uint8_t id;
_gnutls_buffer_init (&sb);
gnutls_datum_t dconcat;
int ret;
digest_hd_st td_sha;
- opaque concat[MAX_SIG_SIZE];
+ uint8_t concat[MAX_SIG_SIZE];
gnutls_protocol_t ver = gnutls_protocol_get_version (session);
gnutls_digest_algorithm_t hash_algo;
int ret;
digest_hd_st td_md5;
digest_hd_st td_sha;
- opaque concat[MAX_SIG_SIZE];
+ uint8_t concat[MAX_SIG_SIZE];
gnutls_protocol_t ver = gnutls_protocol_get_version (session);
gnutls_digest_algorithm_t hash_algo;
gnutls_sign_algorithm_t sign_algo)
{
int ret;
- opaque concat[MAX_HASH_SIZE];
+ uint8_t concat[MAX_HASH_SIZE];
gnutls_datum_t dconcat;
gnutls_digest_algorithm_t hash_algo;
gnutls_protocol_t ver = gnutls_protocol_get_version (session);
gnutls_sign_algorithm_t sign_algo)
{
int ret;
- opaque concat[MAX_SIG_SIZE];
+ uint8_t concat[MAX_SIG_SIZE];
digest_hd_st td_md5;
digest_hd_st td_sha;
gnutls_datum_t dconcat;
{
gnutls_datum_t dconcat;
int ret;
- opaque concat[MAX_SIG_SIZE];
+ uint8_t concat[MAX_SIG_SIZE];
gnutls_sign_algorithm_t sign_algo;
gnutls_digest_algorithm_t hash_algo;
{
gnutls_datum_t dconcat;
int ret;
- opaque concat[MAX_SIG_SIZE];
+ uint8_t concat[MAX_SIG_SIZE];
digest_hd_st td_md5;
digest_hd_st td_sha;
gnutls_protocol_t ver = gnutls_protocol_get_version (session);
int
decode_ber_digest_info (const gnutls_datum_t * info,
gnutls_mac_algorithm_t * hash,
- opaque * digest, int *digest_size)
+ uint8_t * digest, unsigned int *digest_size)
{
ASN1_TYPE dinfo = ASN1_TYPE_EMPTY;
int result;
return GNUTLS_E_ASN1_GENERIC_ERROR;
}
- result = asn1_read_value (dinfo, "digest", digest, digest_size);
+ len = *digest_size;
+ result = asn1_read_value (dinfo, "digest", digest, &len);
+
if (result != ASN1_SUCCESS)
{
gnutls_assert ();
+ *digest_size = len;
asn1_delete_structure (&dinfo);
return _gnutls_asn2err (result);
}
+ *digest_size = len;
asn1_delete_structure (&dinfo);
return 0;
ASN1_TYPE dinfo = ASN1_TYPE_EMPTY;
int result;
const char *algo;
- opaque *tmp_output;
+ uint8_t *tmp_output;
int tmp_output_size;
algo = _gnutls_x509_mac_to_oid ((gnutls_mac_algorithm_t) hash);
int
decode_ber_digest_info (const gnutls_datum_t * info,
gnutls_mac_algorithm_t * hash,
- opaque * digest, int *digest_size);
+ uint8_t * digest, unsigned int *digest_size);
#endif
*/
static int
-_gnutls_srp_gx (opaque * text, size_t textsize, opaque ** result,
+_gnutls_srp_gx (uint8_t * text, size_t textsize, uint8_t ** result,
bigint_t g, bigint_t prime)
{
bigint_t x, e;
_gnutls_calc_srp_u (bigint_t A, bigint_t B, bigint_t n)
{
size_t b_size, a_size;
- opaque *holder, hd[MAX_HASH_SIZE];
+ uint8_t *holder, hd[MAX_HASH_SIZE];
size_t holder_size, hash_size, n_size;
int ret;
bigint_t res;
*/
static int
_gnutls_calc_srp_sha (const char *username, const char *password,
- opaque * salt, int salt_size, size_t * size,
+ uint8_t * salt, int salt_size, size_t * size,
void *digest)
{
digest_hd_st td;
- opaque res[MAX_HASH_SIZE];
+ uint8_t res[MAX_HASH_SIZE];
int ret;
*size = 20;
}
int
-_gnutls_calc_srp_x (char *username, char *password, opaque * salt,
+_gnutls_calc_srp_x (char *username, char *password, uint8_t * salt,
size_t salt_size, size_t * size, void *digest)
{
bigint_t _n, _g;
int ret;
size_t digest_size = 20, size;
- opaque digest[20];
+ uint8_t digest[20];
ret = _gnutls_calc_srp_sha (username, password, salt->data,
salt->size, &digest_size, digest);
bigint_t _gnutls_calc_srp_A (bigint_t * a, bigint_t g, bigint_t n);
bigint_t _gnutls_calc_srp_S2 (bigint_t B, bigint_t g, bigint_t x, bigint_t a,
bigint_t u, bigint_t n);
-int _gnutls_calc_srp_x (char *username, char *password, opaque * salt,
+int _gnutls_calc_srp_x (char *username, char *password, uint8_t * salt,
size_t salt_size, size_t * size, void *digest);
-int _gnutls_srp_gn (opaque ** ret_g, opaque ** ret_n, int bits);
+int _gnutls_srp_gn (uint8_t ** ret_g, uint8_t ** ret_n, int bits);
/* g is defined to be 2 */
#define SRP_MAX_HASH_SIZE 24
*/
static int
P_hash (gnutls_mac_algorithm_t algorithm,
- const opaque * secret, int secret_size,
- const opaque * seed, int seed_size,
- int total_bytes, opaque * ret)
+ const uint8_t * secret, int secret_size,
+ const uint8_t * seed, int seed_size,
+ int total_bytes, uint8_t * ret)
{
digest_hd_st td2;
int i, times, how, blocksize, A_size;
- opaque final[MAX_HASH_SIZE], Atmp[MAX_SEED_SIZE];
+ uint8_t final[MAX_HASH_SIZE], Atmp[MAX_SEED_SIZE];
int output_bytes, result;
if (seed_size > MAX_SEED_SIZE || total_bytes <= 0)
*/
int
_gnutls_PRF (gnutls_session_t session,
- const opaque * secret, unsigned int secret_size, const char *label,
- int label_size, const opaque * seed, int seed_size,
+ const uint8_t * secret, unsigned int secret_size, const char *label,
+ int label_size, const uint8_t * seed, int seed_size,
int total_bytes, void *ret)
{
int l_s, s_seed_size;
- const opaque *s1, *s2;
- opaque s_seed[MAX_SEED_SIZE];
- opaque o1[MAX_PRF_BYTES], o2[MAX_PRF_BYTES];
+ const uint8_t *s1, *s2;
+ uint8_t s_seed[MAX_SEED_SIZE];
+ uint8_t o1[MAX_PRF_BYTES], o2[MAX_PRF_BYTES];
int result;
gnutls_protocol_t ver = gnutls_protocol_get_version (session);
session->security_parameters.master_secret,
GNUTLS_MASTER_SIZE,
label,
- label_size, (opaque *) seed, seed_size, outsize, out);
+ label_size, (uint8_t *) seed, seed_size, outsize, out);
return ret;
}
size_t extra_size, const char *extra, size_t outsize, char *out)
{
int ret;
- opaque *seed;
+ uint8_t *seed;
size_t seedsize = 2 * GNUTLS_RANDOM_SIZE + extra_size;
seed = gnutls_malloc (seedsize);
int _gnutls_openpgp_send_fingerprint (gnutls_session_t session);
int _gnutls_PRF (gnutls_session_t session,
- const opaque * secret, unsigned int secret_size,
+ const uint8_t * secret, unsigned int secret_size,
const char *label, int label_size,
- const opaque * seed, int seed_size,
+ const uint8_t * seed, int seed_size,
int total_bytes, void *ret);
#define DEFAULT_CERT_TYPE GNUTLS_CRT_X509
{
int rv = -1;
char t[5];
- int pos = 0;
+ unsigned int pos = 0;
while (pos < dest->length)
{
_gnutls_buffer_unescape (gnutls_buffer_st * dest)
{
int rv = -1;
- int pos = 0;
+ unsigned int pos = 0;
while (pos < dest->length)
{
char *buffer, size_t buffer_size, const char *separator)
{
unsigned int i, j;
- const opaque *old = _old;
+ const uint8_t *old = _old;
int step = 2;
const char empty[] = "";
**/
int
gnutls_hex2bin (const char *hex_data,
- size_t hex_size, char *bin_data, size_t * bin_size)
+ size_t hex_size, void *bin_data, size_t * bin_size)
{
- return _gnutls_hex2bin (hex_data, (int) hex_size, bin_data, bin_size);
+ return _gnutls_hex2bin (hex_data, hex_size, (void*)bin_data, bin_size);
}
int
-_gnutls_hex2bin (const opaque * hex_data, int hex_size, opaque * bin_data,
+_gnutls_hex2bin (const char * hex_data, size_t hex_size, uint8_t * bin_data,
size_t * bin_size)
{
- int i, j;
- opaque hex2_data[3];
+ unsigned int i, j;
+ uint8_t hex2_data[3];
unsigned long val;
hex2_data[2] = 0;
int
_gnutls_buffer_append_prefix (gnutls_buffer_st * buf, int pfx_size, size_t data_size)
{
- opaque ss[4];
+ uint8_t ss[4];
if (pfx_size == 32)
{
void
_gnutls_buffer_hexprint (gnutls_buffer_st * str,
- const char *data, size_t len)
+ const void *_data, size_t len)
{
size_t j;
+ const unsigned char* data = _data;
if (len == 0)
_gnutls_buffer_append_str (str, "00");
else
{
for (j = 0; j < len; j++)
- _gnutls_buffer_append_printf (str, "%.2x", (unsigned char) data[j]);
+ _gnutls_buffer_append_printf (str, "%.2x", (unsigned) data[j]);
}
}
void
-_gnutls_buffer_hexdump (gnutls_buffer_st * str, const char *data, size_t len,
+_gnutls_buffer_hexdump (gnutls_buffer_st * str, const void *_data, size_t len,
const char *spc)
{
size_t j;
+ const unsigned char* data = _data;
if (spc)
_gnutls_buffer_append_str (str, spc);
{
if (((j + 1) % 16) == 0)
{
- _gnutls_buffer_append_printf (str, "%.2x\n", (unsigned char) data[j]);
+ _gnutls_buffer_append_printf (str, "%.2x\n", (unsigned)data[j]);
if (spc && j != (len - 1))
_gnutls_buffer_append_str (str, spc);
}
else if (j == (len - 1))
- _gnutls_buffer_append_printf (str, "%.2x", (unsigned char) data[j]);
+ _gnutls_buffer_append_printf (str, "%.2x", (unsigned)data[j]);
else
- _gnutls_buffer_append_printf (str, "%.2x:", (unsigned char) data[j]);
+ _gnutls_buffer_append_printf (str, "%.2x:", (unsigned)data[j]);
}
if ((j % 16) != 0)
_gnutls_buffer_append_str (str, "\n");
typedef struct
{
- opaque *allocd; /* pointer to allocated data */
- opaque *data; /* API: pointer to data to copy from */
+ uint8_t *allocd; /* pointer to allocated data */
+ uint8_t *data; /* API: pointer to data to copy from */
size_t max_length;
size_t length; /* API: current length */
} gnutls_buffer_st;
__attribute__ ((format (printf, 2, 3)));
void _gnutls_buffer_hexprint (gnutls_buffer_st * str,
- const char *data, size_t len);
-void _gnutls_buffer_hexdump (gnutls_buffer_st * str, const char *data,
+ const void *data, size_t len);
+void _gnutls_buffer_hexdump (gnutls_buffer_st * str, const void *data,
size_t len, const char *spc);
void _gnutls_buffer_asciiprint (gnutls_buffer_st * str,
const char *data, size_t len);
char *_gnutls_bin2hex (const void *old, size_t oldlen, char *buffer,
size_t buffer_size, const char *separator);
-int _gnutls_hex2bin (const opaque * hex_data, int hex_size, opaque * bin_data,
+int _gnutls_hex2bin (const char * hex_data, size_t hex_size, uint8_t * bin_data,
size_t * bin_size);
int _gnutls_hostname_compare (const char *certname, size_t certnamesize,
typedef struct gnutls_str_array_st
{
char* str;
- int len;
+ unsigned int len;
struct gnutls_str_array_st* next;
} *gnutls_str_array_t;
inline static void append(gnutls_str_array_t array, const char* str, int len)
{
- array->str = ((uint8_t*)array) + sizeof(struct gnutls_str_array_st);
+ array->str = ((char*)array) + sizeof(struct gnutls_str_array_st);
memcpy(array->str, str, len);
array->str[len] = 0;
array->len = len;
#include "gnutls_num.h"
typedef int (*supp_recv_func) (gnutls_session_t session,
- const opaque * data, size_t data_size);
+ const uint8_t * data, size_t data_size);
typedef int (*supp_send_func) (gnutls_session_t session,
gnutls_buffer_st * buf);
_gnutls_parse_supplemental (gnutls_session_t session,
const uint8_t * data, int datalen)
{
- const opaque *p = data;
+ const uint8_t *p = data;
ssize_t dsize = datalen;
size_t total_size;
if (type != GNUTLS_RANDOM_ART_OPENSSH)
return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
- art->data = _gnutls_key_fingerprint_randomart(fpr, fpr_size, key_type, key_size, NULL);
+ art->data = (void*)_gnutls_key_fingerprint_randomart(fpr, fpr_size, key_type, key_size, NULL);
if (art->data == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
- art->size = strlen(art->data);
+ art->size = strlen((char*)art->data);
return 0;
}
/* This selects the best supported ciphersuite from the ones provided */
static int
_gnutls_handshake_select_v2_suite (gnutls_session_t session,
- opaque * data, unsigned int datalen)
+ uint8_t * data, unsigned int datalen)
{
- int i, j, ret;
- opaque *_data;
+ unsigned int i, j;
+ int ret;
+ uint8_t *_data;
int _datalen;
_gnutls_handshake_log ("HSK[%p]: Parsing a version 2.0 client hello.\n",
* However they set their version to 3.0 or 3.1.
*/
int
-_gnutls_read_client_hello_v2 (gnutls_session_t session, opaque * data,
+_gnutls_read_client_hello_v2 (gnutls_session_t session, uint8_t * data,
unsigned int datalen)
{
uint16_t session_id_len = 0;
int ret = 0;
uint16_t sizeOfSuites;
gnutls_protocol_t adv_version;
- opaque rnd[GNUTLS_RANDOM_SIZE];
+ uint8_t rnd[GNUTLS_RANDOM_SIZE];
int len = datalen;
int err;
uint16_t challenge;
- opaque session_id[TLS_MAX_SESSION_ID_SIZE];
+ uint8_t session_id[TLS_MAX_SESSION_ID_SIZE];
DECR_LEN (len, 2);
*
*/
-int _gnutls_read_client_hello_v2 (gnutls_session_t session, opaque * data,
+int _gnutls_read_client_hello_v2 (gnutls_session_t session, uint8_t * data,
unsigned int datalen);
static int
_gnutls_check_key_cert_match (gnutls_certificate_credentials_t res)
{
- unsigned int pk = gnutls_pubkey_get_pk_algorithm(res->certs[res->ncerts-1].cert_list[0].pubkey, NULL);
+ int pk = gnutls_pubkey_get_pk_algorithm(res->certs[res->ncerts-1].cert_list[0].pubkey, NULL);
if (gnutls_privkey_get_pk_algorithm (res->pkey[res->ncerts - 1], NULL) !=
pk)
goto cleanup;
}
- tmp.data = (opaque *) input_cert;
+ tmp.data = (uint8_t *) input_cert;
tmp.size = input_cert_size;
ret = gnutls_x509_crt_import (crt, &tmp, GNUTLS_X509_FMT_DER);
if (key)
{
- tmp.data = (opaque *) key;
+ tmp.data = (uint8_t *) key;
tmp.size = key_size;
ret = _gnutls_x509_raw_privkey_to_privkey (&privkey, &tmp, type);
static int
parse_pem_ca_mem (gnutls_certificate_credentials_t res,
- const opaque * input_cert, int input_cert_size)
+ const uint8_t * input_cert, int input_cert_size)
{
gnutls_x509_crt_t *x509_cert_list;
unsigned int x509_ncerts;
}
#endif
- cas.data = read_binary_file (cafile, &size);
+ cas.data = (void*)read_binary_file (cafile, &size);
if (cas.data == NULL)
{
gnutls_assert ();
static int
parse_pem_crl_mem (gnutls_x509_trust_list_t tlist,
- const opaque * input_crl, int input_crl_size)
+ const char * input_crl, unsigned int input_crl_size)
{
gnutls_x509_crl_t *x509_crl_list;
unsigned int x509_ncrls;
*/
static int
parse_der_crl_mem (gnutls_x509_trust_list_t tlist,
- const void *input_crl, int input_crl_size)
+ const void *input_crl, unsigned int input_crl_size)
{
gnutls_x509_crl_t crl;
gnutls_datum_t tmp;
{
int ret;
size_t size;
- char *data = read_binary_file (crlfile, &size);
+ char *data = (void*)read_binary_file (crlfile, &size);
if (data == NULL)
{
int ret;
size_t cert_id_size = 0;
size_t key_id_size = 0;
- opaque cert_id[20];
- opaque key_id[20];
+ uint8_t cert_id[20];
+ uint8_t key_id[20];
int privkey_ok = 0;
*cert = NULL;
size_t size;
int ret;
- p12blob.data = read_binary_file (pkcs12file, &size);
+ p12blob.data = (void*)read_binary_file (pkcs12file, &size);
p12blob.size = (unsigned int) size;
if (p12blob.data == NULL)
{
int gnutls_hex_encode (const gnutls_datum_t * data, char *result,
size_t * result_size);
- int gnutls_hex_decode (const gnutls_datum_t * hex_data, char *result,
+ int gnutls_hex_decode (const gnutls_datum_t * hex_data, void *result,
size_t * result_size);
void
gnutls_params_function * func);
int gnutls_hex2bin (const char *hex_data, size_t hex_size,
- char *bin_data, size_t * bin_size);
+ void *bin_data, size_t * bin_size);
/* Gnutls error codes. The mapping to a TLS alert is also shown in
* comments.
const char *so_pin, const char *label);
int
-gnutls_pkcs11_token_get_mechanism (const char *url, int idx,
+gnutls_pkcs11_token_get_mechanism (const char *url, unsigned int idx,
unsigned long *mechanism);
int gnutls_pkcs11_token_set_pin (const char *token_url,
unsigned int seq,
int what,
gnutls_datum_t * data,
- int *critical);
+ unsigned int *critical);
#define GNUTLS_CRL_REASON_UNUSED 128
#define GNUTLS_CRL_REASON_KEY_COMPROMISE 64
int gnutls_x509_crl_get_extension_info (gnutls_x509_crl_t crl, int indx,
void *oid, size_t * sizeof_oid,
- int *critical);
+ unsigned int *critical);
int gnutls_x509_crl_get_extension_data (gnutls_x509_crl_t crl, int indx,
void *data, size_t * sizeof_data);
wrap_nettle_cipher_setkey (void *_ctx, const void *key, size_t keysize)
{
struct nettle_cipher_ctx *ctx = _ctx;
- opaque des_key[DES3_KEY_SIZE];
+ uint8_t des_key[DES3_KEY_SIZE];
switch (ctx->algo)
{
static int
do_read (int fd, void *buf, size_t nbytes)
{
- int n, nread = 0;
+ int n;
+ size_t nread = 0;
do
{
}
while (n == -1 && errno == EINTR);
if (n == -1)
- return nread ? nread : -1;
+ {
+ if (nread > 0)
+ return nread;
+ else return -1;
+ }
if (n == 0)
return -1;
nread += n;
int
_rndegd_read (int *fd, void *_output, size_t _length)
{
- int n;
+ ssize_t n;
uint8_t buffer[256 + 2];
int nbytes;
int do_restart = 0;
unsigned char *output = _output;
- size_t length = _length;
+ ssize_t length = (ssize_t)_length;
if (!length)
return 0;
-
restart:
if (*fd == -1 || do_restart)
*fd = _rndegd_connect_socket ();
if (format == GNUTLS_MPI_FORMAT_PGP)
{
- opaque *buf = buffer;
+ uint8_t *buf = buffer;
unsigned int nbits = _gnutls_mpi_get_nbits (a);
buf[0] = (nbits >> 8) & 0xff;
buf[1] = (nbits) & 0xff;
}
else if (format == GNUTLS_MPI_FORMAT_PGP)
{
- const opaque *buf = buffer;
+ const uint8_t *buf = buffer;
size_t size;
if (nbytes < 3)
{
mpz_t q, w, r;
unsigned int p_bytes = nbits / 8;
- opaque *buffer = NULL;
+ uint8_t *buffer = NULL;
unsigned int q_bytes, w_bytes, r_bytes, w_bits;
int ret;
const gnutls_datum_t * vdata,
const gnutls_pk_params_st * pk_params)
{
- int ret, hash;
+ int ret;
+ unsigned int hash;
+ unsigned int hash_len;
switch (algo)
{
{
ecc_key priv;
struct dsa_signature sig;
- int hash_len;
_ecc_params_to_privkey(pk_params, &priv);
struct dsa_public_key pub;
struct dsa_private_key priv;
struct dsa_signature sig;
- int hash_len;
memset(&priv, 0, sizeof(priv));
memset(&pub, 0, sizeof(pub));
const gnutls_pk_params_st * pk_params)
{
int ret;
- int hash_len;
+ unsigned int hash_len;
bigint_t tmp[2] = { NULL, NULL };
switch (algo)
unsigned int level /*bits */ ,
gnutls_pk_params_st * params)
{
- int ret, i;
- int q_bits;
+ int ret;
+ unsigned int i, q_bits;
memset(params, 0, sizeof(*params));
do_device_source_urandom (int init)
{
time_t now = gnutls_time (NULL);
- int read_size = DEVICE_READ_SIZE;
+ unsigned int read_size = DEVICE_READ_SIZE;
if (init)
{
do_device_source_egd (int init)
{
time_t now = gnutls_time (NULL);
- int read_size = DEVICE_READ_SIZE;
+ unsigned int read_size = DEVICE_READ_SIZE;
if (init)
{
cdk_keydb_hd_t pub;
unsigned int close_db:1;
} db;
- char *(*passphrase_cb) (void *opaque, const char *prompt);
+ char *(*passphrase_cb) (void *uint8_t, const char *prompt);
void *passphrase_cb_value;
};
/*-- armor.c -*/
-int _cdk_filter_armor (void *opaque, int ctl, FILE * in, FILE * out);
+int _cdk_filter_armor (void *uint8_t, int ctl, FILE * in, FILE * out);
/*-- cipher.c --*/
-cdk_error_t _cdk_filter_hash (void *opaque, int ctl, FILE * in, FILE * out);
-cdk_error_t _cdk_filter_cipher (void *opaque, int ctl, FILE * in, FILE * out);
+cdk_error_t _cdk_filter_hash (void *uint8_t, int ctl, FILE * in, FILE * out);
+cdk_error_t _cdk_filter_cipher (void *uint8_t, int ctl, FILE * in, FILE * out);
/*-- literal.c --*/
-int _cdk_filter_literal (void *opaque, int ctl, FILE * in, FILE * out);
-int _cdk_filter_text (void *opaque, int ctl, FILE * in, FILE * out);
+int _cdk_filter_literal (void *uint8_t, int ctl, FILE * in, FILE * out);
+int _cdk_filter_text (void *uint8_t, int ctl, FILE * in, FILE * out);
/*-- compress.c --*/
-cdk_error_t _cdk_filter_compress (void *opaque, int ctl,
+cdk_error_t _cdk_filter_compress (void *uint8_t, int ctl,
FILE * in, FILE * out);
#endif /* CDK_FILTERS_H */
/**
* cdk_kbnode_hash:
* @node: the key node
- * @hashctx: opaque pointer to the hash context
+ * @hashctx: uint8_t pointer to the hash context
* @is_v4: OpenPGP signature (yes=1, no=0)
* @pkttype: packet type to hash (if (0) use the packet type from the node)
* @flags: flags which depend on the operation
void _cdk_stream_set_compress_algo (cdk_stream_t s, int algo);
cdk_error_t _cdk_stream_open_mode (const char *file, const char *mode,
cdk_stream_t * ret_s);
-void *_cdk_stream_get_opaque (cdk_stream_t s, int fid);
+void *_cdk_stream_get_uint8_t (cdk_stream_t s, int fid);
const char *_cdk_stream_get_fname (cdk_stream_t s);
FILE *_cdk_stream_get_fp (cdk_stream_t s);
int _cdk_stream_gets (cdk_stream_t s, char *buf, size_t count);
/**
* cdk_stream_new_from_cbs:
* @cbs: the callback context with all user callback functions
- * @opa: opaque handle which is passed to all callbacks.
+ * @opa: uint8_t handle which is passed to all callbacks.
* @ret_s: the allocated stream
*
* This function creates a stream which uses user callback
{
f2 = f->next;
if (f->fnct)
- f->fnct (f->opaque, STREAMCTL_FREE, NULL, NULL);
+ f->fnct (f->uint8_t, STREAMCTL_FREE, NULL, NULL);
cdk_free (f);
f = f2;
}
}
static inline void
-set_opaque (struct stream_filter_s *f)
+set_uint8_t (struct stream_filter_s *f)
{
switch (f->type)
{
case fARMOR:
- f->opaque = &f->u.afx;
+ f->uint8_t = &f->u.afx;
break;
case fCIPHER:
- f->opaque = &f->u.cfx;
+ f->uint8_t = &f->u.cfx;
break;
case fLITERAL:
- f->opaque = &f->u.pfx;
+ f->uint8_t = &f->u.pfx;
break;
case fCOMPRESS:
- f->opaque = &f->u.zfx;
+ f->uint8_t = &f->u.zfx;
break;
case fHASH:
- f->opaque = &f->u.mfx;
+ f->uint8_t = &f->u.mfx;
break;
case fTEXT:
- f->opaque = &f->u.tfx;
+ f->uint8_t = &f->u.tfx;
break;
default:
- f->opaque = NULL;
+ f->uint8_t = NULL;
}
}
f->tmp = NULL;
f->type = type;
- set_opaque (f);
+ set_uint8_t (f);
return f;
}
if (rc)
break;
}
- rc = f->fnct (f->opaque, f->ctl, s->fp, f->tmp);
+ rc = f->fnct (f->uint8_t, f->ctl, s->fp, f->tmp);
_gnutls_read_log ("filter [write]: type=%d rc=%d\n", f->type, rc);
if (!rc)
rc = stream_fp_replace (s, &f->tmp);
rc = CDK_File_Error;
break;
}
- rc = f->fnct (f->opaque, f->ctl, s->fp, f->tmp);
+ rc = f->fnct (f->uint8_t, f->ctl, s->fp, f->tmp);
_gnutls_read_log ("filter %s [read]: type=%d rc=%d\n",
s->fname ? s->fname : "[temp]", f->type, rc);
if (rc)
void *
-_cdk_stream_get_opaque (cdk_stream_t s, int fid)
+_cdk_stream_get_uint8_t (cdk_stream_t s, int fid)
{
struct stream_filter_s *f;
for (f = s->filters; f; f = f->next)
{
if ((int) f->type == fid)
- return f->opaque;
+ return f->uint8_t;
}
return NULL;
}
};
/* Type definition for the filter function. */
-typedef cdk_error_t (*filter_fnct_t) (void *opaque, int ctl, FILE * in,
+typedef cdk_error_t (*filter_fnct_t) (void *uint8_t, int ctl, FILE * in,
FILE * out);
/* The stream filter context structure. */
{
struct stream_filter_s *next;
filter_fnct_t fnct;
- void *opaque;
+ void *uint8_t;
FILE *tmp;
union
{
size += calc_mpisize (sk->mpi, nskey);
}
else /* We do not know anything about the encrypted mpi's so we
- treat the data as opaque. */
+ treat the data as uint8_t. */
size += sk->enclen;
pkttype = is_subkey ? CDK_PKT_SECRET_SUBKEY : CDK_PKT_SECRET_KEY;
cdk_error_t err;
cdk_stream_t input = NULL;
size_t raw_len = 0;
- opaque *raw_data = NULL;
+ uint8_t *raw_data = NULL;
if (data->data == NULL || data->size == 0)
{
int
gnutls_openpgp_get_key (gnutls_datum_t * key,
gnutls_openpgp_keyring_t keyring, key_attr_t by,
- opaque * pattern)
+ uint8_t * pattern)
{
cdk_kbnode_t knode = NULL;
unsigned long keyid[2];
return GNUTLS_E_FILE_ERROR;
}
- cert.data = read_binary_file (certfile, &size);
+ cert.data = (void*)read_binary_file (certfile, &size);
cert.size = (unsigned int) size;
if (cert.data == NULL)
{
return GNUTLS_E_FILE_ERROR;
}
- key.data = read_binary_file (keyfile, &size);
+ key.data = (void*)read_binary_file (keyfile, &size);
key.size = (unsigned int) size;
if (key.data == NULL)
{
return GNUTLS_E_INVALID_REQUEST;
}
- ring.data = read_binary_file (file, &size);
+ ring.data = (void*)read_binary_file (file, &size);
ring.size = (unsigned int) size;
if (ring.data == NULL)
{
**/
int
gnutls_certificate_set_openpgp_keyring_mem (gnutls_certificate_credentials_t
- c, const opaque * data,
+ c, const uint8_t * data,
size_t dlen,
gnutls_openpgp_crt_fmt_t format)
{
int
_gnutls_openpgp_request_key (gnutls_session_t session, gnutls_datum_t * ret,
const gnutls_certificate_credentials_t cred,
- opaque * key_fpr, int key_fpr_size)
+ uint8_t * key_fpr, int key_fpr_size)
{
int rc = 0;
int gnutls_openpgp_get_key (gnutls_datum_t * key,
gnutls_openpgp_keyring_t keyring,
- key_attr_t by, opaque * pattern);
+ key_attr_t by, uint8_t * pattern);
/* internal */
int
_gnutls_openpgp_request_key (gnutls_session_t,
gnutls_datum_t * ret,
const gnutls_certificate_credentials_t cred,
- opaque * key_fpr, int key_fpr_size);
+ uint8_t * key_fpr, int key_fpr_size);
int _gnutls_openpgp_verify_key (const gnutls_certificate_credentials_t,
const gnutls_datum_t * cert_list,
static void
print_key_fingerprint (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert)
{
- char fpr[128];
+ uint8_t fpr[128];
size_t fpr_size = sizeof (fpr);
int err;
const char* name;
gnutls_datum_t * out)
{
gnutls_buffer_st str;
+ int ret;
_gnutls_buffer_init (&str);
_gnutls_buffer_append_data (&str, "\0", 1);
- out->data = str.data;
- out->size = strlen (str.data);
-
- return 0;
+ ret = _gnutls_buffer_to_datum( &str, out);
+ if (out->size > 0) out->size--;
+
+ return ret;
}
bigint_t * m)
{
size_t buf_size = 512;
- opaque *buf = gnutls_malloc (buf_size);
+ uint8_t *buf = gnutls_malloc (buf_size);
int err;
unsigned int max_pub_params = 0;
{
int ret;
size_t raw_size=0;
- opaque *der;
+ uint8_t *der;
gnutls_datum_t tmp;
ret = gnutls_openpgp_privkey_export (src, GNUTLS_OPENPGP_FMT_RAW, NULL, 0, NULL, &raw_size);
uint32_t * keyid /*[2] */ ,
gnutls_pk_params_st * params)
{
- int result, i;
- int pk_algorithm;
+ int result;
+ unsigned int i, pk_algorithm;
cdk_packet_t pkt;
gnutls_pk_params_init(params);
unsigned long nslots;
ck_slot_id_t *slots;
struct ck_info info;
- int initialized;
+ unsigned int initialized;
};
struct flags_find_data_st
static struct gnutls_pkcs11_provider_s providers[MAX_PROVIDERS];
-static int active_providers = 0;
-static int initialized_registered = 0;
+static unsigned int active_providers = 0;
+static unsigned int initialized_registered = 0;
static gnutls_pkcs11_pin_callback_t pin_func;
static void *pin_data;
pkcs11_add_module (const char *name, struct ck_function_list *module)
{
struct ck_info info;
- int i;
+ unsigned int i;
if (active_providers >= MAX_PROVIDERS)
{
{
struct ck_attribute *attr = NULL;
struct ck_version *version = NULL;
- const char *str = NULL;
+ const uint8_t *str = NULL;
size_t str_max = 0;
int terminate = 0;
int hexify = 0;
}
else if (str != NULL)
{
- data = str;
+ data = (void*)str;
length = p11_kit_space_strlen (str, str_max);
terminate = 1;
}
void
gnutls_pkcs11_deinit (void)
{
- int i;
+ unsigned int i;
init--;
if (init > 0)
pkcs11_find_slot (struct ck_function_list ** module, ck_slot_id_t * slot,
struct p11_kit_uri *info, struct token_info *_tinfo)
{
- int x, z;
+ unsigned int x, z;
for (x = 0; x < active_providers; x++)
{
struct p11_kit_uri *info, unsigned int flags)
{
ck_rv_t rv;
- int found = 0, x, z, ret;
+ unsigned int found = 0, x, z;
+ int ret;
ck_session_handle_t pks = 0;
struct ck_function_list *module = NULL;
ck_key_type_t key_type, gnutls_datum_t * pubkey)
{
struct ck_attribute a[4];
- opaque tmp1[2048];
- opaque tmp2[2048];
+ uint8_t tmp1[2048];
+ uint8_t tmp2[2048];
int ret;
switch (key_type)
struct ck_attribute a[4];
struct ck_attribute *attr;
ck_object_class_t class = -1;
- ck_certificate_type_t type = -1;
+ ck_certificate_type_t type = (ck_certificate_type_t)-1;
ck_rv_t rv;
ck_object_handle_t obj;
unsigned long count, a_vals;
int found = 0, ret;
- opaque *cert_data = NULL;
+ uint8_t *cert_data = NULL;
char label_tmp[PKCS11_LABEL_SIZE];
if (info == NULL)
a_vals++;
}
- if (type != -1)
+ if (type != (ck_certificate_type_t)-1)
{
a[a_vals].type = CKA_CERTIFICATE_TYPE;
a[a_vals].value = &type;
void *output, size_t * output_size)
{
struct p11_kit_uri *info = NULL;
- const char *str;
+ const uint8_t *str;
size_t str_max;
size_t len;
int ret;
struct crt_find_data_st *find_data = input;
struct ck_attribute a[4];
struct ck_attribute *attr;
- ck_object_class_t class = -1;
- ck_certificate_type_t type = -1;
+ ck_object_class_t class = (ck_object_class_t)-1;
+ ck_certificate_type_t type = (ck_certificate_type_t)-1;
unsigned int trusted;
ck_rv_t rv;
ck_object_handle_t obj;
unsigned long count;
- opaque *cert_data;
+ uint8_t *cert_data;
char certid_tmp[PKCS11_ID_SIZE];
char label_tmp[PKCS11_LABEL_SIZE];
- int ret, i;
+ int ret;
struct pkey_list plist; /* private key holder */
- int tot_values = 0;
+ unsigned int i, tot_values = 0;
if (info == NULL)
{ /* final call */
}
else if (find_data->flags == GNUTLS_PKCS11_OBJ_ATTR_ALL)
{
- if (class != -1)
+ if (class != (ck_object_class_t)-1)
{
a[tot_values].type = CKA_CLASS;
a[tot_values].value = &class;
a[tot_values].value_len = sizeof class;
tot_values++;
}
- if (type != -1)
+ if (type != (ck_certificate_type_t)-1)
{
a[tot_values].type = CKA_CERTIFICATE_TYPE;
a[tot_values].value = &type;
gnutls_pkcs11_obj_t * const objs,
unsigned int flags)
{
- int i, j;
+ unsigned int i, j;
int ret;
for (i = 0; i < cert_max; i++)
* Since: 2.12.0
**/
int
-gnutls_pkcs11_token_get_mechanism (const char *url, int idx,
+gnutls_pkcs11_token_get_mechanism (const char *url, unsigned int idx,
unsigned long *mechanism)
{
int ret;
ck_rv_t
pkcs11_set_pin (struct ck_function_list *module,
ck_session_handle_t sess,
- unsigned char *old_pin,
+ const char *old_pin,
unsigned long old_len,
- unsigned char *new_pin,
+ const char *new_pin,
unsigned long new_len)
{
- return (module)->C_SetPIN (sess, old_pin, old_len, new_pin, new_len);
+ return (module)->C_SetPIN (sess, (uint8_t*)old_pin, old_len, (uint8_t*)new_pin, new_len);
}
const char *
ck_rv_t
pkcs11_set_pin (struct ck_function_list *module,
ck_session_handle_t sess,
- unsigned char *old_pin,
+ const char *old_pin,
unsigned long old_len,
- unsigned char *new_pin,
+ const char *new_pin,
unsigned long new_len);
const char *
ck_key_type_t keytype = CKK_GENERIC_SECRET;
ck_bool_t tval = 1;
int a_val;
- opaque id[16];
+ uint8_t id[16];
ret = pkcs11_url_to_info (token_url, &info);
if (ret < 0)
struct p11_kit_uri *info = NULL;
ck_rv_t rv;
size_t der_size, id_size;
- opaque *der = NULL;
- opaque id[20];
+ uint8_t *der = NULL;
+ uint8_t id[20];
struct ck_attribute a[16];
ck_object_class_t class = CKO_CERTIFICATE;
ck_certificate_type_t type = CKC_X_509;
struct p11_kit_uri *info = NULL;
ck_rv_t rv;
size_t id_size;
- opaque id[20];
+ uint8_t id[20];
struct ck_attribute a[16];
ck_object_class_t class = CKO_PRIVATE_KEY;
ck_object_handle_t obj;
struct ck_attribute a[4];
struct ck_attribute *attr;
ck_object_class_t class;
- ck_certificate_type_t type = -1;
+ ck_certificate_type_t type = (ck_certificate_type_t)-1;
ck_rv_t rv;
ck_object_handle_t obj;
unsigned long count, a_vals;
a_vals++;
}
- if (type != -1)
+ if (type != (ck_certificate_type_t)-1)
{
a[a_vals].type = CKA_CERTIFICATE_TYPE;
a[a_vals].value = &type;
memcpy (flabel, label, strlen (label));
rv =
- pkcs11_init_token (module, slot, (char *) so_pin, strlen (so_pin),
- flabel);
+ pkcs11_init_token (module, slot, (uint8_t*)so_pin, strlen (so_pin),
+ (uint8_t*)flabel);
if (rv != CKR_OK)
{
gnutls_assert ();
if (oldpin == NULL)
{
- rv = pkcs11_init_pin (module, pks, (char *) newpin, strlen (newpin));
+ rv = pkcs11_init_pin (module, pks, (uint8_t *) newpin, strlen (newpin));
if (rv != CKR_OK)
{
gnutls_assert ();
else
{
rv = pkcs11_set_pin (module, pks,
- (char *) oldpin, strlen (oldpin),
- (char *) newpin, strlen (newpin));
+ oldpin, strlen (oldpin),
+ newpin, strlen (newpin));
if (rv != CKR_OK)
{
gnutls_assert ();
str[len] = 0;
/* Refuse to deal with strings containing NULs. */
- if (strlen (str) != len)
+ if (strlen (str) != (size_t)len)
return GNUTLS_E_ASN1_DER_ERROR;
if (res)
_gnutls_str_cpy (res, *res_size, str);
- *res_size = len;
+ *res_size = (size_t)len;
asn1_delete_structure (&tmpasn);
}
str[len] = 0;
/* Refuse to deal with strings containing NULs. */
- if (strlen (str) != len)
+ if (strlen (str) != (size_t)len)
return GNUTLS_E_ASN1_DER_ERROR;
if (res)
_gnutls_str_cpy (res, *res_size, str);
- *res_size = len;
+ *res_size = (size_t)len;
}
else
{
- result = _gnutls_x509_data2hex (str, len, res, res_size);
+ result = _gnutls_x509_data2hex (str, (size_t)len, res, res_size);
if (result < 0)
{
gnutls_assert ();
* something like '#01020304'
*/
int
-_gnutls_x509_data2hex (const opaque * data, size_t data_size,
- opaque * out, size_t * sizeof_out)
+_gnutls_x509_data2hex (const void * data, size_t data_size,
+ void * _out, size_t * sizeof_out)
{
char *res;
char escaped[MAX_STRING_LEN];
unsigned int size;
+ char* out = _out;
if (2 * data_size + 1 > MAX_STRING_LEN)
{
mktime_utc (const struct fake_tm *tm)
{
time_t result = 0;
- unsigned int i;
+ int i;
/* We do allow some ill-formed dates, but we don't do anything special
* with them and our callers really shouldn't pass them to us. Do
* YEAR(2)|MONTH(2)|DAY(2)|HOUR(2)|MIN(2)|SEC(2)
*/
static int
-_gnutls_x509_gtime2utcTime (time_t gtime, char *str_time, int str_time_size)
+_gnutls_x509_gtime2utcTime (time_t gtime, char *str_time, size_t str_time_size)
{
size_t ret;
struct tm _tm;
asn1_der_coding (asn1_data, name, output_data, &len,
NULL)) != ASN1_SUCCESS)
{
- *output_data_size = len;
+ *output_data_size = (size_t)len;
if (result == ASN1_MEM_ERROR)
{
return GNUTLS_E_SHORT_MEMORY_BUFFER;
return _gnutls_asn2err (result);
}
- *output_data_size = len;
+ *output_data_size = (size_t)len;
}
else
{ /* PEM */
- opaque *out;
+ uint8_t *out;
gnutls_datum_t tmp;
result = _gnutls_x509_der_encode (asn1_data, name, &tmp, 0);
return GNUTLS_E_INTERNAL_ERROR;
}
- if ((unsigned) result > *output_data_size)
+ if ((size_t) result > *output_data_size)
{
gnutls_assert ();
gnutls_free (out);
- *output_data_size = result;
+ *output_data_size = (size_t)result;
return GNUTLS_E_SHORT_MEMORY_BUFFER;
}
- *output_data_size = result;
+ *output_data_size = (size_t)result;
if (output_data)
{
- memcpy (output_data, out, result);
+ memcpy (output_data, out, (size_t)result);
/* do not include the null character into output size.
*/
- *output_data_size = result - 1;
+ *output_data_size = (size_t)result - 1;
}
gnutls_free (out);
*/
int
_gnutls_x509_decode_octet_string (const char *string_type,
- const opaque * der, size_t der_size,
- opaque * output, size_t * output_size)
+ const uint8_t * der, size_t der_size,
+ uint8_t * output, size_t * output_size)
{
ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
int result, tmp_output_size;
tmp_output_size = *output_size;
result = asn1_read_value (c2, "", output, &tmp_output_size);
- *output_size = tmp_output_size;
+ *output_size = (size_t)tmp_output_size;
if (result != ASN1_SUCCESS)
{
{
int len = 0, result;
size_t slen;
- opaque *tmp = NULL;
+ uint8_t *tmp = NULL;
result = asn1_read_value (c, root, NULL, &len);
if (result != ASN1_MEM_ERROR)
if (flags == 2)
len /= 8;
- tmp = gnutls_malloc (len);
+ tmp = gnutls_malloc ((size_t)len);
if (tmp == NULL)
{
gnutls_assert ();
if (flags == 1)
{
- slen = len;
+ slen = (size_t)len;
result = _gnutls_x509_decode_octet_string (NULL, tmp, slen, tmp, &slen);
if (result < 0)
{
}
ret->data = tmp;
- ret->size = len;
+ ret->size = (unsigned)len;
return 0;
{
int size, result;
int asize;
- opaque *data = NULL;
+ uint8_t *data = NULL;
ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
size = 0;
size += 16; /* for later to include the octet tags */
asize = size;
- data = gnutls_malloc (size);
+ data = gnutls_malloc ((size_t)size);
if (data == NULL)
{
gnutls_assert ();
}
res->data = data;
- res->size = size;
+ res->size = (unsigned)size;
return 0;
cleanup:
/* Write the data.
*/
- result = asn1_write_value (dest, dest_name, encoded.data, encoded.size);
+ result = asn1_write_value (dest, dest_name, encoded.data, (int)encoded.size);
_gnutls_free_datum (&encoded);
return result;
}
- result = _gnutls_x509_oid2sign_algorithm (sa.data);
+ result = _gnutls_x509_oid2sign_algorithm ( (char*)sa.data);
_gnutls_free_datum (&sa);
int _gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim);
int _gnutls_x509_decode_octet_string (const char *string_type,
- const opaque * der, size_t der_size,
- opaque * output, size_t * output_size);
+ const uint8_t * der, size_t der_size,
+ uint8_t * output, size_t * output_size);
int _gnutls_x509_oid_data2string (const char *OID, void *value,
int value_size, char *res,
size_t * res_size);
-int _gnutls_x509_data2hex (const opaque * data, size_t data_size,
- opaque * out, size_t * sizeof_out);
+int _gnutls_x509_data2hex (const void * data, size_t data_size,
+ void * out, size_t * sizeof_out);
const char *_gnutls_x509_oid2asn_string (const char *oid);
*/
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
result = _gnutls_fbase64_decode (PEM_CRL, data->data, data->size, &out);
len = bits / 8;
- if (*sizeof_sig < len)
+ if (*sizeof_sig < (unsigned)len)
{
*sizeof_sig = bits / 8;
return GNUTLS_E_SHORT_MEMORY_BUFFER;
int
gnutls_x509_crl_get_version (gnutls_x509_crl_t crl)
{
- opaque version[8];
+ uint8_t version[8];
int len, result;
if (crl == NULL)
{
int ret;
size_t der_size;
- opaque *der;
+ uint8_t *der;
gnutls_datum_t tmp;
ret = gnutls_x509_crl_export (src, GNUTLS_X509_FMT_DER, NULL, &der_size);
int
gnutls_x509_crl_get_extension_info (gnutls_x509_crl_t crl, int indx,
void *oid, size_t * sizeof_oid,
- int *critical)
+ unsigned int *critical)
{
int result;
char str_critical[10];
time_t revocation_time)
{
int ret;
- opaque serial[128];
+ uint8_t serial[128];
size_t serial_size;
if (crl == NULL || crt == NULL)
*/
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
/* Try the first header */
result = _gnutls_fbase64_decode (PEM_CRQ, data->data, data->size, &out);
int
gnutls_x509_crq_get_version (gnutls_x509_crq_t crq)
{
- opaque version[8];
+ uint8_t version[8];
int len, result;
if (crq == NULL)
{
int result;
uint16_t _usage;
- opaque buf[128];
+ uint8_t buf[128];
size_t buf_size = sizeof (buf);
if (crq == NULL)
{
int result;
unsigned int tmp_ca;
- opaque buf[256];
+ uint8_t buf[256];
size_t buf_size = sizeof (buf);
if (crq == NULL)
char tmpbuffer1[ASN1_MAX_NAME_SIZE];
char tmpbuffer2[ASN1_MAX_NAME_SIZE];
char tmpbuffer3[ASN1_MAX_NAME_SIZE];
- opaque value[MAX_STRING_LEN], *value2 = NULL;
+ uint8_t value[MAX_STRING_LEN], *value2 = NULL;
char *escaped = NULL;
const char *ldap_desc;
char oid[MAX_OID_SIZE];
char tmpbuffer1[ASN1_MAX_NAME_SIZE];
char tmpbuffer2[ASN1_MAX_NAME_SIZE];
char tmpbuffer3[ASN1_MAX_NAME_SIZE];
- opaque value[256];
+ uint8_t value[256];
char oid[MAX_OID_SIZE];
int len, printable;
int i = 0;
int sizeof_data, int multi)
{
const char *val_name;
- const opaque *data = _data;
+ const uint8_t *data = _data;
char tmp[128];
ASN1_TYPE c2;
int result;
/**
* gnutls_x509_dn_deinit:
- * @dn: a DN opaque object pointer.
+ * @dn: a DN uint8_t object pointer.
*
* This function deallocates the DN object as returned by
* gnutls_x509_dn_import().
/**
* gnutls_x509_dn_export:
- * @dn: Holds the opaque DN object
+ * @dn: Holds the uint8_t DN object
* @format: the format of output params. One of PEM or DER.
* @output_data: will contain a DN PEM or DER encoded
* @output_data_size: holds the size of output_data (and will be
*/
int
_gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
- opaque * extnValue, int extnValueLen)
+ uint8_t * extnValue, int extnValueLen)
{
ASN1_TYPE ext = ASN1_TYPE_EMPTY;
int len, result;
int
_gnutls_x509_ext_extract_basicConstraints (unsigned int *CA,
int *pathLenConstraint,
- opaque * extnValue,
+ uint8_t * extnValue,
int extnValueLen)
{
ASN1_TYPE ext = ASN1_TYPE_EMPTY;
/* extract an INTEGER from the DER encoded extension
*/
int
-_gnutls_x509_ext_extract_number (opaque * number,
+_gnutls_x509_ext_extract_number (uint8_t * number,
size_t * _nr_size,
- opaque * extnValue, int extnValueLen)
+ uint8_t * extnValue, int extnValueLen)
{
ASN1_TYPE ext = ASN1_TYPE_EMPTY;
int result;
/* generate an INTEGER in a DER encoded extension
*/
int
-_gnutls_x509_ext_gen_number (const opaque * number, size_t nr_size,
+_gnutls_x509_ext_gen_number (const uint8_t * number, size_t nr_size,
gnutls_datum_t * der_ext)
{
ASN1_TYPE ext = ASN1_TYPE_EMPTY;
char **policyLanguage,
char **policy,
size_t * sizeof_policy,
- opaque * extnValue, int extnValueLen)
+ uint8_t * extnValue, int extnValueLen)
{
ASN1_TYPE ext = ASN1_TYPE_EMPTY;
int result;
}
if (policyLanguage)
- *policyLanguage = gnutls_strdup (value.data);
+ *policyLanguage = gnutls_strdup ((char*)value.data);
result = _gnutls_x509_read_value (ext, "proxyPolicy.policy", &value, 0);
if (result == GNUTLS_E_ASN1_ELEMENT_NOT_FOUND)
else
{
if (policy)
- *policy = value.data;
+ *policy = (char*)value.data;
if (sizeof_policy)
*sizeof_policy = value.size;
}
#include <gnutls_num.h>
#include <gnutls_ecc.h>
-static int _gnutls_x509_read_rsa_pubkey (opaque * der, int dersize,
+static int _gnutls_x509_read_rsa_pubkey (uint8_t * der, int dersize,
gnutls_pk_params_st* params);
-static int _gnutls_x509_read_dsa_pubkey (opaque * der, int dersize,
+static int _gnutls_x509_read_dsa_pubkey (uint8_t * der, int dersize,
gnutls_pk_params_st * params);
-static int _gnutls_x509_read_ecc_pubkey (opaque * der, int dersize,
+static int _gnutls_x509_read_ecc_pubkey (uint8_t * der, int dersize,
gnutls_pk_params_st * params);
static int
-_gnutls_x509_read_dsa_params (opaque * der, int dersize, gnutls_pk_params_st * params);
+_gnutls_x509_read_dsa_params (uint8_t * der, int dersize, gnutls_pk_params_st * params);
/*
* some x509 certificate parsing functions that relate to MPI parameter
* Returns 2 parameters (m,e). It does not set params_nr.
*/
int
-_gnutls_x509_read_rsa_pubkey (opaque * der, int dersize, gnutls_pk_params_st * params)
+_gnutls_x509_read_rsa_pubkey (uint8_t * der, int dersize, gnutls_pk_params_st * params)
{
int result;
ASN1_TYPE spk = ASN1_TYPE_EMPTY;
* Returns 2 parameters (m,e). It does not set params_nr.
*/
int
-_gnutls_x509_read_ecc_pubkey (opaque * der, int dersize, gnutls_pk_params_st * params)
+_gnutls_x509_read_ecc_pubkey (uint8_t * der, int dersize, gnutls_pk_params_st * params)
{
/* Eventhough RFC5480 defines the public key to be an ECPoint (i.e. OCTET STRING),
* it is actually copied in raw there. Why do they use ASN.1 anyway?
* params[0-2]. It does NOT set params_nr.
*/
static int
-_gnutls_x509_read_dsa_params (opaque * der, int dersize, gnutls_pk_params_st * params)
+_gnutls_x509_read_dsa_params (uint8_t * der, int dersize, gnutls_pk_params_st * params)
{
int result;
ASN1_TYPE spk = ASN1_TYPE_EMPTY;
* params[0-4]. It does NOT set params_nr.
*/
int
-_gnutls_x509_read_ecc_params (opaque * der, int dersize, gnutls_pk_params_st * params)
+_gnutls_x509_read_ecc_params (uint8_t * der, int dersize, gnutls_pk_params_st * params)
{
int ret;
ASN1_TYPE spk = ASN1_TYPE_EMPTY;
}
-int _gnutls_x509_read_pubkey (gnutls_pk_algorithm_t algo, opaque * der, int dersize,
+int _gnutls_x509_read_pubkey (gnutls_pk_algorithm_t algo, uint8_t * der, int dersize,
gnutls_pk_params_st * params)
{
int ret;
return ret;
}
-int _gnutls_x509_read_pubkey_params (gnutls_pk_algorithm_t algo, opaque * der, int dersize,
+int _gnutls_x509_read_pubkey_params (gnutls_pk_algorithm_t algo, uint8_t * der, int dersize,
gnutls_pk_params_st * params)
{
switch(algo)
* only sets params[3]
*/
int
-_gnutls_x509_read_dsa_pubkey (opaque * der, int dersize, gnutls_pk_params_st * params)
+_gnutls_x509_read_dsa_pubkey (uint8_t * der, int dersize, gnutls_pk_params_st * params)
{
/* do not set a number */
params->params_nr = 0;
_gnutls_asn1_encode_rsa (ASN1_TYPE * c2, gnutls_pk_params_st * params)
{
int result;
- opaque null = '\0';
+ uint8_t null = '\0';
gnutls_pk_params_st pk_params;
gnutls_datum_t m, e, d, p, q, u, exp1, exp2;
_gnutls_asn1_encode_ecc (ASN1_TYPE * c2, gnutls_pk_params_st * params)
{
int ret;
- opaque one = '\x01';
+ uint8_t one = '\x01';
gnutls_datum pubkey = { NULL, 0 };
const char *oid;
{
int result, i;
size_t size[DSA_PRIVATE_PARAMS], total;
- opaque *p_data, *q_data, *g_data, *x_data, *y_data;
- opaque *all_data = NULL, *p;
- opaque null = '\0';
+ uint8_t *p_data, *q_data, *g_data, *x_data, *y_data;
+ uint8_t *all_data = NULL, *p;
+ uint8_t null = '\0';
/* Read all the sizes */
total = 0;
*/
int
-_gnutls_x509_read_der_int (opaque * der, int dersize, bigint_t * out)
+_gnutls_x509_read_der_int (uint8_t * der, int dersize, bigint_t * out)
{
int result;
ASN1_TYPE spk = ASN1_TYPE_EMPTY;
_gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret)
{
int len, result;
- opaque *tmpstr;
+ uint8_t *tmpstr;
len = 0;
result = asn1_read_value (node, value, NULL, &len);
int
_gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value, uint32_t num)
{
- opaque tmpstr[4];
+ uint8_t tmpstr[4];
int result;
_gnutls_write_uint32 (num, tmpstr);
print_keyid (gnutls_buffer_st * str, gnutls_x509_crt_t cert)
{
int err;
- char buffer[32];
+ unsigned char buffer[32];
size_t size = sizeof(buffer);
const char* name;
char* p;
gnutls_datum_t * out)
{
gnutls_buffer_st str;
+ int ret;
if (format == GNUTLS_CRT_PRINT_FULL
|| format == GNUTLS_CRT_PRINT_UNSIGNED_FULL)
print_other (&str, cert, format == GNUTLS_CRT_PRINT_UNSIGNED_FULL);
_gnutls_buffer_append_data (&str, "\0", 1);
- out->data = str.data;
- out->size = strlen (str.data);
+
+ ret = _gnutls_buffer_to_datum( &str, out);
+ if (out->size > 0) out->size--;
+
+ return ret;
}
else if (format == GNUTLS_CRT_PRINT_ONELINE)
{
print_oneline (&str, cert);
_gnutls_buffer_append_data (&str, "\0", 1);
- out->data = str.data;
- out->size = strlen (str.data);
+
+ ret = _gnutls_buffer_to_datum( &str, out);
+ if (out->size > 0) out->size--;
+
+ return ret;
}
else
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
-
- return 0;
}
#ifdef ENABLE_PKI
for (j = 0; j < num; j++)
{
- char serial[128];
+ unsigned char serial[128];
size_t serial_size = sizeof (serial);
int err;
time_t tim;
gnutls_datum_t * out)
{
gnutls_buffer_st str;
+ int ret;
_gnutls_buffer_init (&str);
print_crl (&str, crl, format == GNUTLS_CRT_PRINT_UNSIGNED_FULL);
_gnutls_buffer_append_data (&str, "\0", 1);
- out->data = str.data;
- out->size = strlen (str.data);
-
- return 0;
+
+ ret = _gnutls_buffer_to_datum( &str, out);
+ if (out->size > 0) out->size--;
+
+ return ret;
}
static void
{
int err;
size_t size = 0;
- char *buffer = NULL;
+ unsigned char *buffer = NULL;
err = gnutls_x509_crq_get_key_id (crq, 0, buffer, &size);
if (err != GNUTLS_E_SHORT_MEMORY_BUFFER)
gnutls_datum_t * out)
{
gnutls_buffer_st str;
+ int ret;
_gnutls_buffer_init (&str);
print_crq_other (&str, crq);
_gnutls_buffer_append_data (&str, "\0", 1);
- out->data = str.data;
- out->size = strlen (str.data);
- return 0;
+ ret = _gnutls_buffer_to_datum( &str, out);
+ if (out->size > 0) out->size--;
+
+ return ret;
}
#endif /* ENABLE_PKI */
int
_gnutls_pbkdf2_sha1 (const char *P, size_t Plen,
- const char *S, size_t Slen,
- unsigned int c, char *DK, size_t dkLen)
+ const unsigned char *S, size_t Slen,
+ unsigned int c, unsigned char *DK, size_t dkLen)
{
unsigned int hLen = 20;
char U[20];
int _gnutls_pbkdf2_sha1 (const char *P, size_t Plen,
- const char *S, size_t Slen,
- unsigned int c, char *DK, size_t dkLen);
+ const unsigned char *S, size_t Slen,
+ unsigned int c, unsigned char *DK, size_t dkLen);
*/
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
result = _gnutls_fbase64_decode (PEM_PKCS12, data->data, data->size,
&out);
continue;
}
bag->element[i].friendly_name =
- ucs2_to_ascii (attr_val.data, attr_val.size);
+ ucs2_to_ascii ((char*)attr_val.data, attr_val.size);
}
else
{
int
gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
{
- opaque salt[8], key[20];
+ uint8_t salt[8], key[20];
int result;
const int iter = 1;
digest_hd_st td1;
gnutls_datum_t tmp = { NULL, 0 };
- opaque sha_mac[20];
+ uint8_t sha_mac[20];
if (pkcs12 == NULL)
{
int
gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
{
- opaque key[20];
+ uint8_t key[20];
int result;
unsigned int iter;
int len;
gnutls_datum_t tmp = { NULL, 0 }, salt =
{
NULL, 0};
- opaque sha_mac[20];
- opaque sha_mac_orig[20];
+ uint8_t sha_mac[20];
+ uint8_t sha_mac_orig[20];
if (pkcs12 == NULL)
{
if (bag->element[elem].friendly_name != NULL)
{
- opaque *name;
+ uint8_t *name;
int size, i;
const char *p;
static int
_pkcs12_check_pass (const char *pass, size_t plen)
{
- const unsigned char *p = pass;
unsigned int i;
for (i = 0; i < plen; i++)
{
- if (isascii (p[i]))
+ if (isascii (pass[i]))
continue;
return GNUTLS_E_INVALID_PASSWORD;
}
* 1 for encryption key
*/
int
-_gnutls_pkcs12_string_to_key (unsigned int id, const opaque * salt,
+_gnutls_pkcs12_string_to_key (unsigned int id, const uint8_t * salt,
unsigned int salt_size, unsigned int iter,
const char *pw, unsigned int req_keylen,
- opaque * keybuf)
+ uint8_t * keybuf)
{
int rc;
unsigned int i, j;
bigint_t num_b1 = NULL, num_ij = NULL;
bigint_t mpi512 = NULL;
unsigned int pwlen;
- opaque hash[20], buf_b[64], buf_i[128], *p;
+ uint8_t hash[20], buf_b[64], buf_i[128], *p;
size_t cur_keylen;
size_t n, m;
- const opaque buf_512[] = /* 2^64 */
+ const uint8_t buf_512[] = /* 2^64 */
{ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
{
char oid[MAX_OID_SIZE];
ASN1_TYPE c2;
- opaque *tmp = NULL;
+ uint8_t *tmp = NULL;
int tmp_size, len, result;
len = sizeof (oid) - 1;
*/
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
result = _gnutls_fbase64_decode (PEM_PKCS7, data->data, data->size,
&out);
int
gnutls_x509_privkey_cpy (gnutls_x509_privkey_t dst, gnutls_x509_privkey_t src)
{
- int i, ret;
+ unsigned int i;
+ int ret;
if (!src || !dst)
return GNUTLS_E_INVALID_REQUEST;
*/
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
/* Try the first header */
result =
struct pbkdf2_params
{
- opaque salt[32];
+ uint8_t salt[32];
int salt_size;
unsigned int iter_count;
unsigned int key_size;
struct pbe_enc_params
{
gnutls_cipher_algorithm_t cipher;
- opaque iv[MAX_CIPHER_BLOCK_SIZE];
+ uint8_t iv[MAX_CIPHER_BLOCK_SIZE];
int iv_size;
};
_encode_privkey (gnutls_x509_privkey_t pkey, gnutls_datum_t * raw)
{
size_t size = 0;
- opaque *data = NULL;
+ uint8_t *data = NULL;
int ret;
ASN1_TYPE spk = ASN1_TYPE_EMPTY;
gnutls_datum_t * der, ASN1_TYPE * pkey_info)
{
int result, len;
- opaque null = 0;
+ uint8_t null = 0;
const char *oid;
gnutls_datum_t algo_params = { NULL, 0 };
gnutls_datum_t algo_privkey = { NULL, 0 };
*/
static int
read_pkcs_schema_params (schema_id * schema, const char *password,
- const opaque * data, int data_size,
+ const uint8_t * data, int data_size,
struct pbkdf2_params *kdf_params,
struct pbe_enc_params *enc_params)
{
goto error;
}
- tmp.data = (opaque *) data;
+ tmp.data = (uint8_t *) data;
tmp.size = data_size;
result = read_pbkdf2_params (pbes2_asn, &tmp, kdf_params);
gnutls_x509_privkey_t pkey)
{
int result, len;
- opaque oid[64];
+ char oid[64];
ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
*/
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
/* Try the first header
*/
{
int result;
int data_size;
- opaque *data = NULL, *key = NULL;
+ uint8_t *data = NULL, *key = NULL;
gnutls_datum_t dkey, d_iv;
cipher_hd_st ch;
int ch_init = 0;
dkey.data = key;
dkey.size = key_size;
- d_iv.data = (opaque *) enc_params->iv;
+ d_iv.data = (uint8_t *) enc_params->iv;
d_iv.size = enc_params->iv_size;
result = _gnutls_cipher_init (&ch, enc_params->cipher, &dkey, &d_iv, 0);
{
int result;
ASN1_TYPE pbkdf2_asn = ASN1_TYPE_EMPTY;
- opaque tmp[64];
+ uint8_t tmp[64];
/* Write the key derivation algorithm
*/
{
int result;
int data_size;
- opaque *data = NULL;
+ uint8_t *data = NULL;
gnutls_datum_t d_iv;
cipher_hd_st ch;
int ch_init = 0;
- opaque pad, pad_size;
+ uint8_t pad, pad_size;
pad_size = gnutls_cipher_get_block_size (enc_params->cipher);
data_size = plain->size + pad;
- d_iv.data = (opaque *) enc_params->iv;
+ d_iv.data = (uint8_t *) enc_params->iv;
d_iv.size = enc_params->iv_size;
result = _gnutls_cipher_init (&ch, enc_params->cipher, key, &d_iv, 1);
gnutls_datum_t * tbs)
{
int result;
- opaque *buf;
+ uint8_t *buf;
int buf_size;
buf_size = 0;
};
struct gnutls_x509_trust_list_st {
- int size;
+ unsigned int size;
struct node_st *node;
};
gnutls_x509_trust_list_deinit(gnutls_x509_trust_list_t list,
unsigned int all)
{
- int i, j;
+ unsigned int i, j;
if (!list)
return;
*/
static int shorten_clist(gnutls_x509_trust_list_t list,
gnutls_x509_crt_t * certificate_list,
- int clist_size)
+ unsigned int clist_size)
{
- int i, ret;
+ int ret;
+ unsigned int j, i;
uint32_t hash;
gnutls_datum_t dn;
* self-signed E but already removed above), and we trust B, remove
* B, C and D. */
for (i = 1; i < clist_size; i++) {
- int j;
-
ret = gnutls_x509_crt_get_raw_issuer_dn(certificate_list[i], &dn);
if (ret < 0) {
gnutls_assert();
unsigned int flags)
{
gnutls_datum_t dn;
- int ret, i;
+ int ret;
+ unsigned int i;
uint32_t hash;
ret = gnutls_x509_crt_get_raw_issuer_dn(cert, &dn);
gnutls_verify_output_function func)
{
gnutls_datum_t dn;
- int ret, i;
+ int ret;
+ unsigned int i;
uint32_t hash;
if (cert_list == NULL || cert_list_size < 1)
gnutls_verify_output_function func)
{
gnutls_datum_t dn;
- int ret, i;
+ int ret;
+ unsigned int i;
uint32_t hash;
ret = gnutls_x509_crt_get_raw_issuer_dn(cert, &dn);
gnutls_x509_crt_t cert)
{
gnutls_datum_t dn;
- int ret, i;
+ int ret;
+ unsigned int i;
uint32_t hash;
ret = gnutls_x509_crt_get_raw_dn (cert, &dn);
{
NULL, 0};
int result;
- opaque serial1[128], serial2[128];
+ uint8_t serial1[128], serial2[128];
size_t serial1_size, serial2_size;
serial1_size = sizeof (serial1);
gnutls_pk_algorithm_t pk,
gnutls_pk_params_st * issuer_params)
{
- opaque digest[MAX_HASH_SIZE];
+ uint8_t digest[MAX_HASH_SIZE];
gnutls_datum_t decrypted;
- int digest_size;
+ unsigned int digest_size;
int ret;
switch (pk)
{
int ret;
size_t der_size=0;
- opaque *der;
+ uint8_t *der;
gnutls_datum_t tmp;
ret = gnutls_x509_crt_export (src, GNUTLS_X509_FMT_DER, NULL, &der_size);
*/
if (format == GNUTLS_X509_FMT_PEM)
{
- opaque *out;
+ uint8_t *out;
/* Try the first header */
result =
int
gnutls_x509_crt_get_version (gnutls_x509_crt_t cert)
{
- opaque version[8];
+ uint8_t version[8];
int len, result;
if (cert == NULL)
* This function will return the X.509 certificate's serial number.
* This is obtained by the X509 Certificate serialNumber field. Serial
* is not always a 32 or 64bit number. Some CAs use large serial
- * numbers, thus it may be wise to handle it as something opaque.
+ * numbers, thus it may be wise to handle it as something uint8_t.
*
* Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a
* negative error value.
int len;
char nptr[ASN1_MAX_NAME_SIZE];
int result;
- opaque choice_type[128];
+ char choice_type[128];
gnutls_x509_subject_alt_name_t type;
seq++; /* 0->1, 1->2 etc */
if (othername_oid)
{
- if (len > strlen (XMPP_OID) && strcmp (name, XMPP_OID) == 0)
+ if ((unsigned)len > strlen (XMPP_OID) && strcmp (name, XMPP_OID) == 0)
type = GNUTLS_SAN_OTHERNAME_XMPP;
}
else
return _gnutls_asn2err (result);
}
- if (len > strlen (XMPP_OID) && strcmp (oid, XMPP_OID) == 0)
+ if ((unsigned)len > strlen (XMPP_OID) && strcmp (oid, XMPP_OID) == 0)
{
ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
size_t orig_name_size = *name_size;
}
asn1_delete_structure (&c2);
- if (len + 1 > orig_name_size)
+ if ((unsigned)len + 1 > orig_name_size)
{
gnutls_assert ();
*name_size = len + 1;
if (is_type_printable (type))
{
- if (len + 1 > orig_name_size)
+ if ((unsigned)len + 1 > orig_name_size)
{
gnutls_assert ();
(*name_size)++;
/**
* gnutls_x509_crt_get_subject:
* @cert: should contain a #gnutls_x509_crt_t structure
- * @dn: output variable with pointer to opaque DN.
+ * @dn: output variable with pointer to uint8_t DN.
*
- * Return the Certificate's Subject DN as an opaque data type. You
+ * Return the Certificate's Subject DN as an uint8_t data type. You
* may use gnutls_x509_dn_get_rdn_ava() to decode the DN.
*
* Note that @dn should be treated as constant. Because points
/**
* gnutls_x509_crt_get_issuer:
* @cert: should contain a #gnutls_x509_crt_t structure
- * @dn: output variable with pointer to opaque DN
+ * @dn: output variable with pointer to uint8_t DN
*
- * Return the Certificate's Issuer DN as an opaque data type. You may
+ * Return the Certificate's Issuer DN as an uint8_t data type. You may
* use gnutls_x509_dn_get_rdn_ava() to decode the DN.
*
* Note that @dn should be treated as constant. Because points
/**
* gnutls_x509_dn_get_rdn_ava:
- * @dn: input variable with opaque DN pointer
+ * @dn: input variable with uint8_t DN pointer
* @irdn: index of RDN
* @iava: index of AVA.
* @ava: Pointer to structure which will hold output information.
gnutls_digest_algorithm_t algo,
void *buf, size_t * buf_size)
{
- opaque *cert_buf;
+ uint8_t *cert_buf;
int cert_buf_size;
int result;
gnutls_datum_t tmp;
int ret = 0;
gnutls_datum_t der = { NULL, 0 };
const gnutls_digest_algorithm_t hash = GNUTLS_DIG_SHA1;
- int digest_len = _gnutls_hash_get_algo_len(hash);
+ unsigned int digest_len = _gnutls_hash_get_algo_len(hash);
if (output_data == NULL || *output_data_size < digest_len)
{
int crl_list_length,
gnutls_verify_output_function func)
{
- opaque serial[128];
- opaque cert_serial[128];
+ uint8_t serial[128];
+ uint8_t cert_serial[128];
size_t serial_size, cert_serial_size;
int ncerts, ret, i, j;
gnutls_datum_t dn1, dn2;
gnutls_assert ();
return _gnutls_asn2err (result);
}
- if (len != strlen (oid) + 1 || memcmp (tmpoid, oid, len) != 0)
+ if ((unsigned)len != strlen (oid) + 1 || memcmp (tmpoid, oid, len) != 0)
return GNUTLS_E_UNKNOWN_ALGORITHM;
}
/* fall through */
unsigned int seq,
int what,
gnutls_datum_t * data,
- int *critical)
+ unsigned int *critical)
{
int ret;
gnutls_datum_t aia;
gnutls_x509_privkey_t pkey);
int
-_gnutls_x509_read_ecc_params (opaque * der, int dersize, gnutls_pk_params_st * params);
+_gnutls_x509_read_ecc_params (uint8_t * der, int dersize, gnutls_pk_params_st * params);
int _gnutls_asn1_encode_privkey (gnutls_pk_algorithm_t pk, ASN1_TYPE * c2, gnutls_pk_params_st * params);
int indx, void *ret,
size_t * ret_size);
int _gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
- opaque * extnValue, int extnValueLen);
+ uint8_t * extnValue, int extnValueLen);
int _gnutls_x509_ext_extract_basicConstraints (unsigned int *CA,
int *pathLenConstraint,
- opaque * extnValue,
+ uint8_t * extnValue,
int extnValueLen);
int _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
const char *extension_id,
unsigned int critical);
int
-_gnutls_x509_ext_extract_number (opaque * number,
+_gnutls_x509_ext_extract_number (uint8_t * number,
size_t * nr_size,
- opaque * extnValue, int extnValueLen);
+ uint8_t * extnValue, int extnValueLen);
int
-_gnutls_x509_ext_gen_number (const opaque * nuber, size_t nr_size,
+_gnutls_x509_ext_gen_number (const uint8_t * nuber, size_t nr_size,
gnutls_datum_t * der_ext);
char **policyLanguage,
char **policy,
size_t * sizeof_policy,
- opaque * extnValue,
+ uint8_t * extnValue,
int extnValueLen);
int _gnutls_x509_ext_gen_proxyCertInfo (int pathLenConstraint,
const char *policyLanguage,
int _gnutls_x509_crt_get_mpis (gnutls_x509_crt_t cert,
gnutls_pk_params_st * params);
-int _gnutls_x509_read_pubkey_params (gnutls_pk_algorithm_t, opaque * der, int dersize,
+int _gnutls_x509_read_pubkey_params (gnutls_pk_algorithm_t, uint8_t * der, int dersize,
gnutls_pk_params_st * params);
-int _gnutls_x509_read_pubkey (gnutls_pk_algorithm_t, opaque * der, int dersize,
+int _gnutls_x509_read_pubkey (gnutls_pk_algorithm_t, uint8_t * der, int dersize,
gnutls_pk_params_st * params);
int _gnutls_x509_write_ecc_params (gnutls_pk_params_st * params,
int _gnutls_x509_read_uint (ASN1_TYPE node, const char *value,
unsigned int *ret);
-int _gnutls_x509_read_der_int (opaque * der, int dersize, bigint_t * out);
+int _gnutls_x509_read_der_int (uint8_t * der, int dersize, bigint_t * out);
int _gnutls_x509_read_int (ASN1_TYPE node, const char *value,
bigint_t * ret_mpi);
#define KEY_ID_OID "1.2.840.113549.1.9.21"
int
-_gnutls_pkcs12_string_to_key (unsigned int id, const opaque * salt,
+_gnutls_pkcs12_string_to_key (unsigned int id, const uint8_t * salt,
unsigned int salt_size, unsigned int iter,
const char *pw, unsigned int req_keylen,
- opaque * keybuf);
+ uint8_t * keybuf);
int _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
const char *password, gnutls_datum_t * dec);
int result;
char oid[MAX_OID_SIZE];
size_t oid_size;
- opaque *extensions;
+ uint8_t *extensions;
size_t extensions_size;
unsigned int critical;
gnutls_datum_t ext;
* and negative error codes indicate that the pathLenConstraints field should
* not be present.
* @policyLanguage: OID describing the language of @policy.
- * @policy: opaque byte array with policy language, can be %NULL
+ * @policy: uint8_t byte array with policy language, can be %NULL
* @sizeof_policy: size of @policy.
*
* This function will set the proxyCertInfo extension.
* This function will set the X.509 certificate's serial number.
* Serial is not always a 32 or 64bit number. Some CAs use large
* serial numbers, thus it may be wise to handle it as something
- * opaque.
+ * uint8_t.
*
* Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a
* negative error value.
*/
#define TOASCII(c) (c < 127 ? asciitable[c] : 0xff)
inline static int
-decode (uint8_t * result, const opaque * data)
+decode (uint8_t * result, const uint8_t * data)
{
uint8_t a1, a2;
int ret = 3;
*/
int
_gnutls_fbase64_encode (const char *msg, const uint8_t * data,
- int data_size, uint8_t ** result)
+ size_t data_size, uint8_t ** result)
{
int ret, tmp;
unsigned int i, j;
char tmpres[4];
uint8_t *ptr;
- uint8_t top[80];
- uint8_t bottom[80];
+ char top[80];
+ char bottom[80];
int pos, bytes, top_len, bottom_len;
if (msg == NULL || strlen(msg) > 50)
gnutls_pem_base64_encode (const char *msg, const gnutls_datum_t * data,
char *result, size_t * result_size)
{
- opaque *ret;
+ uint8_t *ret;
int size;
size = _gnutls_fbase64_encode (msg, data->data, data->size, &ret);
const gnutls_datum_t * data,
gnutls_datum_t * result)
{
- opaque *ret;
+ uint8_t *ret;
int size;
if (result == NULL)
*/
#define ENDSTR "-----"
int
-_gnutls_fbase64_decode (const char *header, const opaque * data,
+_gnutls_fbase64_decode (const char *header, const uint8_t * data,
size_t data_size, uint8_t ** result)
{
int ret;
const gnutls_datum_t * b64_data,
unsigned char *result, size_t * result_size)
{
- opaque *ret;
+ uint8_t *ret;
int size;
size =
const gnutls_datum_t * b64_data,
gnutls_datum_t * result)
{
- opaque *ret;
+ uint8_t *ret;
int size;
if (result == NULL)
*/
int _gnutls_fbase64_encode (const char *msg, const uint8_t * data,
- int data_size, uint8_t ** result);
+ size_t data_size, uint8_t ** result);
int _gnutls_fbase64_decode (const char *header, const uint8_t * data,
size_t data_size, uint8_t ** result);
{
/* Server stuff. */
gnutls_anon_server_credentials_t s_anoncred;
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen(pkcs3) };
+ const gnutls_datum_t p3 = { (void*) pkcs3, strlen(pkcs3) };
static gnutls_dh_params_t dh_params;
gnutls_session_t server;
int sret, cret;
{
/* Server stuff. */
gnutls_anon_server_credentials_t s_anoncred;
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen(pkcs3) };
+ const gnutls_datum_t p3 = { (void*) pkcs3, strlen(pkcs3) };
static gnutls_dh_params_t dh_params;
gnutls_session_t server;
int sret, cret;
gnutls_datum_t *
load_secret_key (int mand, common_info_st * info)
{
- unsigned char raw_key[64];
+ char raw_key[64];
size_t raw_key_size = sizeof (raw_key);
static gnutls_datum_t key;
gnutls_datum_t hex_key;
return NULL;
}
- hex_key.data = (char *) info->secret_key;
+ hex_key.data = (void *) info->secret_key;
hex_key.size = strlen (info->secret_key);
ret = gnutls_hex_decode (&hex_key, raw_key, &raw_key_size);
if (ret < 0)
error (EXIT_FAILURE, 0, "hex_decode: %s", gnutls_strerror (ret));
- key.data = raw_key;
+ key.data = (void*)raw_key;
key.size = raw_key_size;
return &key;
return _load_pkcs11_privkey(info->privkey);
#endif
- dat.data = read_binary_file (info->privkey, &size);
+ dat.data = (void*)read_binary_file (info->privkey, &size);
dat.size = size;
if (!dat.data)
if (ret < 0)
error (EXIT_FAILURE, 0, "privkey_init: %s", gnutls_strerror (ret));
- dat.data = read_binary_file (info->privkey, &size);
+ dat.data = (void*)read_binary_file (info->privkey, &size);
dat.size = size;
if (!dat.data)
fclose (fd);
- ptr = buffer;
+ ptr = (void*)buffer;
ptr_size = size;
for (i = 0; i < MAX_CERTS; i++)
if (ret < 0)
error (EXIT_FAILURE, 0, "crt_init: %s", gnutls_strerror (ret));
- dat.data = ptr;
+ dat.data = (void*)ptr;
dat.size = ptr_size;
ret = gnutls_x509_crt_import (crt[i], &dat, info->incert_format);
if (ret < 0)
error (EXIT_FAILURE, 0, "crq_init: %s", gnutls_strerror (ret));
- dat.data = read_binary_file (info->request, &size);
+ dat.data = (void*)read_binary_file (info->request, &size);
dat.size = size;
if (!dat.data)
return _load_pkcs11_privkey(info->ca_privkey);
#endif
- dat.data = read_binary_file (info->ca_privkey, &size);
+ dat.data = (void*)read_binary_file (info->ca_privkey, &size);
dat.size = size;
if (!dat.data)
if (ret < 0)
error (EXIT_FAILURE, 0, "crt_init: %s", gnutls_strerror (ret));
- dat.data = read_binary_file (info->ca, &size);
+ dat.data = (void*)read_binary_file (info->ca, &size);
dat.size = size;
if (!dat.data)
if (ret < 0)
error (EXIT_FAILURE, 0, "privkey_init: %s", gnutls_strerror (ret));
- dat.data = read_binary_file (info->pubkey, &size);
+ dat.data = (void*)read_binary_file (info->pubkey, &size);
dat.size = size;
if (!dat.data)
gnutls_datum_t pem;
unsigned int crt_num;
- pem.data = fread_file (infile, &size);
+ pem.data = (void*)fread_file (infile, &size);
pem.size = size;
crt_num = MAX_CRTS;
gnutls_datum_t pem, out_data;
unsigned int verify_status;
- pem.data = fread_file (infile, &size);
+ pem.data = (void*)fread_file (infile, &size);
pem.size = size;
ret = gnutls_openpgp_crt_init (&crt);
int ret, i, count;
gnutls_datum_t pem;
- pem.data = fread_file (infile, &size);
+ pem.data = (void*)fread_file (infile, &size);
pem.size = size;
ret = gnutls_openpgp_keyring_init (&ring);
if (ret < 0)
error (EXIT_FAILURE, 0, "crl_init: %s", gnutls_strerror (ret));
- pem.data = fread_file (infile, &size);
+ pem.data = (void*)fread_file (infile, &size);
pem.size = size;
if (!pem.data)
if (ret < 0)
error (EXIT_FAILURE, 0, "crq_init: %s", gnutls_strerror (ret));
- pem.data = fread_file (infile, &size);
+ pem.data = (void*)fread_file (infile, &size);
pem.size = size;
if (!pem.data)
strcpy(name, "unnumbered");
else
{
- data.data = tmp;
+ data.data = (void*)tmp;
data.size = name_size;
name_size = sizeof(name);
char *buf;
size_t size;
- buf = fread_file (infile, &size);
+ buf = (void*)fread_file (infile, &size);
if (buf == NULL)
error (EXIT_FAILURE, errno, "reading chain");
if (ca_file == NULL)
error (EXIT_FAILURE, errno, "opening CA file");
- cert = fread_file (infile, &cert_size);
+ cert = (void*)fread_file (infile, &cert_size);
if (cert == NULL)
error (EXIT_FAILURE, errno, "reading certificate chain");
cert[cert_size] = 0;
- cas = fread_file (ca_file, &ca_size);
+ cas = (void*)fread_file (ca_file, &ca_size);
if (cas == NULL)
error (EXIT_FAILURE, errno, "reading CA list");
if (ret < 0)
error (EXIT_FAILURE, 0, "crl_init: %s", gnutls_strerror (ret));
- pem.data = fread_file (infile, &size);
+ pem.data = (void*)fread_file (infile, &size);
pem.size = size;
ret = gnutls_x509_crl_import (crl, &pem, info.incert_format);
if (result < 0)
error (EXIT_FAILURE, 0, "p12_init: %s", gnutls_strerror (result));
- data.data = fread_file (infile, &size);
+ data.data = (void*)fread_file (infile, &size);
data.size = size;
result = gnutls_pkcs12_import (pkcs12, &data, info.incert_format, 0);
if (result < 0)
error (EXIT_FAILURE, 0, "p7_init: %s", gnutls_strerror (result));
- data.data = fread_file (infile, &size);
+ data.data = (void*)fread_file (infile, &size);
data.size = size;
result = gnutls_pkcs7_import (pkcs7, &data, info.incert_format);
if (result < 0)
error (EXIT_FAILURE, 0, "encoding: %s", gnutls_strerror (result));
- fputs (b64.data, outfile);
+ fputs ((void*)b64.data, outfile);
gnutls_free (b64.data);
}
if (result < 0)
error (EXIT_FAILURE, 0, "encoding: %s", gnutls_strerror (result));
- fputs (b64.data, outfile);
+ fputs ((void*)b64.data, outfile);
gnutls_free (b64.data);
}
}
gnutls_datum_t loaded_file = { NULL, 0 };
size_t length;
- loaded_file.data = read_binary_file (file, &length);
+ loaded_file.data = (void*)read_binary_file (file, &length);
if (loaded_file.data)
loaded_file.size = (unsigned int) length;
load_keys (void)
{
unsigned int crt_num;
- int ret, i;
+ int ret;
+ unsigned int i;
gnutls_datum_t data = { NULL, 0 };
gnutls_x509_crt_t crt_list[MAX_CRT];
#ifdef ENABLE_PKCS11
psk_callback (gnutls_session_t session, char **username, gnutls_datum_t * key)
{
const char *hint = gnutls_psk_client_get_hint (session);
- unsigned char *rawkey;
+ char *rawkey;
char *passwd;
int ret;
size_t res_size;
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
- tmp.data = passwd;
+ tmp.data = (void*)passwd;
tmp.size = strlen (passwd);
res_size = tmp.size / 2 + 1;
return ret;
}
- key->data = rawkey;
+ key->data = (void*)rawkey;
key->size = res_size;
if (info.debug)
gnutls_openpgp_crt_t crt;
const gnutls_datum_t *cert_list;
- int cert_list_size = 0;
+ unsigned int cert_list_size = 0;
int hostname_ok = 0;
int ret;
if (verbose)
{
- char id[32];
+ unsigned char id[32];
size_t id_size = sizeof (id);
gnutls_session_get_id (session, id, &id_size);
printf ("- Session ID: %s\n", raw_to_string (id, id_size));
*/
static gnutls_certificate_server_credentials cred;
static gnutls_dh_params dh_params; /**< GNUTLS DH parameters. */
-static gnutls_datum dh_file = { _crywrap_prime_dh_1024, sizeof(_crywrap_prime_dh_1024) }; /**< Diffie Hellman parameters */
+static gnutls_datum dh_file = { (void*)_crywrap_prime_dh_1024, sizeof(_crywrap_prime_dh_1024) }; /**< Diffie Hellman parameters */
/** Bugreport address.
* Used by the argp suite.
gnutls_datum_t loaded_file = { NULL, 0 };
size_t length;
- loaded_file.data = read_binary_file (file, &length);
+ loaded_file.data = (void*)read_binary_file (file, &length);
if (loaded_file.data)
loaded_file.size = (unsigned int) length;
static void
print_dh_info (gnutls_datum_t * p, gnutls_datum_t * g, unsigned int q_bits)
{
-int i;
+unsigned int i;
fprintf (outfile, "\nGenerator (%d bits): ", g->size*8);
exit (1);
}
- params.data = fread_file (infile, &size);
+ params.data = (void*)fread_file (infile, &size);
params.size = size;
ret =
{
gnutls_pkcs11_obj_t *crt_list;
gnutls_x509_crt_t xcrt;
- unsigned int crt_list_size = 0;
+ unsigned int crt_list_size = 0, i;
int ret;
char *output;
- int i, attrs;
+ int attrs;
unsigned int obj_flags = 0;
if (login)
static int
static_dh_params (void)
{
- gnutls_datum_t params = { pkcs3, sizeof (pkcs3) };
+ gnutls_datum_t params = { (void*)pkcs3, sizeof (pkcs3) };
int ret;
if (gnutls_dh_params_init (&dh_params) < 0)
*pos = 0;
/* convert salt to binary. */
- tmp.data = _salt;
+ tmp.data = (void*)_salt;
tmp.size = strlen (_salt);
if (gnutls_srp_base64_decode_alloc (&tmp, &raw_salt) < 0)
_srp_crypt (const char *username, const char *passwd, int salt_size,
const gnutls_datum_t * g, const gnutls_datum_t * n)
{
- char salt[128];
+ unsigned char salt[128];
static char result[1024];
gnutls_datum_t dat_salt, txt_salt;
gnutls_datum_t verifier, txt_verifier;
if (p[len - 1] == '\n')
len--;
- dat.data = p;
+ dat.data = (void*)p;
dat.size = len;
ret = gnutls_srp_base64_decode_alloc (&dat, g);
*p = '\0';
p++;
- dat.data = p;
+ dat.data = (void*)p;
dat.size = strlen (p);
ret = gnutls_srp_base64_decode_alloc (&dat, n);
static int
generate_dh_params (void)
{
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
/* Generate Diffie-Hellman parameters - for use with DHE
* kx algorithms. These should be discarded and regenerated
* once a day, once a week or once a month. Depending on the
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
-int client_len;
+socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
#include <stdio.h>
#include <stdlib.h>
+#include <stdint.h>
#include <string.h>
#include <gnutls/gnutls.h>
#include <gnutls/x509.h>
{
int rc;
gnutls_certificate_credentials_t crt;
- gnutls_datum_t crldatum = { crl, strlen (crl) };
+ gnutls_datum_t crldatum = { (uint8_t*)crl, strlen (crl) };
gnutls_x509_crl_t crl;
rc = gnutls_global_init ();
const char *name;
const char **chain;
const char **ca;
- int verify_flags;
- int expected_verify_result;
+ unsigned int verify_flags;
+ unsigned int expected_verify_result;
} chains[] =
{
{ "CVE-2008-4989", cve_2008_4989_chain, &cve_2008_4989_chain[2],
error (EXIT_FAILURE, 0, "gnutls_x509_crt_init[%d,%d]: %s",
(int) i, (int) j, gnutls_strerror (ret));
- tmp.data = (char *) chains[i].chain[j];
+ tmp.data = (unsigned char *) chains[i].chain[j];
tmp.size = strlen (chains[i].chain[j]);
ret = gnutls_x509_crt_import (certs[j], &tmp, GNUTLS_X509_FMT_PEM);
error (EXIT_FAILURE, 0, "gnutls_x509_crt_init: %s",
gnutls_strerror (ret));
- tmp.data = (char *) *chains[i].ca;
+ tmp.data = (unsigned char *) *chains[i].ca;
tmp.size = strlen (*chains[i].ca);
ret = gnutls_x509_crt_import (ca, &tmp, GNUTLS_X509_FMT_PEM);
error (EXIT_FAILURE, 0, "gnutls_x509_crt_init[%d]: %s", (int) i,
gnutls_strerror (ret));
- tmp.data = (char *) pem_certs[i];
+ tmp.data = (unsigned char *) pem_certs[i];
tmp.size = strlen (pem_certs[i]);
ret = gnutls_x509_crt_import (certs[i], &tmp, GNUTLS_X509_FMT_PEM);
error (EXIT_FAILURE, 0, "gnutls_x509_crt_init: %s",
gnutls_strerror (ret));
- tmp.data = (char *) pem_ca;
+ tmp.data = (unsigned char *) pem_ca;
tmp.size = strlen (pem_ca);
ret = gnutls_x509_crt_import (ca, &tmp, GNUTLS_X509_FMT_PEM);
error (EXIT_FAILURE, 0, "gnutls_x509_crt_init: %s",
gnutls_strerror (ret));
- tmp.data = (char *) pem_self_cert;
+ tmp.data = (unsigned char *) pem_self_cert;
tmp.size = strlen (pem_self_cert);
ret = gnutls_x509_crt_import (self_cert, &tmp, GNUTLS_X509_FMT_PEM);
"QcDzQ8REwidsfh9uKAluk1c/KQ==\n" "-----END CERTIFICATE-----\n";
const gnutls_datum_t dsa_cert_dat = {
- dsa_cert, sizeof (dsa_cert)
+ (void*)dsa_cert, sizeof (dsa_cert)
};
int
{
gnutls_x509_crt_t crt;
gnutls_pubkey_t pubkey;
- gnutls_datum_t data = { (char *) "foo", 3 };
- gnutls_datum_t sig = { (char *) "bar", 3 };
+ gnutls_datum_t data = { (void *) "foo", 3 };
+ gnutls_datum_t sig = { (void *) "bar", 3 };
int ret;
gnutls_global_init ();
gnutls_session_t session;
char buffer[MAX_BUF + 1];
gnutls_psk_client_credentials_t pskcred;
- const gnutls_datum_t key = { (char *) "DEADBEEF", 8 };
+ const gnutls_datum_t key = { (void *) "DEADBEEF", 8 };
gnutls_global_init ();
static int
generate_dh_params (void)
{
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
/* Generate Diffie-Hellman parameters - for use with DHE
* kx algorithms. These should be discarded and regenerated
* once a day, once a week or once a month. Depending on the
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
-int client_len;
+socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
doit (void)
{
int ret;
- gnutls_datum_t derCert = { pem, sizeof (pem) };
+ gnutls_datum_t derCert = { (unsigned char*)pem, sizeof (pem) };
gnutls_x509_crt_t cert;
gnutls_x509_dn_t xdn;
void
doit (void)
{
- gnutls_datum_t der = { pem, sizeof (pem) };
+ gnutls_datum_t der = { (void*)pem, sizeof (pem) };
gnutls_x509_crt_t cert;
gnutls_datum_t out;
int ret;
if (ret < 0)
fail ("x509_crt_print %d\n", ret);
- if (out.size != strlen (info) || strcmp (out.data, info) != 0)
+ if (out.size != strlen (info) ||
+ strcmp ((char*)out.data, info) != 0)
fail ("comparison fail (%d/%d)\nexpect: %s\n got: %.*s\n",
out.size, (int) strlen (info), info, out.size, out.data);
void
doit (void)
{
- char digest[20];
+ unsigned char digest[20];
int err;
/* XXX: We need this to fix secure memory. */
}
}
- err = _gnutls_pbkdf2_sha1 ("password", 8, "salt", 4, 4711, digest, 16);
+ err = _gnutls_pbkdf2_sha1 ("password", 8, (unsigned char*)"salt", 4, 4711, digest, 16);
if (err < 0)
fail ("_gnutls_pkcs5_pbkdf2_sha1() failed: %d\n", err);
else
if (debug)
success ("Testing pem1...\n");
- data.data = pem1;
+ data.data = (unsigned char*)pem1;
data.size = strlen (pem1);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem2...\n");
- data.data = pem2;
+ data.data = (unsigned char*)pem2;
data.size = strlen (pem2);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem3...\n");
- data.data = pem3;
+ data.data = (unsigned char*)pem3;
data.size = strlen (pem3);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem4...\n");
- data.data = pem4;
+ data.data = (unsigned char*)pem4;
data.size = strlen (pem4);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem6...\n");
- data.data = pem6;
+ data.data = (unsigned char*)pem6;
data.size = strlen (pem6);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem7...\n");
- data.data = pem7;
+ data.data = (unsigned char*)pem7;
data.size = strlen (pem7);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem8...\n");
- data.data = pem8;
+ data.data = (unsigned char*)pem8;
data.size = strlen (pem8);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem9...\n");
- data.data = pem9;
+ data.data = (unsigned char*)pem9;
data.size = strlen (pem9);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem10...\n");
- data.data = pem10;
+ data.data = (unsigned char*)pem10;
data.size = strlen (pem10);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
if (debug)
success ("Testing pem_too_many...\n");
- data.data = pem_too_many;
+ data.data = (unsigned char*)pem_too_many;
data.size = strlen (pem_too_many);
ret = gnutls_x509_crt_import (x509, &data, GNUTLS_X509_FMT_PEM);
#ifdef ENABLE_OPENPGP
if (debug)
success ("Testing pem11...\n");
- data.data = pem11;
+ data.data = (unsigned char*)pem11;
data.size = strlen (pem11);
ret = gnutls_openpgp_crt_import (pgp, &data, GNUTLS_OPENPGP_FMT_BASE64);
"-----END CERTIFICATE-----\n";
const gnutls_datum_t cert_with_aia = {
- cert_with_aia_data, sizeof (cert_with_aia_data)
+ (void*)cert_with_aia_data, sizeof (cert_with_aia_data)
};
void
gnutls_x509_crt_t crt;
int ret;
gnutls_datum_t data;
- int critical;
+ unsigned int critical;
ret = gnutls_global_init ();
if (ret < 0)
{
/* Server stuff. */
gnutls_anon_server_credentials_t s_anoncred;
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (unsigned char*) pkcs3, strlen (pkcs3) };
static gnutls_dh_params_t dh_params;
gnutls_session_t server;
int sret = GNUTLS_E_AGAIN;
{
/* Server stuff. */
gnutls_anon_server_credentials_t s_anoncred;
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
static gnutls_dh_params_t dh_params;
gnutls_session_t server;
int sret, cret;
{
/* Server stuff. */
gnutls_anon_server_credentials_t s_anoncred;
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (unsigned char *) pkcs3, strlen (pkcs3) };
static gnutls_dh_params_t dh_params;
gnutls_session_t server;
int sret, cret;
{
/* Server stuff. */
gnutls_anon_server_credentials_t s_anoncred;
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (unsigned char *) pkcs3, strlen (pkcs3) };
static gnutls_dh_params_t dh_params;
gnutls_session_t server;
int sret = GNUTLS_E_AGAIN;
"jpfc/3X7sLUsMvumcDE01ls/cG5mIatmiyEU9qI3jbgUf82z23ON/acwJf875D3/\n"
"U7jyOsBJ44SEQITbin2yUeJMIm1tievvdNXBDfW95AM507ShzP12sfiJkJfjjdhy\n"
"dc8Siq5JojruiMizAf0pA7in\n" "-----END CERTIFICATE-----\n";
-static const gnutls_datum_t cert_datum = { (char *) cert_pem,
+static const gnutls_datum_t cert_datum = { (unsigned char *) cert_pem,
sizeof (cert_pem)
};
"CQ==\n" "-----END CERTIFICATE-----\n";
const gnutls_datum_t badguy_nul_cn = {
- badguy_nul_cn_data, sizeof (badguy_nul_cn_data)
+ (void*)badguy_nul_cn_data, sizeof (badguy_nul_cn_data)
};
static char badguy_nul_san_data[] =
"-----END CERTIFICATE-----\n";
const gnutls_datum_t badguy_nul_san = {
- badguy_nul_san_data, sizeof (badguy_nul_san_data)
+ (void*)badguy_nul_san_data, sizeof (badguy_nul_san_data)
};
void
ssize_t received;
pid_t done;
int status;
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
if (debug)
printf ("server process %i (child %i)\n", getpid (), child);
ssize_t received;
pid_t done;
int status;
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void*) pkcs3, strlen (pkcs3) };
if (debug)
printf ("server process %i (child %i)\n", getpid (), child);
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
+#include <sys/socket.h>
#if !defined(_WIN32)
#include <netinet/in.h>
-#include <sys/socket.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#endif
static int
generate_dh_params (void)
{
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
/* Generate Diffie-Hellman parameters - for use with DHE
* kx algorithms. These should be discarded and regenerated
* once a day, once a week or once a month. Depending on the
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
-int client_len;
+socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
{
int rc;
gnutls_certificate_credentials_t cred;
- gnutls_datum_t ca = { castr, sizeof (castr) };
+ gnutls_datum_t ca = { (unsigned char*)castr, sizeof (castr) };
gnutls_global_init ();
"jpfc/3X7sLUsMvumcDE01ls/cG5mIatmiyEU9qI3jbgUf82z23ON/acwJf875D3/\n"
"U7jyOsBJ44SEQITbin2yUeJMIm1tievvdNXBDfW95AM507ShzP12sfiJkJfjjdhy\n"
"dc8Siq5JojruiMizAf0pA7in\n" "-----END CERTIFICATE-----\n";
-const gnutls_datum_t client_dat = { client_pem, sizeof (client_pem) };
+const gnutls_datum_t client_dat = { (void*)client_pem, sizeof (client_pem) };
static char ca_pem[] =
"-----BEGIN CERTIFICATE-----\n"
"njuu7kHq5peUgYn8Jd9zNzExBOEp1VOipGsf6G66oQAhDFp2o8zkz7ZH71zR4HEW\n"
"KoX6n5Emn6DvcEH/9pAhnGxNHJAoS7czTKv/JDZJhkqHxyrE1fuLsg5Qv25DTw7+\n"
"PfqUpIhz5Bbm7J4=\n" "-----END CERTIFICATE-----\n";
-const gnutls_datum_t ca_dat = { ca_pem, sizeof (ca_pem) };
+const gnutls_datum_t ca_dat = { (void*)ca_pem, sizeof (ca_pem) };
static void
tls_log_func (int level, const char *str)
gnutls_x509_crt_t client;
gnutls_x509_crt_t ca;
gnutls_pkcs12_bag_t bag;
- char key_id_buf[20];
+ unsigned char key_id_buf[20];
gnutls_datum_t key_id;
int ret, indx;
char outbuf[10240];
fprintf (stderr, "|<%d>| %s", level, str);
}
-static const char *salt[3] = { "salt1", "ltsa22", "balt33" };
+static const unsigned char *salt[3] = { (void*)"salt1", (void*)"ltsa22", (void*)"balt33" };
static const char *pw[3] = { "secret1", "verysecret2", "veryverysecret3" };
static const char *values[] = {
{
int id;
const char *password;
- const char *salt;
+ const unsigned char *salt;
size_t iter;
size_t keylen;
const char *key;
} tv[] =
{
{
- 1, "smeg", "\x0A\x58\xCF\x64\x53\x0D\x82\x3F", 1, 24,
+ 1, "smeg", (void*)"\x0A\x58\xCF\x64\x53\x0D\x82\x3F", 1, 24,
"8aaae6297b6cb04642ab5b077851284eb7128f1a2a7fbca3"},
{
- 2, "smeg", "\x0A\x58\xCF\x64\x53\x0D\x82\x3F", 1, 8, "79993dfe048d3b76"},
+ 2, "smeg", (void*)"\x0A\x58\xCF\x64\x53\x0D\x82\x3F", 1, 8, "79993dfe048d3b76"},
{
- 1, "smeg", "\x64\x2B\x99\xAB\x44\xFB\x4B\x1F", 1, 24,
+ 1, "smeg", (void*)"\x64\x2B\x99\xAB\x44\xFB\x4B\x1F", 1, 24,
"f3a95fec48d7711e985cfe67908c5ab79fa3d7c5caa5d966"},
{
- 2, "smeg", "\x64\x2B\x99\xAB\x44\xFB\x4B\x1F", 1, 8, "c0a38d64a79bea1d"},
+ 2, "smeg", (void*)"\x64\x2B\x99\xAB\x44\xFB\x4B\x1F", 1, 8, "c0a38d64a79bea1d"},
{
- 3, "smeg", "\x3D\x83\xC0\xE4\x54\x6A\xC1\x40", 1, 20,
+ 3, "smeg", (void*)"\x3D\x83\xC0\xE4\x54\x6A\xC1\x40", 1, 20,
"8d967d88f6caa9d714800ab3d48051d63f73a312"},
{
- 1, "queeg", "\x05\xDE\xC9\x59\xAC\xFF\x72\xF7", 1000, 24,
+ 1, "queeg", (void*)"\x05\xDE\xC9\x59\xAC\xFF\x72\xF7", 1000, 24,
"ed2034e36328830ff09df1e1a07dd357185dac0d4f9eb3d4"},
{
- 2, "queeg", "\x05\xDE\xC9\x59\xAC\xFF\x72\xF7", 1000, 8,
+ 2, "queeg", (void*)"\x05\xDE\xC9\x59\xAC\xFF\x72\xF7", 1000, 8,
"11dedad7758d4860"},
{
- 1, "queeg", "\x16\x82\xC0\xFC\x5B\x3F\x7E\xC5", 1000, 24,
+ 1, "queeg", (void*)"\x16\x82\xC0\xFC\x5B\x3F\x7E\xC5", 1000, 24,
"483dd6e919d7de2e8e648ba8f862f3fbfbdc2bcb2c02957f"},
{
- 2, "queeg", "\x16\x82\xC0\xFC\x5B\x3F\x7E\xC5", 1000, 8,
+ 2, "queeg", (void*)"\x16\x82\xC0\xFC\x5B\x3F\x7E\xC5", 1000, 8,
"9d461d1b00355c50"},
{
- 3, "queeg", "\x26\x32\x16\xFC\xC2\xFA\xB3\x1C", 1000, 20,
+ 3, "queeg", (void*)"\x26\x32\x16\xFC\xC2\xFA\xB3\x1C", 1000, 20,
"5ec4c7a80df652294c3925b6489a7ab857c83476"}
};
void
doit (void)
{
- int rc, i, j, x;
- char key[32];
+ int rc;
+ unsigned int i, j, x;
+ unsigned char key[32];
char tmp[1024];
gnutls_global_init ();
for (j = 0; j < 3; j++)
{
rc =
- _gnutls_pkcs12_string_to_key (i, salt[j], strlen (salt[j]),
+ _gnutls_pkcs12_string_to_key (i, salt[j], strlen ((char*)salt[j]),
j + i + 15, pw[j], sizeof (key),
key);
if (rc < 0)
if (ret < 0)
return 1;
- tmp.data = (char *) keys[i].pkcs12key;
- tmp.size = strlen (tmp.data);
+ tmp.data = (unsigned char *) keys[i].pkcs12key;
+ tmp.size = strlen ((char*)tmp.data);
ret = gnutls_x509_privkey_import_pkcs8 (key, &tmp,
GNUTLS_X509_FMT_PEM,
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
-#if !defined(_WIN32)
#include <sys/socket.h>
+#if !defined(_WIN32)
#include <sys/wait.h>
#include <netinet/in.h>
#include <arpa/inet.h>
char buffer[MAX_BUF + 1];
gnutls_psk_client_credentials_t pskcred;
/* Need to enable anonymous KX specifically. */
- const gnutls_datum_t key = { (char *) "DEADBEEF", 8 };
+ const gnutls_datum_t key = { (void *) "DEADBEEF", 8 };
gnutls_global_init ();
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
-int client_len;
+socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
-#if !defined(_WIN32)
#include <sys/socket.h>
+#if !defined(_WIN32)
#include <sys/wait.h>
#include <netinet/in.h>
#include <arpa/inet.h>
static int
generate_dh_params (void)
{
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
/* Generate Diffie-Hellman parameters - for use with DHE
* kx algorithms. These should be discarded and regenerated
* once a day, once a week or once a month. Depending on the
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
-int client_len;
+socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
"-----END RSA PRIVATE KEY-----\n";
const gnutls_datum_t cert_dat[] = {
- {pem1_cert, sizeof (pem1_cert)}
+ {(void*)pem1_cert, sizeof (pem1_cert)}
};
const gnutls_datum_t key_dat[] = {
- {pem1_key, sizeof (pem1_key)}
+ {(void*)pem1_key, sizeof (pem1_key)}
};
void
{
const uint8_t *key;
const uint8_t *auth;
- int auth_size;
+ unsigned int auth_size;
const uint8_t *plaintext;
- int plaintext_size;
+ unsigned int plaintext_size;
const uint8_t *iv;
const uint8_t *ciphertext;
const uint8_t *tag;
struct aes_gcm_vectors_st aes_gcm_vectors[] = {
{
- .key =
+ .key = (void*)
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
.auth = NULL,
.auth_size = 0,
.plaintext = NULL,
.plaintext_size = 0,
.ciphertext = NULL,
- .iv = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
- .tag =
+ .iv = (void*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+ .tag = (void*)
"\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4\xe7\x45\x5a"},
{
- .key =
+ .key = (void*)
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
.auth = NULL,
.auth_size = 0,
- .plaintext =
+ .plaintext = (void*)
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
.plaintext_size = 16,
- .ciphertext =
+ .ciphertext = (void*)
"\x03\x88\xda\xce\x60\xb6\xa3\x92\xf3\x28\xc2\xb9\x71\xb2\xfe\x78",
- .iv = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
- .tag =
+ .iv = (void*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+ .tag = (void*)
"\xab\x6e\x47\xd4\x2c\xec\x13\xbd\xf5\x3a\x67\xb2\x12\x57\xbd\xdf"},
{
- .key =
+ .key = (void*)
"\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
- .auth =
+ .auth = (void*)
"\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef\xab\xad\xda\xd2",
.auth_size = 20,
- .plaintext =
+ .plaintext = (void*)
"\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
.plaintext_size = 60,
- .ciphertext =
+ .ciphertext = (void*)
"\x42\x83\x1e\xc2\x21\x77\x74\x24\x4b\x72\x21\xb7\x84\xd0\xd4\x9c\xe3\xaa\x21\x2f\x2c\x02\xa4\xe0\x35\xc1\x7e\x23\x29\xac\xa1\x2e\x21\xd5\x14\xb2\x54\x66\x93\x1c\x7d\x8f\x6a\x5a\xac\x84\xaa\x05\x1b\xa3\x0b\x39\x6a\x0a\xac\x97\x3d\x58\xe0\x91",
- .iv = "\xca\xfe\xba\xbe\xfa\xce\xdb\xad\xde\xca\xf8\x88",
- .tag =
+ .iv = (void*)"\xca\xfe\xba\xbe\xfa\xce\xdb\xad\xde\xca\xf8\x88",
+ .tag = (void*)
"\x5b\xc9\x4f\xbc\x32\x21\xa5\xdb\x94\xfa\xe9\x5a\xe7\x12\x1a\x47"}
};
test_aes (void)
{
gnutls_cipher_hd_t hd;
- int ret, i, j;
+ int ret;
+ unsigned int i, j;
uint8_t _iv[16];
uint8_t tmp[128];
gnutls_datum_t key, iv;
const char *name;
int algorithm;
const uint8_t *key; /* if hmac */
- int key_size;
+ unsigned int key_size;
const uint8_t *plaintext;
- int plaintext_size;
+ unsigned int plaintext_size;
const uint8_t *output;
- int output_size;
+ unsigned int output_size;
} hash_vectors[] =
{
{
test_hash (void)
{
uint8_t data[HASH_DATA_SIZE];
- int i, j, ret;
+ unsigned int i, j;
+ int ret;
size_t data_size;
fprintf (stdout, "Tests on Hashes\n");
}
void
-hexprint (const char *str, size_t len)
+hexprint (const void *_str, size_t len)
{
size_t i;
+ const char* str = _str;
printf ("\t;; ");
for (i = 0; i < len; i++)
}
void
-binprint (const char *str, size_t len)
+binprint (const void *_str, size_t len)
{
size_t i;
+ const char* str = _str;
printf ("\t;; ");
for (i = 0; i < len; i++)
__attribute__ ((format (printf, 1, 2)));
extern void escapeprint (const char *str, size_t len);
-extern void hexprint (const char *str, size_t len);
-extern void binprint (const char *str, size_t len);
+extern void hexprint (const void *str, size_t len);
+extern void binprint (const void *str, size_t len);
/* This must be implemented elsewhere. */
extern void doit (void);
doit (void)
{
int ret;
- gnutls_datum_t derCert = { pem, sizeof (pem) };
+ gnutls_datum_t derCert = { (void*)pem, sizeof (pem) };
gnutls_x509_crt_t cert;
size_t data_len = MAX_DATA_SIZE;
char data[MAX_DATA_SIZE];
doit (void)
{
gnutls_certificate_credentials_t x509_cred;
- int ret, i;
+ int ret;
+ unsigned int i;
gnutls_x509_crt_t issuer;
gnutls_x509_crt_t list[LIST_SIZE];
char dn[128];
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
-#if !defined(_WIN32)
-#include <netinet/in.h>
#include <sys/socket.h>
-#include <sys/wait.h>
-#include <arpa/inet.h>
+#if !defined(_WIN32)
+# include <netinet/in.h>
+# include <sys/wait.h>
+# include <arpa/inet.h>
#endif
#include <unistd.h>
#include <gnutls/gnutls.h>
success ("client: got RDN 0.\n");
if (val.value.size == strlen (EXPECT_RDN0)
- && strncmp (val.value.data, EXPECT_RDN0, val.value.size) == 0)
+ && strncmp ((char*)val.value.data, EXPECT_RDN0, val.value.size) == 0)
{
if (debug)
success ("client: RND 0 correct.\n");
static int
generate_dh_params (void)
{
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
/* Generate Diffie-Hellman parameters - for use with DHE
* kx algorithms. These should be discarded and regenerated
* once a day, once a week or once a month. Depending on the
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
-int client_len;
+socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
+# include <sys/socket.h>
#if !defined(_WIN32)
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/wait.h>
-#include <arpa/inet.h>
+# include <netinet/in.h>
+# include <sys/wait.h>
+# include <arpa/inet.h>
#endif
#include <unistd.h>
#include <gnutls/gnutls.h>
static int
generate_dh_params (void)
{
- const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
+ const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
/* Generate Diffie-Hellman parameters - for use with DHE
* kx algorithms. These should be discarded and regenerated
* once a day, once a week or once a month. Depending on the
int sd, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in sa_cli;
-int client_len;
+socklen_t client_len;
char topbuf[512];
gnutls_session_t session;
char buffer[MAX_BUF + 1];
"AoNBXjeBjgCGMei2m8E=\n" "-----END DSA PRIVATE KEY-----\n";
const gnutls_datum_t cert_dat[] = {
- {pem1_cert, sizeof (pem1_cert)}
+ {(void*)pem1_cert, sizeof (pem1_cert)}
,
- {pem2_cert, sizeof (pem2_cert)}
+ {(void*)pem2_cert, sizeof (pem2_cert)}
};
const gnutls_datum_t key_dat[] = {
- {pem1_key, sizeof (pem1_key)}
+ {(void*)pem1_key, sizeof (pem1_key)}
,
- {pem2_key, sizeof (pem2_key)}
+ {(void*)pem2_key, sizeof (pem2_key)}
};
void
projects / thirdparty / gnutls.git / commitdiff
