gnutls_srp_verifier()
gnutls_srp_base64_encode()
gnutls_srp_base64_decode()
+- Added the function gnutls_srp_server_set_credentials_function()
+ to allow retrieving SRP parameters from an external backend - other
+ than password files.
- Added the function gnutls_openpgp_set_recv_key_function()
which can be used to set a callback, to get OpenPGP keys.
unsigned char *buf = cdk_calloc( 1, 20001 );
size_t len = 20000;
cdk_kbnode_write_to_mem( knode, buf, &len);
- datum_append( key, buf, len );
+
+ key->data = malloc( len);
+ if (key->data==NULL) return -1;
+ memcpy( key->data, buf, len);
+
cdk_free( buf );
}
cdk_kbnode_release( knode );
const gnutls_datum* g, const gnutls_datum* n,
gnutls_datum * res);
+typedef int gnutls_srp_server_credentials_function(
+ gnutls_session,
+ char* username, gnutls_datum* salt,
+ gnutls_datum* verifier, gnutls_datum* generator,
+ gnutls_datum* prime
+);
+
+void gnutls_srp_server_set_credentials_function(
+ gnutls_srp_server_credentials,
+ gnutls_srp_server_credentials_function *);
/* Openpgp certificate stuff */
int gnutls_openpgp_fingerprint( const gnutls_datum* data, char* result, size_t* result_size);
int _gnutls_dh_generate_prime(MPI *ret_g, MPI* ret_n, int bits);
void _gnutls_dh_clear_mpis(void);
int _gnutls_dh_calc_mpis(void);
-MPI _gnutls_get_rnd_srp_params( MPI * ret_p, int bits);
+int _gnutls_get_rnd_srp_params(gnutls_datum *g, gnutls_datum* p, int bits);
extern _gnutls_dh_params _gnutls_dh_default_params;
/* returns g and p, depends on the requested bits.
* We only support limited key sizes.
*/
-GNUTLS_MPI _gnutls_get_rnd_srp_params(GNUTLS_MPI * ret_p, int bits)
+int _gnutls_get_rnd_srp_params(gnutls_datum *g, gnutls_datum* p, int bits)
{
- GNUTLS_MPI g = NULL, prime = NULL;
int i;
if (_gnutls_dh_default_params == NULL) {
gnutls_assert();
- return NULL;
+ return GNUTLS_E_INTERNAL_ERROR;
}
+ g->data = p->data = NULL;
+ g->size = p->size = 0;
+
bits = normalize_bits(bits);
i = 0;
do {
if (_gnutls_dh_default_params[i].bits == bits) {
- prime =
- _gnutls_mpi_copy(_gnutls_dh_default_params[i].
- _prime);
- g = _gnutls_mpi_copy(_gnutls_dh_default_params[i].
- _generator);
+ gnutls_set_datum( p, _gnutls_dh_default_params[i].prime.data,
+ _gnutls_dh_default_params[i].prime.size);
+
+ gnutls_set_datum( g, _gnutls_dh_default_params[i].generator.data,
+ _gnutls_dh_default_params[i].generator.size);
+
break;
}
i++;
} while (_gnutls_dh_default_params[i].bits != 0);
- if (prime == NULL || g == NULL) { /* if not prime was found */
+ if (g->data == NULL || p->data == NULL) {
gnutls_assert();
- _gnutls_mpi_release(&g);
- _gnutls_mpi_release(&prime);
- *ret_p = NULL;
- return NULL;
+ gnutls_free_datum(&g);
+ gnutls_free_datum(&p);
+ return GNUTLS_E_INTERNAL_ERROR;
}
- if (ret_p)
- *ret_p = prime;
- return g;
+ return 0;
}
/* These should be added in gcrypt.h */
#include "gnutls_num.h"
#include "auth_srp.h"
#include <gnutls_str.h>
+#include <gnutls_datum.h>
int _gnutls_gen_srp_server_kx2(gnutls_session, opaque **);
int _gnutls_gen_srp_client_kx0(gnutls_session, opaque **);
*/
int _gnutls_gen_srp_server_hello(gnutls_session state, opaque * data, size_t _data_size)
{
- size_t n_g, n_n, n_s;
int ret;
uint8 *data_n, *data_s;
uint8 *data_g, *username;
- GNUTLS_SRP_PWD_ENTRY *pwd_entry;
+ SRP_PWD_ENTRY *pwd_entry;
int err;
SRP_SERVER_AUTH_INFO info;
ssize_t data_size = _data_size;
pwd_entry = _gnutls_srp_pwd_read_entry( state, username, &err);
if (pwd_entry == NULL) {
- if (err==0)
+ if (err==0) {
+ gnutls_assert();
/* in order to avoid informing the peer that
* username does not exist.
*/
pwd_entry = _gnutls_randomize_pwd_entry();
- else
+ } else {
return GNUTLS_E_PWD_ERROR;
+ }
}
- if (_gnutls_mpi_print( NULL, &n_g, pwd_entry->g)!=0) {
+ /* copy from pwd_entry to local variables (actually in state) */
+ if (_gnutls_mpi_scan( &G, pwd_entry->g.data, &pwd_entry->g.size) < 0) {
gnutls_assert();
- return GNUTLS_E_MPI_PRINT_FAILED;
+ return GNUTLS_E_MPI_SCAN_FAILED;
}
- if (_gnutls_mpi_print( NULL, &n_n, pwd_entry->n)!=0) {
+
+ if (_gnutls_mpi_scan( &N, pwd_entry->n.data, &pwd_entry->n.size) < 0) {
gnutls_assert();
- return GNUTLS_E_MPI_PRINT_FAILED;
+ return GNUTLS_E_MPI_SCAN_FAILED;
}
-
- /* copy from pwd_entry to local variables (actually in state) */
- G = _gnutls_mpi_alloc_like(pwd_entry->g);
- N = _gnutls_mpi_alloc_like(pwd_entry->n);
- V = _gnutls_mpi_alloc_like(pwd_entry->v);
- if (G==NULL || N == NULL || V == NULL) {
+ if (_gnutls_mpi_scan( &V, pwd_entry->v.data, &pwd_entry->v.size) < 0) {
gnutls_assert();
- return GNUTLS_E_MEMORY_ERROR;
+ return GNUTLS_E_MPI_SCAN_FAILED;
}
- _gnutls_mpi_set(G, pwd_entry->g);
- _gnutls_mpi_set(N, pwd_entry->n);
- _gnutls_mpi_set(V, pwd_entry->v);
-
- if ((size_t)data_size < n_n + n_g + pwd_entry->salt_size + 5) {
+ if ((size_t)data_size < pwd_entry->n.size +
+ pwd_entry->g.size + pwd_entry->salt.size + 5) {
gnutls_assert();
return GNUTLS_E_INVALID_REQUEST;
}
*/
data_s = data;
- n_s = pwd_entry->salt_size;
- memcpy(&data_s[1], pwd_entry->salt, n_s);
-
- data_s[0] = (uint8) n_s;
+ _gnutls_write_datum8( data_s, pwd_entry->salt);
/* copy N (mod n) */
- data_n = &data_s[1 + n_s];
-
- if (_gnutls_mpi_print( &data_n[2], &n_n, N)!=0) {
- gnutls_assert();
- return GNUTLS_E_MPI_PRINT_FAILED;
- }
-
- _gnutls_write_uint16( n_n, data_n);
+ data_n = &data_s[1 + pwd_entry->salt.size];
+ _gnutls_write_datum16( data_n, pwd_entry->n);
- data_g = &data_n[2 + n_n];
+ data_g = &data_n[2 + pwd_entry->n.size];
/* copy G (generator) to data */
+ _gnutls_write_datum16( data_g, pwd_entry->g);
- if(_gnutls_mpi_print( &data_g[2], &n_g, G)!=0) {
- gnutls_assert();
- return GNUTLS_E_MPI_PRINT_FAILED;
- }
-
- _gnutls_write_uint16( n_g, data_g);
- ret = n_g + n_n + pwd_entry->salt_size + 5;
+ ret = pwd_entry->g.size + pwd_entry->n.size +
+ pwd_entry->salt.size + 5;
_gnutls_srp_clear_pwd_entry( pwd_entry);
return ret;
return GNUTLS_E_MEMORY_ERROR;
}
- if (_gnutls_mpi_print( NULL, &n_b, B)!=0)
+ if (_gnutls_mpi_print( NULL, &n_b, B)!=0) {
+ gnutls_assert();
return GNUTLS_E_MPI_PRINT_FAILED;
+ }
(*data) = gnutls_malloc(n_b + 2);
if ( (*data) == NULL) {
ret = _gnutls_generate_key( state->key);
_gnutls_mpi_release( &S);
- if (ret < 0)
+ if (ret < 0) {
+ gnutls_assert();
return ret;
+ }
return n_b + 2;
}
#include <gnutls_auth.h>
+
+typedef int gnutls_srp_server_credentials_function(gnutls_session,
+ char *username,
+ gnutls_datum * salt,
+ gnutls_datum * verifier,
+ gnutls_datum *
+ generator,
+ gnutls_datum * prime);
+
+
typedef struct {
- char* username;
- char* password;
+ char *username;
+ char *password;
} SRP_CLIENT_CREDENTIALS_INT;
#define gnutls_srp_client_credentials SRP_CLIENT_CREDENTIALS_INT*
typedef struct {
- char** password_file;
- char** password_conf_file;
- int password_files;
+ char **password_file;
+ char **password_conf_file;
+ int password_files;
+ /* callback function, instead of reading the
+ * password files.
+ */
+ gnutls_srp_server_credentials_function *pwd_callback;
} SRP_SERVER_CREDENTIALS_INT;
#define gnutls_srp_server_credentials SRP_SERVER_CREDENTIALS_INT*
/* these structures should not use allocated data */
typedef struct SRP_SERVER_AUTH_INFO_INT {
- char username[MAX_SRP_USERNAME];
+ char username[MAX_SRP_USERNAME];
} *SRP_SERVER_AUTH_INFO;
#ifdef ENABLE_SRP
-int _gnutls_proc_srp_server_hello(gnutls_session state, const opaque * data, size_t data_size);
-int _gnutls_gen_srp_server_hello(gnutls_session state, opaque * data, size_t data_size);
+int _gnutls_proc_srp_server_hello(gnutls_session state,
+ const opaque * data, size_t data_size);
+int _gnutls_gen_srp_server_hello(gnutls_session state, opaque * data,
+ size_t data_size);
int _gnutls_gen_srp_server_kx2(gnutls_session, opaque **);
int _gnutls_gen_srp_client_kx0(gnutls_session, opaque **);
int _gnutls_proc_srp_server_kx2(gnutls_session, opaque *, size_t);
int _gnutls_proc_srp_client_kx0(gnutls_session, opaque *, size_t);
-typedef struct SRP_SERVER_AUTH_INFO_INT SRP_SERVER_AUTH_INFO_INT;
+typedef struct SRP_SERVER_AUTH_INFO_INT SRP_SERVER_AUTH_INFO_INT;
-#endif /* ENABLE_SRP */
+#endif /* ENABLE_SRP */
#endif
#include "gnutls_dh.h"
#include "debug.h"
#include <gnutls_str.h>
+#include <gnutls_datum.h>
/* this function parses tpasswd.conf file. Format is:
* string(username):base64(v):base64(salt):int(index)
*/
-static int pwd_put_values( GNUTLS_SRP_PWD_ENTRY *entry, char *str) {
+static int pwd_put_values( SRP_PWD_ENTRY *entry, char *str) {
char * p;
int len, ret;
opaque *verifier;
p++;
len = strlen(p);
-
- entry->salt_size = _gnutls_sbase64_decode( p, len, &entry->salt);
- if (entry->salt_size <= 0) {
+ entry->salt.size = _gnutls_sbase64_decode( p, len, &entry->salt.data);
+
+ if (entry->salt.size <= 0) {
gnutls_assert();
return GNUTLS_E_PARSING_ERROR;
}
/* now go for verifier */
p = rindex( str, ':'); /* we have verifier */
if (p==NULL) {
- gnutls_free(entry->salt);
+ gnutls_free_datum(&entry->salt);
return GNUTLS_E_PARSING_ERROR;
}
ret = _gnutls_sbase64_decode( p, len, &verifier);
if (ret <= 0) {
gnutls_assert();
- gnutls_free(entry->salt);
+ gnutls_free_datum(&entry->salt);
return GNUTLS_E_PARSING_ERROR;
}
verifier_size = ret;
- if (_gnutls_mpi_scan(&entry->v, verifier, &verifier_size)) {
- gnutls_assert();
- gnutls_free( entry->salt);
- return GNUTLS_E_MPI_SCAN_FAILED;
- }
-
- gnutls_free( verifier);
+ entry->v.data = verifier;
+ entry->v.size = verifier_size;
/* now go for username */
*p='\0';
entry->username = gnutls_strdup(str);
if (entry->username==NULL) {
- gnutls_free( entry->salt);
+ gnutls_free_datum( &entry->salt);
gnutls_assert();
return GNUTLS_E_MEMORY_ERROR;
}
/* this function parses tpasswd.conf file. Format is:
* int(index):base64(n):int(g)
*/
-static int pwd_put_values2( GNUTLS_SRP_PWD_ENTRY *entry, char *str)
+static int pwd_put_values2( SRP_PWD_ENTRY *entry, char *str)
{
char * p;
int len;
opaque * tmp;
int ret;
-size_t tmp_size;
p = rindex( str, ':'); /* we have g */
if (p==NULL) {
return GNUTLS_E_PARSING_ERROR;
}
- tmp_size = ret;
- if (_gnutls_mpi_scan(&entry->g, tmp, &tmp_size)) {
- gnutls_assert();
- gnutls_free(tmp);
- return GNUTLS_E_MPI_SCAN_FAILED;
- }
-
- gnutls_free(tmp);
-
+ entry->g.data = tmp;
+ entry->g.size = ret;
/* now go for n - modulo */
p = rindex( str, ':'); /* we have n */
if (p==NULL) {
- _gnutls_mpi_release(&entry->g);
+ gnutls_free_datum( &entry->g);
gnutls_assert();
return GNUTLS_E_PARSING_ERROR;
}
if (ret < 0) {
gnutls_assert();
- _gnutls_mpi_release(&entry->g);
+ gnutls_free_datum( &entry->g);
return GNUTLS_E_PARSING_ERROR;
}
- tmp_size = ret;
- if (_gnutls_mpi_scan(&entry->n, tmp, &tmp_size)) {
- gnutls_assert();
- gnutls_free(tmp);
- _gnutls_mpi_release(&entry->g);
- return GNUTLS_E_MPI_SCAN_FAILED;
- }
-
- gnutls_free(tmp);
+
+ entry->n.data = tmp;
+ entry->n.size = ret;
return 0;
}
/* this function opens the tpasswd.conf file
*/
-static int pwd_read_conf( const char* pconf_file, GNUTLS_SRP_PWD_ENTRY* entry, int index) {
+static int pwd_read_conf( const char* pconf_file, SRP_PWD_ENTRY* entry, int index) {
FILE * fd;
char line[2*1024];
uint i;
}
-GNUTLS_SRP_PWD_ENTRY *_gnutls_srp_pwd_read_entry( gnutls_session state, char* username, int *err) {
+SRP_PWD_ENTRY *_gnutls_srp_pwd_read_entry( gnutls_session state, char* username, int *err) {
const gnutls_srp_server_credentials cred;
FILE * fd;
char line[2*1024];
uint i, len;
- GNUTLS_SRP_PWD_ENTRY * entry = gnutls_malloc(sizeof(GNUTLS_SRP_PWD_ENTRY));
- int index;
- int pwd_index = 0;
-
+ SRP_PWD_ENTRY * entry;
+ int index, pwd_index = 0, ret;
+
+ entry = gnutls_calloc(1, sizeof(SRP_PWD_ENTRY));
if (entry==NULL) {
gnutls_assert();
*err = 1;
return NULL;
}
+ /* if the callback which sends the parameters is
+ * set.
+ */
+ if (cred->pwd_callback != NULL) {
+ ret = cred->pwd_callback( state, username, &entry->salt,
+ &entry->v, &entry->g, &entry->n);
+
+ if (ret < 0) {
+ gnutls_assert();
+ gnutls_free(entry);
+ return NULL;
+ }
+
+ return entry;
+ }
+
if (cred->password_files<=0) {
gnutls_assert();
return NULL;
}
#define RNDUSER "rnd"
#define RND_SALT_SIZE 17
-GNUTLS_SRP_PWD_ENTRY* _gnutls_randomize_pwd_entry() {
- GNUTLS_SRP_PWD_ENTRY * pwd_entry = gnutls_calloc(1, sizeof(GNUTLS_SRP_PWD_ENTRY));
+SRP_PWD_ENTRY* _gnutls_randomize_pwd_entry() {
+ int ret;
+ SRP_PWD_ENTRY * pwd_entry = gnutls_calloc(1, sizeof(SRP_PWD_ENTRY));
if (pwd_entry == NULL) {
gnutls_assert();
return NULL;
}
- pwd_entry->g = _gnutls_get_rnd_srp_params( &pwd_entry->n, 1024);
- if (pwd_entry->g==NULL || pwd_entry->n==NULL) {
+ ret = _gnutls_get_rnd_srp_params( &pwd_entry->g, &pwd_entry->n, 1024);
+ if (ret < 0) {
gnutls_assert();
_gnutls_srp_clear_pwd_entry( pwd_entry);
return NULL;
}
_gnutls_str_cpy( pwd_entry->username, MAX_SRP_USERNAME, RNDUSER); /* Flawfinder: ignore */
- pwd_entry->v = _gnutls_mpi_new(160);
- if (pwd_entry->v==NULL) {
+ pwd_entry->v.data = gnutls_malloc(20);
+ pwd_entry->v.size = 20;
+ if (pwd_entry->v.data==NULL) {
gnutls_assert();
_gnutls_srp_clear_pwd_entry( pwd_entry);
return NULL;
}
- _gnutls_mpi_randomize( pwd_entry->v, 160, GCRY_WEAK_RANDOM);
+ _gnutls_get_random( pwd_entry->v.data, 20, GNUTLS_WEAK_RANDOM);
- pwd_entry->salt_size = RND_SALT_SIZE;
+ pwd_entry->salt.size = RND_SALT_SIZE;
- pwd_entry->salt = gnutls_malloc(RND_SALT_SIZE);
- if (pwd_entry->salt==NULL) {
+ pwd_entry->salt.data = gnutls_malloc(RND_SALT_SIZE);
+ if (pwd_entry->salt.data==NULL) {
gnutls_assert();
_gnutls_srp_clear_pwd_entry( pwd_entry);
return NULL;
}
- if (_gnutls_get_random(pwd_entry->salt, RND_SALT_SIZE, GNUTLS_WEAK_RANDOM) < 0) {
+ if (_gnutls_get_random(pwd_entry->salt.data, RND_SALT_SIZE, GNUTLS_WEAK_RANDOM) < 0) {
gnutls_assert();
_gnutls_srp_clear_pwd_entry( pwd_entry);
return NULL;
}
-void _gnutls_srp_clear_pwd_entry( GNUTLS_SRP_PWD_ENTRY * entry) {
- _gnutls_mpi_release(&entry->v);
- _gnutls_mpi_release(&entry->g);
- _gnutls_mpi_release(&entry->n);
-
- gnutls_free(entry->salt);
+void _gnutls_srp_clear_pwd_entry( SRP_PWD_ENTRY * entry) {
+ gnutls_free_datum(&entry->v);
+ gnutls_free_datum(&entry->g);
+ gnutls_free_datum(&entry->n);
+ gnutls_free_datum(&entry->salt);
+
gnutls_free(entry->username);
-
gnutls_free(entry);
return;
}
-/* Generates a prime and a generator, and returns the srpbase64 encoded value.
- */
-int _gnutls_srp_generate_prime(opaque ** ret_g, opaque ** ret_n, int bits)
-{
-
- GNUTLS_MPI prime, g;
- size_t siz;
- char *tmp;
-
- if ( _gnutls_dh_generate_prime(&g, &prime, bits) < 0) {
- gnutls_assert();
- return GNUTLS_E_MEMORY_ERROR;
- }
-
- siz = 0;
- _gnutls_mpi_print( NULL, &siz, g);
- if (ret_g != NULL) {
- tmp = gnutls_malloc(siz);
- if (tmp==NULL) return GNUTLS_E_MEMORY_ERROR;
-
- _gnutls_mpi_print( tmp, &siz, g);
-
- if (_gnutls_sbase64_encode(tmp, siz, ret_g) < 0) {
- gnutls_free(tmp);
- return GNUTLS_E_INTERNAL_ERROR;
- }
- gnutls_free(tmp);
- }
-
- siz = 0;
- _gnutls_mpi_print( NULL, &siz, prime);
- if (ret_n != NULL) {
- tmp = gnutls_malloc(siz);
- if (tmp==NULL) return GNUTLS_E_MEMORY_ERROR;
-
- _gnutls_mpi_print( tmp, &siz, prime);
- if (_gnutls_sbase64_encode(tmp, siz, ret_n) < 0) {
- gnutls_free(tmp);
- return GNUTLS_E_INTERNAL_ERROR;
- }
-
- gnutls_free(tmp);
- }
-
- _gnutls_mpi_release(&g);
- _gnutls_mpi_release(&prime);
-
- return 0;
-
-}
#endif /* ENABLE SRP */
typedef struct {
char* username;
- opaque *salt;
- int salt_size;
-
- MPI v;
- MPI g;
- MPI n;
-} GNUTLS_SRP_PWD_ENTRY;
+ gnutls_datum salt;
+ gnutls_datum v;
+ gnutls_datum g;
+ gnutls_datum n;
+} SRP_PWD_ENTRY;
/* this is localy alocated. It should be freed using the provided function */
-GNUTLS_SRP_PWD_ENTRY *_gnutls_srp_pwd_read_entry( gnutls_session state, char* username, int* err);
-void _gnutls_srp_clear_pwd_entry( GNUTLS_SRP_PWD_ENTRY * entry);
-GNUTLS_SRP_PWD_ENTRY* _gnutls_randomize_pwd_entry(void);
+SRP_PWD_ENTRY *_gnutls_srp_pwd_read_entry( gnutls_session state, char* username, int* err);
+void _gnutls_srp_clear_pwd_entry( SRP_PWD_ENTRY * entry);
+SRP_PWD_ENTRY* _gnutls_randomize_pwd_entry(void);
int _gnutls_sbase64_encode(uint8 * data, size_t data_size, uint8 ** result);
int _gnutls_sbase64_decode(uint8 * data, size_t data_size, uint8 ** result);
gnutls_assert();
return GNUTLS_E_OPENPGP_GETKEY_FAILED;
}
+
+ if (gnutls_malloc != malloc) {
+ char* tmpdata = gnutls_malloc( ret->size);
+ if (tmpdata == NULL) {
+ free( ret->data);
+ return GNUTLS_E_OPENPGP_GETKEY_FAILED;
+ }
+ memcpy(tmpdata, ret->data, ret->size);
+ free( ret->data);
+
+ ret->data = tmpdata;
+ }
}
return rc;
* first password file
*
* In case the callback returned a negative number then gnutls will
- * not attempt to choose the appropriate certificate and the caller function
- * will fail.
+ * terminate this handshake.
*
* The callback function will only be called once per handshake.
- * The callback function should return the index of the certificate
- * choosen by the server. -1 indicates an error.
+ * The callback function should return the index of the password file
+ * that will be used by the server. -1 indicates an error.
*
**/
void gnutls_srp_server_set_select_function(gnutls_session session,
session->internals.server_srp_callback = func;
}
+/**
+ * gnutls_srp_server_set_credentials_function - Used to set a callback to retrieve the user's SRP credentials
+ * @cred: is a &gnutls_srp_server_credentials structure.
+ * @func: is the callback function
+ *
+ * The callback's function form is:
+ * int (*callback)(gnutls_session, const char* username,
+ * gnutls_datum* salt, gnutls_datum *verifier, gnutls_datum* g,
+ * gnutls_datum* n);
+ *
+ * 'username' contains the actual username.
+ *
+ * The 'salt', 'verifier', 'generator' and 'prime' must be filled
+ * in.
+ *
+ * In case the callback returned a negative number then gnutls will
+ * assume that the username does not exist.
+ *
+ * The callback function will only be called once per handshake.
+ * The callback function should return 0 on success.
+ * -1 indicates an error.
+ *
+ **/
+void gnutls_srp_server_set_credentials_function(
+ gnutls_srp_server_credentials cred,
+ gnutls_srp_server_credentials_function * func)
+{
+ cred->pwd_callback = func;
+}
+
+
/**
* gnutls_srp_server_get_username - This function returns the username of the peer
* @session: is a gnutls session
int _gnutls_calc_srp_x( char* username, char* password, opaque* salt, size_t salt_size, size_t* size, void* digest);
int _gnutls_srp_gn( opaque** ret_g, opaque** ret_n, int bits);
-/* our prime */
-extern const uint8 diffie_hellman_group1_prime[130];
-
/* g is defined to be 2 */
#define SRP_MAX_HASH_SIZE 24
#include <stdio.h>
#include <stdlib.h>
+#include <string.h>
#include <gnutls/gnutls.h>
#include <gnutls/extra.h>
#include <time.h>
gnutls_datum res;
gnutls_x509_certificate_to_xml(&cert_list[0], &res, 0);
- printf(res.data);
+ puts(res.data);
free(res.data);
gnutls_datum res;
gnutls_openpgp_key_to_xml(&cert_list[0], &res, 0);
- printf(res.data);
+ puts(res.data);
free(res.data);
projects / thirdparty / gnutls.git / commitdiff
