gnutls_handshake_get_last_out().
- The gnutls_certificate_set_rsa_params() was renamed to
gnutls_certificate_set_rsa_export_params().
+- Added the new functions: gnutls_certificate_set_x509_key()
+ gnutls_certificate_set_x509_trust(), gnutls_certificate_set_x509_crl(),
+ gnutls_x509_crt_export(), gnutls_x509_crl_export().
+
Version 0.9.2 (15/03/2003)
- Some corrections in the memory mapping code (file is unmapped after
/* Certificate handling functions */
-struct gnutls_x509_crt_int;
-typedef struct gnutls_x509_crt_int* gnutls_x509_crt;
int gnutls_x509_crt_init(gnutls_x509_crt * cert);
void gnutls_x509_crt_deinit(gnutls_x509_crt cert);
int gnutls_x509_crt_import(gnutls_x509_crt cert, const gnutls_datum * data,
gnutls_x509_crt_fmt format);
+int gnutls_x509_crt_export( gnutls_x509_crt cert,
+ gnutls_x509_crt_fmt format, unsigned char* output_data, int* output_data_size);
int gnutls_x509_crt_get_issuer_dn(gnutls_x509_crt cert, char *buf,
int *sizeof_buf);
int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt cert,
/* CRL handling functions */
-struct gnutls_x509_crl_int;
-typedef struct gnutls_x509_crl_int* gnutls_x509_crl;
int gnutls_x509_crl_init(gnutls_x509_crl * crl);
void gnutls_x509_crl_deinit(gnutls_x509_crl crl);
int gnutls_x509_crl_import(gnutls_x509_crl crl, const gnutls_datum * data,
gnutls_x509_crt_fmt format);
+int gnutls_x509_crl_export( gnutls_x509_crl crl,
+ gnutls_x509_crt_fmt format, unsigned char* output_data, int* output_data_size);
int gnutls_x509_crl_get_issuer_dn(const gnutls_x509_crl crl,
char *buf, int *sizeof_buf);
/* Private key handling
*/
-struct gnutls_x509_privkey_int;
-typedef struct gnutls_x509_privkey_int* gnutls_x509_privkey;
int gnutls_x509_privkey_init(gnutls_x509_privkey * key);
void gnutls_x509_privkey_deinit(gnutls_x509_privkey key);
int gnutls_certificate_allocate_credentials( gnutls_certificate_credentials *sc);
void gnutls_certificate_free_keys(gnutls_certificate_credentials sc);
+void gnutls_certificate_free_cas(gnutls_certificate_credentials sc);
+void gnutls_certificate_free_crls(gnutls_certificate_credentials sc);
void gnutls_certificate_set_dh_params(gnutls_certificate_credentials res, gnutls_dh_params);
void gnutls_certificate_set_rsa_export_params(gnutls_certificate_credentials res, gnutls_rsa_params rsa_params);
void gnutls_certificate_set_verify_flags(gnutls_certificate_credentials res, unsigned int flags);
+
int gnutls_certificate_set_x509_trust_file( gnutls_certificate_credentials res, const char* CAFILE,
gnutls_x509_crt_fmt);
int gnutls_certificate_set_x509_trust_mem(gnutls_certificate_credentials res,
const gnutls_datum* CERT, const gnutls_datum* KEY,
gnutls_x509_crt_fmt);
+
+/* New functions to allow setting already parsed X.509 stuff.
+ */
+struct gnutls_x509_privkey_int;
+typedef struct gnutls_x509_privkey_int* gnutls_x509_privkey;
+
+struct gnutls_x509_crl_int;
+typedef struct gnutls_x509_crl_int* gnutls_x509_crl;
+
+struct gnutls_x509_crt_int;
+typedef struct gnutls_x509_crt_int* gnutls_x509_crt;
+
+int gnutls_certificate_set_x509_key(gnutls_certificate_credentials res,
+ gnutls_x509_crt *cert_list, int cert_list_size,
+ gnutls_x509_privkey key);
+int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials res,
+ gnutls_x509_crt * ca_list, int ca_list_size);
+int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials res,
+ gnutls_x509_crl* crl_list, int crl_list_size);
+
+
/* global state functions
*/
int gnutls_global_init(void);
}
+/* Like above but it accepts a parsed certificate instead.
+ */
+int _gnutls_x509_crt2gnutls_cert(gnutls_cert * gcert, gnutls_x509_crt cert,
+ unsigned int flags)
+{
+ int ret = 0;
+
+ memset(gcert, 0, sizeof(gnutls_cert));
+ gcert->cert_type = GNUTLS_CRT_X509;
+
+ if ( !(flags & CERT_NO_COPY)) {
+ opaque* der;
+ int der_size = 0;
+
+ ret = gnutls_x509_crt_export( cert, GNUTLS_X509_FMT_DER, NULL, &der_size);
+ if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER) {
+ gnutls_assert();
+ return ret;
+ }
+
+ der = gnutls_malloc( der_size);
+ if (der == NULL) {
+ gnutls_assert();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+ ret = gnutls_x509_crt_export( cert, GNUTLS_X509_FMT_DER, der, &der_size);
+ if (ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+
+ gcert->raw.data = der;
+ gcert->raw.size = der_size;
+ } else
+ /* now we have 0 or a bitwise or of things to decode */
+ flags ^= CERT_NO_COPY;
+
+
+ if (flags & CERT_ONLY_EXTENSIONS || flags == 0) {
+ gnutls_x509_crt_get_key_usage( cert, &gcert->keyUsage, NULL);
+ gcert->version = gnutls_x509_crt_get_version( cert);
+ }
+ gcert->subject_pk_algorithm = gnutls_x509_crt_get_pk_algorithm( cert, NULL);
+
+ if (flags & CERT_ONLY_PUBKEY || flags == 0) {
+ gcert->params_size = MAX_PUBLIC_PARAMS_SIZE;
+ ret = _gnutls_x509_crt_get_mpis( cert, gcert->params, &gcert->params_size);
+ if (ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+ }
+
+ return 0;
+
+}
+
void _gnutls_free_cert(gnutls_cert *cert)
{
int i;
int _gnutls_x509_cert2gnutls_cert(gnutls_cert * gcert, const gnutls_datum *derCert,
int flags);
+int _gnutls_x509_crt2gnutls_cert(gnutls_cert * gcert, gnutls_x509_crt cert,
+ unsigned int flags);
void _gnutls_free_cert(gnutls_cert* cert);
int _gnutls_cert_get_dn(gnutls_cert * cert, gnutls_datum * odn);
return 0;
}
-#define MAX_FILE_SIZE 100*1024
-
/* Reads a DER encoded certificate list from memory and stores it to
* a gnutls_cert structure. This is only called if PKCS7 read fails.
* returns the number of certificates parsed (1)
*/
-static int parse_der_cert_mem( gnutls_cert** cert_list, int* ncerts,
- const char *input_cert, int input_cert_size)
+static int parse_crt_mem( gnutls_cert** cert_list, int* ncerts,
+ gnutls_x509_crt cert)
{
int i;
- gnutls_datum tmp;
int ret;
i = *ncerts + 1;
return GNUTLS_E_MEMORY_ERROR;
}
- tmp.data = (opaque*)input_cert;
- tmp.size = input_cert_size;
-
- ret = _gnutls_x509_cert2gnutls_cert(
- &cert_list[0][i - 1], &tmp, 0);
+ ret = _gnutls_x509_crt2gnutls_cert(
+ &cert_list[0][i-1], cert, 0);
if ( ret < 0) {
gnutls_assert();
return ret;
return 1; /* one certificate parsed */
}
+/* Reads a DER encoded certificate list from memory and stores it to
+ * a gnutls_cert structure. This is only called if PKCS7 read fails.
+ * returns the number of certificates parsed (1)
+ */
+static int parse_der_cert_mem( gnutls_cert** cert_list, int* ncerts,
+ const char *input_cert, int input_cert_size)
+{
+ gnutls_datum tmp;
+ gnutls_x509_crt cert;
+ int ret;
+
+ ret = gnutls_x509_crt_init( &cert);
+ if ( ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+
+ tmp.data = (opaque*)input_cert;
+ tmp.size = input_cert_size;
+
+ ret = gnutls_x509_crt_import( cert, &tmp, GNUTLS_X509_FMT_DER);
+ if ( ret < 0) {
+ gnutls_assert();
+ gnutls_x509_crt_deinit( cert);
+ return ret;
+ }
+
+ ret = parse_crt_mem( cert_list, ncerts, cert);
+ gnutls_x509_crt_deinit( cert);
+
+ return ret;
+}
+
#define CERT_PEM 1
/* Reads a PKCS7 base64 encoded certificate list from memory and stores it to
return ret;
}
- privkey_cpy( &res->pkey[res->ncerts], tmpkey);
+ ret = privkey_cpy( &res->pkey[res->ncerts], tmpkey);
+ if (ret < 0) {
+ gnutls_assert();
+ gnutls_x509_privkey_deinit( tmpkey);
+
+ return ret;
+ }
gnutls_x509_privkey_deinit( tmpkey);
}
+/**
+ * gnutls_certificate_free_cas - Used to free all the CAs from a gnutls_certificate_credentials structure
+ * @sc: is an &gnutls_certificate_credentials structure.
+ *
+ * This function will delete all the CAs associated
+ * with the given credentials.
+ *
+ **/
+void gnutls_certificate_free_cas(gnutls_certificate_credentials sc)
+{
+ uint j;
+
+ for (j = 0; j < sc->x509_ncas; j++) {
+ gnutls_x509_crt_deinit( sc->x509_ca_list[j]);
+ }
+
+ sc->x509_ncas = 0;
+
+ gnutls_free( sc->x509_ca_list);
+ sc->x509_ca_list = NULL;
+}
+
+/**
+ * gnutls_certificate_free_crls - Used to free all the CRLs from a gnutls_certificate_credentials structure
+ * @sc: is an &gnutls_certificate_credentials structure.
+ *
+ * This function will delete all the CRLs associated
+ * with the given credentials.
+ *
+ **/
+void gnutls_certificate_free_crls(gnutls_certificate_credentials sc)
+{
+ uint j;
+
+ for (j = 0; j < sc->x509_ncrls; j++) {
+ gnutls_x509_crl_deinit( sc->x509_crl_list[j]);
+ }
+
+ sc->x509_ncrls = 0;
+
+ gnutls_free( sc->x509_crl_list);
+ sc->x509_crl_list = NULL;
+}
+
/**
* gnutls_certificate_set_x509_key_mem - Used to set keys in a gnutls_certificate_credentials structure
* @res: is an &gnutls_certificate_credentials structure.
if ((ret = read_cert_mem( res, CERT->data, CERT->size, type)) < 0)
return ret;
+ res->ncerts++;
+
+ if ((ret=_gnutls_check_key_cert_match( res)) < 0) {
+ gnutls_assert();
+ return ret;
+ }
+
+ return 0;
+}
+
+/**
+ * gnutls_certificate_set_x509_key - Used to set keys in a gnutls_certificate_credentials structure
+ * @res: is an &gnutls_certificate_credentials structure.
+ * @cert_list: contains a certificate list (path) for the specified private key
+ * @cert_list_size: holds the size of the certificate list
+ * @key: is a gnutls_x509_privkey key
+ *
+ * This function sets a certificate/private key pair in the
+ * gnutls_certificate_credentials structure. This function may be called
+ * more than once (in case multiple keys/certificates exist for the
+ * server).
+ *
+ **/
+int gnutls_certificate_set_x509_key(gnutls_certificate_credentials res,
+ gnutls_x509_crt *cert_list, int cert_list_size,
+ gnutls_x509_privkey key)
+{
+ int ret, i;
+
+ /* this should be first
+ */
+
+ res->pkey = gnutls_realloc_fast( res->pkey, (res->ncerts+1)*sizeof(gnutls_privkey));
+ if (res->pkey==NULL) {
+ gnutls_assert();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+ ret = privkey_cpy( &res->pkey[res->ncerts], key);
+ if (ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+
+ res->cert_list = gnutls_realloc_fast( res->cert_list,
+ (1+ res->ncerts)*sizeof(gnutls_cert*));
+ if ( res->cert_list==NULL) {
+ gnutls_assert();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+ res->cert_list_length = gnutls_realloc_fast( res->cert_list_length,
+ (1+ res->ncerts)*sizeof(int));
+ if (res->cert_list_length==NULL) {
+ gnutls_assert();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+ res->cert_list[res->ncerts] = NULL; /* for realloc */
+ res->cert_list_length[res->ncerts] = 0;
+
+
+ for (i=0;i<cert_list_size;i++) {
+ ret = parse_crt_mem( &res->cert_list[res->ncerts],
+ &res->cert_list_length[res->ncerts], cert_list[i]);
+ if ( ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+ }
+ res->ncerts++;
+
if ((ret=_gnutls_check_key_cert_match( res)) < 0) {
gnutls_assert();
return ret;
return ret;
}
+/**
+ * gnutls_certificate_set_x509_trust - Used to add trusted CAs in a gnutls_certificate_credentials structure
+ * @res: is an &gnutls_certificate_credentials structure.
+ * @ca_list: is a list of trusted CAs
+ * @ca_list_size: holds the size of the CA list
+ *
+ * This function adds the trusted CAs in order to verify client
+ * certificates. This function may be called multiple times.
+ *
+ * In case of a server the CAs set here will be sent to the client
+ * if a certificate request is sent. This can be disabled using
+ * gnutls_certificate_send_x509_rdn_sequence().
+ *
+ **/
+int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials res,
+ gnutls_x509_crt * ca_list, int ca_list_size)
+{
+ int ret, i, ret2;
+
+ res->x509_ca_list = gnutls_realloc_fast( res->x509_ca_list,
+ (ca_list_size + res->x509_ncas)*sizeof(gnutls_x509_crt));
+ if ( res->x509_ca_list==NULL) {
+ gnutls_assert();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+ for (i=0;i<ca_list_size;i++) {
+ ret = _gnutls_x509_crt_cpy( res->x509_ca_list[i+res->x509_ncas],
+ ca_list[i]);
+ if ( ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+ res->x509_ncas++;
+ }
+
+ if ((ret2 = generate_rdn_seq(res)) < 0)
+ return ret2;
+
+ return 0;
+}
+
/**
* gnutls_certificate_set_x509_trust_file - Used to add trusted CAs in a gnutls_certificate_credentials structure
* @res: is an &gnutls_certificate_credentials structure.
return ret;
}
+/**
+ * gnutls_certificate_set_x509_crl - Used to add CRLs in a gnutls_certificate_credentials structure
+ * @res: is an &gnutls_certificate_credentials structure.
+ * @crl_list: is a list of trusted CRLs. They should have been verified before.
+ * @crl_list_size: holds the size of the crl_list
+ *
+ * This function adds the trusted CRLs in order to verify client or server
+ * certificates. This function may be called multiple times.
+ *
+ **/
+int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials res,
+ gnutls_x509_crl* crl_list, int crl_list_size)
+{
+ int ret, i;
+
+ res->x509_crl_list = gnutls_realloc_fast( res->x509_crl_list,
+ (crl_list_size + res->x509_ncrls)*sizeof(gnutls_x509_crl));
+ if ( res->x509_crl_list==NULL) {
+ gnutls_assert();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+ for (i=0;i<crl_list_size;i++) {
+ ret = _gnutls_x509_crl_cpy( res->x509_crl_list[i+res->x509_ncrls],
+ crl_list[i]);
+ if ( ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+ res->x509_ncrls++;
+ }
+
+ return 0;
+}
+
/**
* gnutls_certificate_set_x509_crl_file - Used to add CRLs in a gnutls_certificate_credentials structure
* @res: is an &gnutls_certificate_credentials structure.
if(p->value[0]=='F') der[counter++]=0;
else der[counter++]=0xFF;
}
+ else
+ counter+=2;
}
move=RIGHT;
break;
pkcs-5-id-PBKDF2 OBJECT IDENTIFIER ::= {pkcs-5 12}
+-- pkcs-5-id-hmacWithSHA1 OBJECT IDENTIFIER ::= {iso(1) member-body(2) us(840) rsadsi(113549) 2 7}
+
-- pkcs-5-algid-hmacWithSHA1 AlgorithmIdentifier ::=
--- {algorithm pkcs-5-id-hmacWithSHA1, parameters NULL : NULL}
+-- {algorithm pkcs-5-id-hmacWithSHA1, parameters NULL : NULL}
pkcs-5-PBKDF2-params ::= SEQUENCE {
salt CHOICE {
}
+/**
+ * gnutls_x509_crl_export - This function will export the CRL
+ * @crl: Holds the revocation list
+ * @format: the format of output params. One of PEM or DER.
+ * @output_data: will contain a private key PEM or DER encoded
+ * @output_data_size: holds the size of output_data (and will be replaced by the actual size of parameters)
+ *
+ * This function will export the revocation list to DER or PEM format.
+ *
+ * If the buffer provided is not long enough to hold the output, then
+ * GNUTLS_E_SHORT_MEMORY_BUFFER will be returned.
+ *
+ * If the structure is PEM encoded, it will have a header
+ * of "BEGIN X509 CRL".
+ *
+ * In case of failure a negative value will be returned, and
+ * 0 on success.
+ *
+ **/
+int gnutls_x509_crl_export( gnutls_x509_crl crl,
+ gnutls_x509_crt_fmt format, unsigned char* output_data, int* output_data_size)
+{
+ return _gnutls_x509_export_int( crl->crl, format, PEM_CRL, *output_data_size,
+ output_data, output_data_size);
+}
+
+/*-
+ * _gnutls_x509_crl_cpy - This function copies a gnutls_x509_crl structure
+ * @dest: The structure where to copy
+ * @src: The structure to be copied
+ *
+ * This function will copy an X.509 certificate structure.
+ *
+ * Returns 0 on success.
+ *
+ -*/
+int _gnutls_x509_crl_cpy(gnutls_x509_crl dest, gnutls_x509_crl src)
+{
+int ret;
+int der_size;
+opaque * der;
+gnutls_datum tmp;
+
+ ret = gnutls_x509_crl_export( src, GNUTLS_X509_FMT_DER, NULL, &der_size);
+ if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER) {
+ gnutls_assert();
+ return ret;
+ }
+
+ der = gnutls_alloca( der_size);
+ if (der == NULL) {
+ gnutls_assert();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+ ret = gnutls_x509_crl_export( src, GNUTLS_X509_FMT_DER, der, &der_size);
+ if (ret < 0) {
+ gnutls_assert();
+ gnutls_afree( der);
+ return ret;
+ }
+
+ tmp.data = der;
+ tmp.size = der_size;
+ ret = gnutls_x509_crl_import( dest, &tmp, GNUTLS_X509_FMT_DER);
+
+ gnutls_afree( der);
+
+ if (ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+
+ return 0;
+
+}
#include <gnutls_ui.h>
/**
- * gnutls_x509_crt_init - This function initializes a gnutls_crl structure
+ * gnutls_x509_crt_init - This function initializes a gnutls_x509_crt structure
* @cert: The structure to be initialized
*
* This function will initialize an X.509 certificate structure.
return GNUTLS_E_MEMORY_ERROR;
}
+/*-
+ * _gnutls_x509_crt_cpy - This function copies a gnutls_x509_crt structure
+ * @dest: The structure where to copy
+ * @src: The structure to be copied
+ *
+ * This function will copy an X.509 certificate structure.
+ *
+ * Returns 0 on success.
+ *
+ -*/
+int _gnutls_x509_crt_cpy(gnutls_x509_crt dest, gnutls_x509_crt src)
+{
+int ret;
+int der_size;
+opaque * der;
+gnutls_datum tmp;
+
+ ret = gnutls_x509_crt_export( src, GNUTLS_X509_FMT_DER, NULL, &der_size);
+ if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER) {
+ gnutls_assert();
+ return ret;
+ }
+
+ der = gnutls_alloca( der_size);
+ if (der == NULL) {
+ gnutls_assert();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+ ret = gnutls_x509_crt_export( src, GNUTLS_X509_FMT_DER, der, &der_size);
+ if (ret < 0) {
+ gnutls_assert();
+ gnutls_afree( der);
+ return ret;
+ }
+
+ tmp.data = der;
+ tmp.size = der_size;
+ ret = gnutls_x509_crt_import( dest, &tmp, GNUTLS_X509_FMT_DER);
+
+ gnutls_afree( der);
+
+ if (ret < 0) {
+ gnutls_assert();
+ return ret;
+ }
+
+ return 0;
+
+}
+
/**
* gnutls_x509_crt_deinit - This function deinitializes memory used by a gnutls_x509_crt structure
* @cert: The structure to be initialized
return _gnutls_asn2err(result);
}
- tmp.data = cert_buf;
tmp.size = cert_buf_size;
result = gnutls_fingerprint( algo, &tmp, buf, sizeof_buf);
return result;
}
+/**
+ * gnutls_x509_crt_export - This function will export the certificate
+ * @cert: Holds the certificate
+ * @format: the format of output params. One of PEM or DER.
+ * @output_data: will contain a private key PEM or DER encoded
+ * @output_data_size: holds the size of output_data (and will be replaced by the actual size of parameters)
+ *
+ * This function will export the certificate to DER or PEM format.
+ *
+ * If the buffer provided is not long enough to hold the output, then
+ * GNUTLS_E_SHORT_MEMORY_BUFFER will be returned.
+ *
+ * If the structure is PEM encoded, it will have a header
+ * of "BEGIN CERTIFICATE".
+ *
+ * In case of failure a negative value will be returned, and
+ * 0 on success.
+ *
+ **/
+int gnutls_x509_crt_export( gnutls_x509_crt cert,
+ gnutls_x509_crt_fmt format, unsigned char* output_data, int* output_data_size)
+{
+ return _gnutls_x509_export_int( cert->cert, format, "CERTIFICATE", *output_data_size,
+ output_data, output_data_size);
+}
+
/* A generic export function. Will export the given ASN.1 encoded data
* to PEM or DER raw data.
int gnutls_x509_crt_get_ca_status(gnutls_x509_crt cert, int* critical);
int gnutls_x509_crt_get_pk_algorithm( gnutls_x509_crt cert, int* bits);
+int _gnutls_x509_crt_cpy(gnutls_x509_crt dest, gnutls_x509_crt src);
int _gnutls_x509_crt_get_raw_issuer_dn( gnutls_x509_crt cert,
gnutls_const_datum* start);
int _gnutls_x509_crt_get_raw_dn( gnutls_x509_crt cert,
int gnutls_x509_crt_check_revocation(gnutls_x509_crt cert, gnutls_x509_crl * crl_list, int crl_list_length);
+int _gnutls_x509_crl_cpy(gnutls_x509_crl dest, gnutls_x509_crl src);
int _gnutls_x509_crl_get_raw_issuer_dn( gnutls_x509_crl crl,
gnutls_const_datum* dn);
int gnutls_x509_crl_get_certificate_count(gnutls_x509_crl crl);
int gnutls_x509_crl_init(gnutls_x509_crl * crl);
int gnutls_x509_crl_import(gnutls_x509_crl crl, const gnutls_datum * data,
gnutls_x509_crt_fmt format);
+int gnutls_x509_crl_export( gnutls_x509_crl crl,
+ gnutls_x509_crt_fmt format, unsigned char* output_data, int* output_data_size);
int gnutls_x509_crt_init(gnutls_x509_crt * cert);
void gnutls_x509_crt_deinit(gnutls_x509_crt cert);
int gnutls_x509_crt_import(gnutls_x509_crt cert, const gnutls_datum * data,
gnutls_x509_crt_fmt format);
+int gnutls_x509_crt_export( gnutls_x509_crt cert,
+ gnutls_x509_crt_fmt format, unsigned char* output_data, int* output_data_size);
int gnutls_x509_crt_get_key_usage(gnutls_x509_crt cert, unsigned int *key_usage,
int *critical);
projects / thirdparty / gnutls.git / commitdiff
