419 lines
15 KiB
Vala
419 lines
15 KiB
Vala
[CCode (cprefix = "gnutls_", lower_case_cprefix = "gnutls_", cheader_filename = "gnutls/gnutls.h")]
|
|
namespace GnuTLS {
|
|
|
|
public int global_init();
|
|
|
|
[CCode (cname = "gnutls_pull_func", has_target = false)]
|
|
public delegate ssize_t PullFunc(void* transport_ptr, [CCode (ctype = "void*", array_length_type="size_t")] uint8[] array);
|
|
|
|
[CCode (cname = "gnutls_pull_timeout_func", has_target = false)]
|
|
public delegate int PullTimeoutFunc(void* transport_ptr, uint ms);
|
|
|
|
[CCode (cname = "gnutls_push_func", has_target = false)]
|
|
public delegate ssize_t PushFunc(void* transport_ptr, [CCode (ctype = "void*", array_length_type="size_t")] uint8[] array);
|
|
|
|
[CCode (cname = "gnutls_certificate_verify_function", has_target = false)]
|
|
public delegate int VerifyFunc(Session session);
|
|
|
|
[Compact]
|
|
[CCode (cname = "struct gnutls_session_int", free_function = "gnutls_deinit")]
|
|
public class Session {
|
|
|
|
public static Session? create(int con_end) throws GLib.Error {
|
|
Session result;
|
|
var ret = init(out result, con_end);
|
|
throw_if_error(ret);
|
|
return result;
|
|
}
|
|
|
|
[CCode (cname = "gnutls_init")]
|
|
private static int init(out Session session, int con_end);
|
|
|
|
[CCode (cname = "gnutls_transport_set_push_function")]
|
|
public void set_push_function(PushFunc func);
|
|
|
|
[CCode (cname = "gnutls_transport_set_pull_function")]
|
|
public void set_pull_function(PullFunc func);
|
|
|
|
[CCode (cname = "gnutls_transport_set_pull_timeout_function")]
|
|
public void set_pull_timeout_function(PullTimeoutFunc func);
|
|
|
|
[CCode (cname = "gnutls_transport_set_ptr")]
|
|
public void set_transport_pointer(void* ptr);
|
|
|
|
[CCode (cname = "gnutls_transport_get_ptr")]
|
|
public void* get_transport_pointer();
|
|
|
|
[CCode (cname = "gnutls_heartbeat_enable")]
|
|
public int enable_heartbeat(uint type);
|
|
|
|
[CCode (cname = "gnutls_certificate_server_set_request")]
|
|
public void server_set_request(CertificateRequest req);
|
|
|
|
[CCode (cname = "gnutls_credentials_set")]
|
|
public int set_credentials_(CredentialsType type, void* cred);
|
|
[CCode (cname = "gnutls_credentials_set_")]
|
|
public void set_credentials(CredentialsType type, void* cred) throws GLib.Error {
|
|
int err = set_credentials_(type, cred);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_priority_set_direct")]
|
|
public int set_priority_from_string_(string priority, out unowned string err_pos = null);
|
|
[CCode (cname = "gnutls_priority_set_direct_")]
|
|
public void set_priority_from_string(string priority, out unowned string err_pos = null) throws GLib.Error {
|
|
int err = set_priority_from_string_(priority, out err_pos);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_srtp_set_profile_direct")]
|
|
public int set_srtp_profile_direct_(string profiles, out unowned string err_pos = null);
|
|
[CCode (cname = "gnutls_srtp_set_profile_direct_")]
|
|
public void set_srtp_profile_direct(string profiles, out unowned string err_pos = null) throws GLib.Error {
|
|
int err = set_srtp_profile_direct_(profiles, out err_pos);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_transport_set_int")]
|
|
public void transport_set_int(int fd);
|
|
|
|
[CCode (cname = "gnutls_handshake")]
|
|
public int handshake();
|
|
|
|
[CCode (cname = "gnutls_srtp_get_keys")]
|
|
public int get_srtp_keys_(void *key_material, uint32 key_material_size, out Datum client_key, out Datum client_salt, out Datum server_key, out Datum server_salt);
|
|
[CCode (cname = "gnutls_srtp_get_keys_")]
|
|
public void get_srtp_keys(void *key_material, uint32 key_material_size, out Datum client_key, out Datum client_salt, out Datum server_key, out Datum server_salt) throws GLib.Error {
|
|
get_srtp_keys_(key_material, key_material_size, out client_key, out client_salt, out server_key, out server_salt);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_certificate_get_peers", array_length_type = "unsigned int")]
|
|
public unowned Datum[]? get_peer_certificates();
|
|
|
|
[CCode (cname = "gnutls_session_set_verify_function")]
|
|
public void set_verify_function(VerifyFunc func);
|
|
}
|
|
|
|
[Compact]
|
|
[CCode (cname = "struct gnutls_certificate_credentials_st", free_function = "gnutls_certificate_free_credentials", cprefix = "gnutls_certificate_")]
|
|
public class CertificateCredentials {
|
|
|
|
[CCode (cname = "gnutls_certificate_allocate_credentials")]
|
|
private static int allocate(out CertificateCredentials credentials);
|
|
|
|
public static CertificateCredentials create() throws GLib.Error {
|
|
CertificateCredentials result;
|
|
var ret = allocate (out result);
|
|
throw_if_error(ret);
|
|
return result;
|
|
}
|
|
|
|
public void get_x509_crt(uint index, [CCode (array_length_type = "unsigned int")] out unowned X509.Certificate[] x509_ca_list);
|
|
|
|
public int set_x509_key(X509.Certificate[] cert_list, X509.PrivateKey key);
|
|
}
|
|
|
|
[CCode (cheader_filename = "gnutls/x509.h", cprefix = "GNUTLS_")]
|
|
namespace X509 {
|
|
|
|
[Compact]
|
|
[CCode (cname = "struct gnutls_x509_crt_int", cprefix = "gnutls_x509_crt_", free_function = "gnutls_x509_crt_deinit")]
|
|
public class Certificate {
|
|
|
|
[CCode (cname = "gnutls_x509_crt_init")]
|
|
private static int init (out Certificate cert);
|
|
public static Certificate create() throws GLib.Error {
|
|
Certificate result;
|
|
var ret = init (out result);
|
|
throw_if_error(ret);
|
|
return result;
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_import")]
|
|
public int import_(ref Datum data, CertificateFormat format);
|
|
[CCode (cname = "gnutls_x509_crt_import_")]
|
|
public void import(ref Datum data, CertificateFormat format) throws GLib.Error {
|
|
int err = import_(ref data, format);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_set_version")]
|
|
public int set_version_(uint version);
|
|
[CCode (cname = "gnutls_x509_crt_set_version_")]
|
|
public void set_version(uint version) throws GLib.Error {
|
|
int err = set_version_(version);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_set_key")]
|
|
public int set_key_(PrivateKey key);
|
|
[CCode (cname = "gnutls_x509_crt_set_key_")]
|
|
public void set_key(PrivateKey key) throws GLib.Error {
|
|
int err = set_key_(key);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_set_activation_time")]
|
|
public int set_activation_time_(time_t act_time);
|
|
[CCode (cname = "gnutls_x509_crt_set_activation_time_")]
|
|
public void set_activation_time(time_t act_time) throws GLib.Error {
|
|
int err = set_activation_time_(act_time);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_set_expiration_time")]
|
|
public int set_expiration_time_(time_t exp_time);
|
|
[CCode (cname = "gnutls_x509_crt_set_expiration_time_")]
|
|
public void set_expiration_time(time_t exp_time) throws GLib.Error {
|
|
int err = set_expiration_time_(exp_time);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_set_serial")]
|
|
public int set_serial_(void* serial, size_t serial_size);
|
|
[CCode (cname = "gnutls_x509_crt_set_serial_")]
|
|
public void set_serial(void* serial, size_t serial_size) throws GLib.Error {
|
|
int err = set_serial_(serial, serial_size);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_sign")]
|
|
public int sign_(Certificate issuer, PrivateKey issuer_key);
|
|
[CCode (cname = "gnutls_x509_crt_sign_")]
|
|
public void sign(Certificate issuer, PrivateKey issuer_key) throws GLib.Error {
|
|
int err = sign_(issuer, issuer_key);
|
|
throw_if_error(err);
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_get_fingerprint")]
|
|
public int get_fingerprint_(DigestAlgorithm algo, void* buf, ref size_t buf_size);
|
|
[CCode (cname = "gnutls_x509_crt_get_fingerprint_")]
|
|
public void get_fingerprint(DigestAlgorithm algo, void* buf, ref size_t buf_size) throws GLib.Error {
|
|
int err = get_fingerprint_(algo, buf, ref buf_size);
|
|
throw_if_error(err);
|
|
}
|
|
}
|
|
|
|
[Compact]
|
|
[CCode (cname = "struct gnutls_x509_privkey_int", cprefix = "gnutls_x509_privkey_", free_function = "gnutls_x509_privkey_deinit")]
|
|
public class PrivateKey {
|
|
private static int init (out PrivateKey key);
|
|
public static PrivateKey create () throws GLib.Error {
|
|
PrivateKey result;
|
|
var ret = init (out result);
|
|
throw_if_error(ret);
|
|
return result;
|
|
}
|
|
|
|
public int generate(PKAlgorithm algo, uint bits, uint flags = 0);
|
|
}
|
|
|
|
}
|
|
|
|
[CCode (cname = "gnutls_certificate_request_t", cprefix = "GNUTLS_CERT_", has_type_id = false)]
|
|
public enum CertificateRequest {
|
|
IGNORE,
|
|
REQUEST,
|
|
REQUIRE
|
|
}
|
|
|
|
[CCode (cname = "gnutls_pk_algorithm_t", cprefix = "GNUTLS_PK_", has_type_id = false)]
|
|
public enum PKAlgorithm {
|
|
UNKNOWN,
|
|
RSA,
|
|
DSA;
|
|
}
|
|
|
|
[CCode (cname = "gnutls_digest_algorithm_t", cprefix = "GNUTLS_DIG_", has_type_id = false)]
|
|
public enum DigestAlgorithm {
|
|
NULL,
|
|
MD5,
|
|
SHA1,
|
|
RMD160,
|
|
MD2,
|
|
SHA224,
|
|
SHA256,
|
|
SHA384,
|
|
SHA512;
|
|
}
|
|
|
|
[Flags]
|
|
[CCode (cname = "gnutls_init_flags_t", cprefix = "GNUTLS_", has_type_id = false)]
|
|
public enum InitFlags {
|
|
SERVER,
|
|
CLIENT,
|
|
DATAGRAM
|
|
}
|
|
|
|
[CCode (cname = "gnutls_credentials_type_t", cprefix = "GNUTLS_CRD_", has_type_id = false)]
|
|
public enum CredentialsType {
|
|
CERTIFICATE,
|
|
ANON,
|
|
SRP,
|
|
PSK,
|
|
IA
|
|
}
|
|
|
|
[CCode (cname = "gnutls_x509_crt_fmt_t", cprefix = "GNUTLS_X509_FMT_", has_type_id = false)]
|
|
public enum CertificateFormat {
|
|
DER,
|
|
PEM
|
|
}
|
|
|
|
[Flags]
|
|
[CCode (cname = "gnutls_certificate_status_t", cprefix = "GNUTLS_CERT_", has_type_id = false)]
|
|
public enum CertificateStatus {
|
|
INVALID, // will be set if the certificate was not verified.
|
|
REVOKED, // in X.509 this will be set only if CRLs are checked
|
|
SIGNER_NOT_FOUND,
|
|
SIGNER_NOT_CA,
|
|
INSECURE_ALGORITHM
|
|
}
|
|
|
|
[SimpleType]
|
|
[CCode (cname = "gnutls_datum_t", has_type_id = false)]
|
|
public struct Datum {
|
|
public uint8* data;
|
|
public uint size;
|
|
|
|
public uint8[] extract() {
|
|
uint8[] ret = new uint8[size];
|
|
for (int i = 0; i < size; i++) {
|
|
ret[i] = data[i];
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
// Gnutls error codes. The mapping to a TLS alert is also shown in comments.
|
|
[CCode (cname = "int", cprefix = "GNUTLS_E_", lower_case_cprefix = "gnutls_error_", has_type_id = false)]
|
|
public enum ErrorCode {
|
|
SUCCESS,
|
|
UNKNOWN_COMPRESSION_ALGORITHM,
|
|
UNKNOWN_CIPHER_TYPE,
|
|
LARGE_PACKET,
|
|
UNSUPPORTED_VERSION_PACKET, // GNUTLS_A_PROTOCOL_VERSION
|
|
UNEXPECTED_PACKET_LENGTH, // GNUTLS_A_RECORD_OVERFLOW
|
|
INVALID_SESSION,
|
|
FATAL_ALERT_RECEIVED,
|
|
UNEXPECTED_PACKET, // GNUTLS_A_UNEXPECTED_MESSAGE
|
|
WARNING_ALERT_RECEIVED,
|
|
ERROR_IN_FINISHED_PACKET,
|
|
UNEXPECTED_HANDSHAKE_PACKET,
|
|
UNKNOWN_CIPHER_SUITE, // GNUTLS_A_HANDSHAKE_FAILURE
|
|
UNWANTED_ALGORITHM,
|
|
MPI_SCAN_FAILED,
|
|
DECRYPTION_FAILED, // GNUTLS_A_DECRYPTION_FAILED, GNUTLS_A_BAD_RECORD_MAC
|
|
MEMORY_ERROR,
|
|
DECOMPRESSION_FAILED, // GNUTLS_A_DECOMPRESSION_FAILURE
|
|
COMPRESSION_FAILED,
|
|
AGAIN,
|
|
EXPIRED,
|
|
DB_ERROR,
|
|
SRP_PWD_ERROR,
|
|
INSUFFICIENT_CREDENTIALS,
|
|
HASH_FAILED,
|
|
BASE64_DECODING_ERROR,
|
|
MPI_PRINT_FAILED,
|
|
REHANDSHAKE, // GNUTLS_A_NO_RENEGOTIATION
|
|
GOT_APPLICATION_DATA,
|
|
RECORD_LIMIT_REACHED,
|
|
ENCRYPTION_FAILED,
|
|
PK_ENCRYPTION_FAILED,
|
|
PK_DECRYPTION_FAILED,
|
|
PK_SIGN_FAILED,
|
|
X509_UNSUPPORTED_CRITICAL_EXTENSION,
|
|
KEY_USAGE_VIOLATION,
|
|
NO_CERTIFICATE_FOUND, // GNUTLS_A_BAD_CERTIFICATE
|
|
INVALID_REQUEST,
|
|
SHORT_MEMORY_BUFFER,
|
|
INTERRUPTED,
|
|
PUSH_ERROR,
|
|
PULL_ERROR,
|
|
RECEIVED_ILLEGAL_PARAMETER, // GNUTLS_A_ILLEGAL_PARAMETER
|
|
REQUESTED_DATA_NOT_AVAILABLE,
|
|
PKCS1_WRONG_PAD,
|
|
RECEIVED_ILLEGAL_EXTENSION,
|
|
INTERNAL_ERROR,
|
|
DH_PRIME_UNACCEPTABLE,
|
|
FILE_ERROR,
|
|
TOO_MANY_EMPTY_PACKETS,
|
|
UNKNOWN_PK_ALGORITHM,
|
|
// returned if libextra functionality was requested but
|
|
// gnutls_global_init_extra() was not called.
|
|
|
|
INIT_LIBEXTRA,
|
|
LIBRARY_VERSION_MISMATCH,
|
|
// returned if you need to generate temporary RSA
|
|
// parameters. These are needed for export cipher suites.
|
|
|
|
NO_TEMPORARY_RSA_PARAMS,
|
|
LZO_INIT_FAILED,
|
|
NO_COMPRESSION_ALGORITHMS,
|
|
NO_CIPHER_SUITES,
|
|
OPENPGP_GETKEY_FAILED,
|
|
PK_SIG_VERIFY_FAILED,
|
|
ILLEGAL_SRP_USERNAME,
|
|
SRP_PWD_PARSING_ERROR,
|
|
NO_TEMPORARY_DH_PARAMS,
|
|
// For certificate and key stuff
|
|
|
|
ASN1_ELEMENT_NOT_FOUND,
|
|
ASN1_IDENTIFIER_NOT_FOUND,
|
|
ASN1_DER_ERROR,
|
|
ASN1_VALUE_NOT_FOUND,
|
|
ASN1_GENERIC_ERROR,
|
|
ASN1_VALUE_NOT_VALID,
|
|
ASN1_TAG_ERROR,
|
|
ASN1_TAG_IMPLICIT,
|
|
ASN1_TYPE_ANY_ERROR,
|
|
ASN1_SYNTAX_ERROR,
|
|
ASN1_DER_OVERFLOW,
|
|
OPENPGP_UID_REVOKED,
|
|
CERTIFICATE_ERROR,
|
|
CERTIFICATE_KEY_MISMATCH,
|
|
UNSUPPORTED_CERTIFICATE_TYPE, // GNUTLS_A_UNSUPPORTED_CERTIFICATE
|
|
X509_UNKNOWN_SAN,
|
|
OPENPGP_FINGERPRINT_UNSUPPORTED,
|
|
X509_UNSUPPORTED_ATTRIBUTE,
|
|
UNKNOWN_HASH_ALGORITHM,
|
|
UNKNOWN_PKCS_CONTENT_TYPE,
|
|
UNKNOWN_PKCS_BAG_TYPE,
|
|
INVALID_PASSWORD,
|
|
MAC_VERIFY_FAILED, // for PKCS #12 MAC
|
|
CONSTRAINT_ERROR,
|
|
WARNING_IA_IPHF_RECEIVED,
|
|
WARNING_IA_FPHF_RECEIVED,
|
|
IA_VERIFY_FAILED,
|
|
UNKNOWN_ALGORITHM,
|
|
BASE64_ENCODING_ERROR,
|
|
INCOMPATIBLE_CRYPTO_LIBRARY,
|
|
INCOMPATIBLE_LIBTASN1_LIBRARY,
|
|
OPENPGP_KEYRING_ERROR,
|
|
X509_UNSUPPORTED_OID,
|
|
RANDOM_FAILED,
|
|
BASE64_UNEXPECTED_HEADER_ERROR,
|
|
OPENPGP_SUBKEY_ERROR,
|
|
CRYPTO_ALREADY_REGISTERED,
|
|
HANDSHAKE_TOO_LARGE,
|
|
UNIMPLEMENTED_FEATURE,
|
|
APPLICATION_ERROR_MAX, // -65000
|
|
APPLICATION_ERROR_MIN; // -65500
|
|
|
|
[CCode (cname = "gnutls_error_is_fatal")]
|
|
public bool is_fatal();
|
|
|
|
[CCode (cname = "gnutls_perror")]
|
|
public void print();
|
|
|
|
[CCode (cname = "gnutls_strerror")]
|
|
public unowned string to_string();
|
|
}
|
|
|
|
public void throw_if_error(int err_int) throws GLib.Error {
|
|
ErrorCode error = (ErrorCode)err_int;
|
|
if (error != ErrorCode.SUCCESS) {
|
|
throw new GLib.Error(-1, error, "%s%s", error.to_string(), error.is_fatal() ? " fatal" : "");
|
|
}
|
|
}
|
|
} |