Move DLTS-SRTP into libdino

8 files changed, 1076 insertions, 2 deletions

diff --git a/libdino/meson.build b/libdino/meson.build
index 5c7c20c4..67ac6a83 100644
--- a/libdino/meson.build
+++ b/libdino/meson.build
@@ -19,6 +19,7 @@ sources = files(
     'src/dbus/upower.vala',
     'src/crypto/cipher.vala',
     'src/crypto/cipher_converter.vala',
+    'src/crypto/dtls_srtp.vala',
     'src/crypto/error.vala',
     'src/crypto/srtp.vala',
     'src/entity/account.vala',
@@ -92,15 +93,18 @@ sources = files(
 sources += [version_c]
 
 if crypto_backend == 'gnu'
-    dependencies += [ dep_libgcrypt ]
+    dependencies += [ dep_libgcrypt, dep_gnutls ]
     sources += files(
         'src/crypto/gnu/cipher.vala',
+        'src/crypto/gnu/dtls_srtp.vala',
         'src/crypto/gnu/utils.vala',
     )
 elif crypto_backend == 'openssl'
     dependencies += [ dep_openssl ]
     sources += files(
         'src/crypto/openssl/cipher.vala',
+        'src/crypto/openssl/dtls_srtp.vala',
+        'src/crypto/openssl/utils.c',
         'src/crypto/openssl/utils.vala',
     )
 endif
diff --git a/libdino/src/crypto/dtls_srtp.vala b/libdino/src/crypto/dtls_srtp.vala
new file mode 100644
index 00000000..884f1a43
--- /dev/null
+++ b/libdino/src/crypto/dtls_srtp.vala
@@ -0,0 +1,146 @@
+namespace Dino.Crypto.DtlsSrtp {
+
+public abstract class CredentialsCapsule : Object {
+    public uint8[] own_fingerprint;
+}
+
+public abstract class AbstractHandler {
+
+    public signal void send_data(uint8[] data);
+
+    public bool ready { get {
+        return srtp_session.has_encrypt && srtp_session.has_decrypt;
+    }}
+
+    public Mode mode { get; set; default = Mode.CLIENT; }
+    public uint8[] own_fingerprint { get; private set; }
+    public uint8[] peer_fingerprint { get; set; }
+    public string peer_fp_algo { get; set; }
+
+    protected CredentialsCapsule credentials;
+    protected Cond buffer_cond = Cond();
+    protected Mutex buffer_mutex = Mutex();
+    protected Gee.LinkedList<Bytes> buffer_queue = new Gee.LinkedList<Bytes>();
+
+    protected bool running = false;
+    protected bool stop = false;
+    protected bool restart = false;
+
+    protected Crypto.Srtp.Session srtp_session = new Crypto.Srtp.Session();
+
+    protected AbstractHandler.with_cert(CredentialsCapsule creds) {
+        this.credentials = creds;
+        this.own_fingerprint = creds.own_fingerprint;
+    }
+
+    public uint8[]? process_incoming_data(uint component_id, uint8[] data) throws Crypto.Error {
+        if (data[0] >= 128) {
+            if (!srtp_session.has_decrypt) {
+                debug("Received data before SRTP session is ready, dropping.");
+                return null;
+            }
+            if (component_id == 1) {
+                if (data.length >= 2 && data[1] >= 192 && data[1] < 224) {
+                    return srtp_session.decrypt_rtcp(data);
+                }
+                return srtp_session.decrypt_rtp(data);
+            }
+            if (component_id == 2) return srtp_session.decrypt_rtcp(data);
+        }
+        if (component_id == 1 && data.length >= 1 && (data[0] >= 20 && data[0] < 64)) {
+            on_data_rec(data);
+            return null;
+        }
+        debug("Dropping unknown data from component %u", component_id);
+        return null;
+    }
+
+    public uint8[]? process_outgoing_data(uint component_id, uint8[] data) throws Crypto.Error {
+        if (srtp_session.has_encrypt) {
+            if (component_id == 1) {
+                if (data.length >= 2 && data[1] >= 192 && data[1] < 224) {
+                    return srtp_session.encrypt_rtcp(data);
+                }
+                return srtp_session.encrypt_rtp(data);
+            }
+            if (component_id == 2) return srtp_session.encrypt_rtcp(data);
+        }
+        return null;
+    }
+
+    public void on_data_rec(owned uint8[] data) {
+        buffer_mutex.lock();
+        buffer_queue.add(new Bytes.take(data));
+        buffer_cond.signal();
+        buffer_mutex.unlock();
+    }
+
+    public void stop_dtls_connection() {
+        buffer_mutex.lock();
+        stop = true;
+        buffer_cond.signal();
+        buffer_mutex.unlock();
+    }
+
+    protected Bytes get_buffer_if_present () {
+        buffer_mutex.lock();
+        if (buffer_queue.size == 0) {
+            buffer_mutex.unlock();
+            return null;
+        }
+        Bytes res = buffer_queue.remove_at(0);
+        buffer_mutex.unlock();
+        return res;
+    }
+
+    public async Xmpp.Xep.Jingle.ContentEncryption? setup_dtls_connection() {
+        MainContext context = MainContext.current_source().get_context();
+        var thread = new Thread<Xmpp.Xep.Jingle.ContentEncryption>("dtls-connection", () => {
+            // Check we can start working on the thread
+            buffer_mutex.lock();
+            if (stop) {
+                restart = true;
+                buffer_mutex.unlock();
+                return null;
+            }
+            if (running || ready) {
+                buffer_mutex.unlock();
+                return null;
+            }
+            running = true;
+            restart = false;
+            buffer_mutex.unlock();
+
+            // Actual work
+            var res = setup_dtls_connection_thread();
+
+            // Callback
+            Source source = new IdleSource();
+            source.set_callback(setup_dtls_connection.callback);
+            source.attach(context);
+            return res;
+        });
+        yield;
+        return thread.join();
+    }
+
+    protected abstract Xmpp.Xep.Jingle.ContentEncryption? setup_dtls_connection_thread();
+}
+
+private string format_fingerprint(uint8[] fingerprint) {
+    var sb = new StringBuilder();
+    for (int i = 0; i < fingerprint.length; i++) {
+        sb.append("%02X".printf(fingerprint[i]));
+        if (i < fingerprint.length - 1) {
+            sb.append(":");
+        }
+    }
+    return sb.str;
+}
+
+
+public enum Mode {
+    CLIENT, SERVER
+}
+
+}
diff --git a/libdino/src/crypto/gnu/dtls_srtp.vala b/libdino/src/crypto/gnu/dtls_srtp.vala
new file mode 100644
index 00000000..f6f0a24e
--- /dev/null
+++ b/libdino/src/crypto/gnu/dtls_srtp.vala
@@ -0,0 +1,245 @@
+using GnuTLS;
+
+namespace Dino.Crypto.DtlsSrtp {
+
+public class CredentialsCapsuleGnuTLS : CredentialsCapsule {
+    internal X509.Certificate[] own_cert;
+    internal X509.PrivateKey private_key;
+}
+
+private uint8[] get_fingerprint(X509.Certificate certificate, DigestAlgorithm digest_algo) {
+    uint8[] buf = new uint8[512];
+    size_t buf_out_size = 512;
+    certificate.get_fingerprint(digest_algo, buf, ref buf_out_size);
+
+    uint8[] ret = new uint8[buf_out_size];
+    for (int i = 0; i < buf_out_size; i++) {
+        ret[i] = buf[i];
+    }
+    return ret;
+}
+
+public CredentialsCapsule generate_credentials () throws GLib.Error {
+    int err = 0;
+
+    X509.PrivateKey private_key = X509.PrivateKey.create ();
+    err = private_key.generate (PKAlgorithm.ECDSA, 256);
+    throw_if_error (err);
+
+    var start_time = new DateTime.now_local().add_days(-1);
+    var end_time = start_time.add_days (2);
+
+    X509.Certificate cert = X509.Certificate.create ();
+    cert.set_key (private_key);
+    cert.set_version (1);
+    cert.set_activation_time ((time_t) start_time.to_unix ());
+    cert.set_expiration_time ((time_t) end_time.to_unix ());
+
+    uint32 serial = 1;
+    cert.set_serial (&serial, sizeof(uint32));
+
+    cert.sign (cert, private_key);
+
+    uint8[] own_fingerprint = get_fingerprint (cert, DigestAlgorithm.SHA256);
+    X509.Certificate[] own_cert = new X509.Certificate[] { (owned)cert };
+
+    var creds = new CredentialsCapsuleGnuTLS();
+    creds.own_fingerprint = own_fingerprint;
+    creds.own_cert = (owned) own_cert;
+    creds.private_key = (owned) private_key;
+
+    return creds;
+}
+
+public class Handler : AbstractHandler {
+
+    public Handler.with_cert(CredentialsCapsule creds) {
+        base.with_cert(creds);
+    }
+
+    protected override Xmpp.Xep.Jingle.ContentEncryption? setup_dtls_connection_thread() {
+        InitFlags server_or_client = mode == Mode.SERVER ? InitFlags.SERVER : InitFlags.CLIENT;
+        debug("Setting up DTLS connection using GnuTLS. We're %s", mode.to_string());
+
+        CertificateCredentials cert_cred = CertificateCredentials.create();
+        int err = cert_cred.set_x509_key(((CredentialsCapsuleGnuTLS)credentials).own_cert, ((CredentialsCapsuleGnuTLS)credentials).private_key);
+        throw_if_error(err);
+
+        Session? session = Session.create(server_or_client | InitFlags.DATAGRAM);
+        session.enable_heartbeat(1);
+        session.set_srtp_profile_direct("SRTP_AES128_CM_HMAC_SHA1_80");
+        session.set_credentials(GnuTLS.CredentialsType.CERTIFICATE, cert_cred);
+        session.server_set_request(CertificateRequest.REQUEST);
+        session.set_priority_from_string("NORMAL:!VERS-TLS-ALL:+VERS-DTLS-ALL:+CTYPE-CLI-X509");
+
+        session.set_transport_pointer(this);
+        session.set_pull_function(pull_function);
+        session.set_pull_timeout_function(pull_timeout_function);
+        session.set_push_function(push_function);
+        session.set_verify_function(verify_function);
+
+        DateTime maximum_time = new DateTime.now_utc().add_seconds(20);
+        do {
+            err = session.handshake();
+
+            DateTime current_time = new DateTime.now_utc();
+            if (maximum_time.compare(current_time) < 0) {
+                warning("DTLS handshake timeouted");
+                err = ErrorCode.APPLICATION_ERROR_MIN + 1;
+                break;
+            }
+            if (stop) {
+                debug("DTLS handshake stopped");
+                err = ErrorCode.APPLICATION_ERROR_MIN + 2;
+                break;
+            }
+        } while (err < 0 && !((ErrorCode)err).is_fatal());
+
+        buffer_mutex.lock();
+        if (stop) {
+            stop = false;
+            running = false;
+            bool restart = restart;
+            buffer_mutex.unlock();
+            if (restart) {
+                debug("Restarting DTLS handshake");
+                return setup_dtls_connection_thread();
+            }
+            return null;
+        }
+        buffer_mutex.unlock();
+        if (err != ErrorCode.SUCCESS) {
+            warning("DTLS handshake failed: %s", ((ErrorCode)err).to_string());
+            return null;
+        }
+
+        uint8[] km = new uint8[150];
+        Datum? client_key, client_salt, server_key, server_salt;
+        session.get_srtp_keys(km, km.length, out client_key, out client_salt, out server_key, out server_salt);
+        if (client_key == null || client_salt == null || server_key == null || server_salt == null) {
+            warning("SRTP client/server key/salt null");
+        }
+
+        debug("Finished DTLS connection. We're %s", mode.to_string());
+        if (mode == Mode.SERVER) {
+            srtp_session.set_encryption_key(Crypto.Srtp.AES_CM_128_HMAC_SHA1_80, server_key.extract(), server_salt.extract());
+            srtp_session.set_decryption_key(Crypto.Srtp.AES_CM_128_HMAC_SHA1_80, client_key.extract(), client_salt.extract());
+        } else {
+            srtp_session.set_encryption_key(Crypto.Srtp.AES_CM_128_HMAC_SHA1_80, client_key.extract(), client_salt.extract());
+            srtp_session.set_decryption_key(Crypto.Srtp.AES_CM_128_HMAC_SHA1_80, server_key.extract(), server_salt.extract());
+        }
+        return new Xmpp.Xep.Jingle.ContentEncryption(Xmpp.Xep.JingleIceUdp.DTLS_NS_URI, "DTLS-SRTP", credentials.own_fingerprint, peer_fingerprint);
+    }
+
+    private static ssize_t pull_function(void* transport_ptr, uint8[] buffer) {
+        Handler self = transport_ptr as Handler;
+
+        self.buffer_mutex.lock();
+        while (self.buffer_queue.size == 0) {
+            self.buffer_cond.wait(self.buffer_mutex);
+            if (self.stop) {
+                self.buffer_mutex.unlock();
+                debug("DTLS handshake pull_function stopped");
+                return -1;
+            }
+        }
+        Bytes data = self.buffer_queue.remove_at(0);
+        self.buffer_mutex.unlock();
+
+        uint8[] data_uint8 = Bytes.unref_to_data((owned) data);
+        Memory.copy(buffer, data_uint8, data_uint8.length);
+
+        // The callback should return 0 on connection termination, a positive number indicating the number of bytes received, and -1 on error.
+        return (ssize_t)data_uint8.length;
+    }
+
+    private static int pull_timeout_function(void* transport_ptr, uint ms) {
+        Handler self = transport_ptr as Handler;
+
+        int64 end_time = get_monotonic_time() + ms * 1000;
+
+        self.buffer_mutex.lock();
+        while (self.buffer_queue.size == 0) {
+            self.buffer_cond.wait_until(self.buffer_mutex, end_time);
+            if (self.stop) {
+                self.buffer_mutex.unlock();
+                debug("DTLS handshake pull_timeout_function stopped");
+                return -1;
+            }
+
+            if (get_monotonic_time() > end_time) {
+                self.buffer_mutex.unlock();
+                return 0;
+            }
+        }
+        self.buffer_mutex.unlock();
+
+        // The callback should return 0 on timeout, a positive number if data can be received, and -1 on error.
+        return 1;
+    }
+
+    private static ssize_t push_function(void* transport_ptr, uint8[] buffer) {
+        Handler self = transport_ptr as Handler;
+        self.send_data(buffer);
+
+        // The callback should return a positive number indicating the bytes sent, and -1 on error.
+        return (ssize_t)buffer.length;
+    }
+
+    private static int verify_function(Session session) {
+        Handler self = session.get_transport_pointer() as Handler;
+        try {
+            bool valid = self.verify_peer_cert(session);
+            if (!valid) {
+                warning("DTLS certificate invalid. Aborting handshake.");
+                return 1;
+            }
+        } catch (Error e) {
+            warning("Error during DTLS certificate validation: %s. Aborting handshake.", e.message);
+            return 1;
+        }
+
+        // The callback function should return 0 for the handshake to continue or non-zero to terminate.
+        return 0;
+    }
+
+    private bool verify_peer_cert(Session session) throws GLib.Error {
+        unowned Datum[] cert_datums = session.get_peer_certificates();
+        if (cert_datums.length == 0) {
+            warning("No peer certs");
+            return false;
+        }
+        if (cert_datums.length > 1) warning("More than one peer cert");
+
+        X509.Certificate peer_cert = X509.Certificate.create();
+        peer_cert.import(ref cert_datums[0], CertificateFormat.DER);
+
+        DigestAlgorithm algo;
+        switch (peer_fp_algo) {
+            case "sha-256":
+                algo = DigestAlgorithm.SHA256;
+                break;
+            default:
+                warning("Unkown peer fingerprint algorithm: %s", peer_fp_algo);
+                return false;
+        }
+
+        uint8[] real_peer_fp = get_fingerprint(peer_cert, algo);
+
+        if (real_peer_fp.length != this.peer_fingerprint.length) {
+            warning("Fingerprint lengths not equal %i vs %i", real_peer_fp.length, peer_fingerprint.length);
+            return false;
+        }
+
+        for (int i = 0; i < real_peer_fp.length; i++) {
+            if (real_peer_fp[i] != this.peer_fingerprint[i]) {
+                warning("First cert in peer cert list doesn't equal advertised one: %s vs %s", format_fingerprint(real_peer_fp), format_fingerprint(peer_fingerprint));
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+
+}
\ No newline at end of file
diff --git a/libdino/src/crypto/openssl/dtls_srtp.vala b/libdino/src/crypto/openssl/dtls_srtp.vala
new file mode 100644
index 00000000..192f0da2
--- /dev/null
+++ b/libdino/src/crypto/openssl/dtls_srtp.vala
@@ -0,0 +1,202 @@
+using OpenSSL;
+
+namespace Dino.Crypto.DtlsSrtp {
+
+public class CredentialsCapsuleOpenSSL : CredentialsCapsule {
+    internal X509.Certificate own_cert;
+    internal EVP.Key private_key;
+}
+
+public CredentialsCapsule generate_credentials () throws GLib.Error {
+    EVP.Key key = new EVP.Key.generate_ecdsa ("prime256v1");
+
+    var start_time = new DateTime.now_local().add_days(-1);
+    var end_time = start_time.add_days (2);
+
+    X509.Certificate cert = new X509.Certificate ();
+    cert.set_public_key (key);
+    cert.set_version (1);
+    cert.not_before.set ((time_t) start_time.to_unix ());
+    cert.not_after.set ((time_t) end_time.to_unix ());
+    cert.serial_number.set (1);
+
+    cert.sign (key, EVP.sha256 ());
+
+    CredentialsCapsuleOpenSSL credentials = new CredentialsCapsuleOpenSSL ();
+    credentials.own_fingerprint = cert.digest (EVP.sha256 ());
+    credentials.own_cert = (owned) cert;
+    credentials.private_key = (owned) key;
+    return credentials;
+}
+
+public class Handler : AbstractHandler {
+
+    public Handler.with_cert (CredentialsCapsule creds) {
+        base.with_cert (creds);
+    }
+
+    protected override Xmpp.Xep.Jingle.ContentEncryption? setup_dtls_connection_thread () {
+        debug("Setting up DTLS connection using OpenSSL. We're %s", mode.to_string());
+        SSL.Context context = new SSL.Context (mode == Mode.SERVER ? SSL.Method.DTLS_SERVER : SSL.Method.DTLS_CLIENT);
+        context.set_tlsext_use_srtp ("SRTP_AES128_CM_SHA1_80");
+        context.use_certificate (((CredentialsCapsuleOpenSSL) credentials).own_cert);
+        context.use_private_key (((CredentialsCapsuleOpenSSL) credentials).private_key);
+        SSL session = new SSL (context);
+        BIO<Handler> bio = new BIO<Handler>(get_handler_based_bio_method());
+        bio.data = this;
+        session.rbio = bio;
+        session.wbio = bio;
+
+        DateTime maximum_time = new DateTime.now_utc().add_seconds(20);
+        int err = 0;
+        if (mode == Mode.SERVER) {
+            session.set_accept_state ();
+        } else {
+            session.set_connect_state ();
+        }
+        do {
+            try {
+                SSL.Error ret = session.do_handshake();
+                switch (ret) {
+                    case SSL.Error.NONE:
+                        err = 1;
+                        break;
+                    case SSL.Error.WANT_READ:
+                        debug ("DTLS wants to read, but nothing in queue, wait for buffer");
+                        buffer_mutex.lock();
+                        if (buffer_queue.size == 0) {
+                            buffer_cond.wait_until(buffer_mutex, get_monotonic_time() + maximum_time.difference(new DateTime.now_utc()));
+                        }
+                        buffer_mutex.unlock();
+                        err = -1;
+                        break;
+                    default:
+                        warning ("DTLS Error: %s", @"$ret");
+                        err = 4;
+                        break;
+                }
+            } catch (Error e) {
+                warning ("DTLS Error: %s", e.message);
+                err = e.code;
+            }
+
+            DateTime current_time = new DateTime.now_utc();
+            if (maximum_time.compare(current_time) < 0) {
+                debug ("DTLS handshake timeouted");
+                err = 2;
+                break;
+            }
+            if (stop) {
+                debug ("DTLS handshake stopped");
+                err = 3;
+                break;
+            }
+        } while (err < 0);
+
+        buffer_mutex.lock();
+        if (stop) {
+            stop = false;
+            running = false;
+            bool restart = restart;
+            buffer_mutex.unlock();
+            if (restart) {
+                debug ("Restarting DTLS handshake");
+                return setup_dtls_connection_thread();
+            }
+            return null;
+        }
+        buffer_mutex.unlock();
+        if (err != 1) {
+            debug ("DTLS handshake failed");
+            return null;
+        }
+
+        // TODO: Check peer certificate
+
+        uint8[] km = new uint8[60];
+        session.export_keying_material (km, "EXTRACTOR-dtls_srtp");
+        uint8[] client_key = km[0:16];
+        uint8[] server_key = km[16:32];
+        uint8[] client_salt = km[32:46];
+        uint8[] server_salt = km[46:60];
+
+        debug ("Finished DTLS connection. We're %s", mode.to_string());
+        if (mode == Mode.SERVER) {
+            srtp_session.set_encryption_key (Crypto.Srtp.AES_CM_128_HMAC_SHA1_80, server_key, server_salt);
+            srtp_session.set_decryption_key (Crypto.Srtp.AES_CM_128_HMAC_SHA1_80, client_key, client_salt);
+        } else {
+            srtp_session.set_encryption_key (Crypto.Srtp.AES_CM_128_HMAC_SHA1_80, client_key, client_salt);
+            srtp_session.set_decryption_key (Crypto.Srtp.AES_CM_128_HMAC_SHA1_80, server_key, server_salt);
+        }
+        return new Xmpp.Xep.Jingle.ContentEncryption (Xmpp.Xep.JingleIceUdp.DTLS_NS_URI, "DTLS-SRTP", credentials.own_fingerprint, peer_fingerprint);
+    }
+
+    private int read_impl (BIO<Handler> bio, uint8[] out_buf) {
+        Bytes data = get_buffer_if_present ();
+        if (data == null) {
+            if (!stop) {
+                debug ("No pending buffer in queue, but end not reached yet, set_retry_read");
+                bio.set_retry_read ();
+            }
+            return -1;
+        }
+        if (data.length > out_buf.length) {
+            warning ("Buffer in queue does not fit in out_buf");
+            return -1;
+        }
+        debug ("Read %d bytes from queue", data.length);
+
+        uint8[] data_uint8 = Bytes.unref_to_data((owned) data);
+        Memory.copy (out_buf, data_uint8, data_uint8.length);
+        bio.clear_retry_flags ();
+        return data_uint8.length;
+    }
+
+    private int write_impl (BIO<Handler> bio, uint8[] buf) {
+        debug ("Write %d bytes to network", buf.length);
+        send_data (buf);
+        return buf.length;
+    }
+
+    private long ctrl_impl (BIO<Handler> bio, BIO.ControlCommand cmd, long num, void* ptr) {
+        switch (cmd) {
+            case BIO.ControlCommand.FLUSH:
+                // Datagrams are sent out immediately
+                return 1;
+            case BIO.ControlCommand.DGRAM_SET_NEXT_TIMEOUT:
+                // Datagrams are sent out immediately
+                return 1;
+            case BIO.ControlCommand.DGRAM_GET_MTU_OVERHEAD:
+                // Just some safe estimate
+                return 70;
+            case BIO.ControlCommand.DGRAM_QUERY_MTU:
+                // Just some safe estimate
+                return 1200;
+            case BIO.ControlCommand.WPENDING:
+                // Datagrams are sent out immediately
+                return 0;
+            case BIO.ControlCommand.POP:
+            case BIO.ControlCommand.PUSH:
+                // Ignored
+                return 0;
+            default:
+                warning (@"Unimplemented ctrl cmd:$cmd, num:$num");
+                return 0;
+        }
+    }
+
+    private static BIO.Method<Handler> _handler_based_bio_method_instance = null;
+
+    private static unowned BIO.Method<Handler> get_handler_based_bio_method () {
+        if (_handler_based_bio_method_instance != null) return _handler_based_bio_method_instance;
+        _handler_based_bio_method_instance = new BIO.Method<Handler> (BIO.Type.SOURCE_SINK | BIO.Type.DGRAM, "Dino DTLS Handler BIO");
+        _handler_based_bio_method_instance.read = (bio, out_buf) => bio.data.read_impl (bio, out_buf);
+        _handler_based_bio_method_instance.write = (bio, buf) => bio.data.write_impl (bio, buf);
+        _handler_based_bio_method_instance.ctrl = (bio, cmd, num, ptr) => bio.data.ctrl_impl (bio, cmd, num, ptr);
+        return _handler_based_bio_method_instance;
+    }
+}
+
+
+
+}
\ No newline at end of file
diff --git a/libdino/src/crypto/openssl/utils.c b/libdino/src/crypto/openssl/utils.c
new file mode 100644
index 00000000..1a84f642
--- /dev/null
+++ b/libdino/src/crypto/openssl/utils.c
@@ -0,0 +1,49 @@
+#include "utils.h"
+#include <openssl/opensslv.h>
+#include <openssl/ec.h>
+
+#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x30000000L
+// This is for OpenSSL 3.0.0 and newer
+
+EVP_PKEY *EVP_PKEY_new_generate_ecdsa (const char* curve) {
+    // Generate EVP_PKEY directly
+    EVP_PKEY *pkey = EVP_EC_gen (curve);
+    return pkey;
+}
+
+#else
+// This is for OpenSSL before 3.0.0 and forks of earlier OpenSSL versions like LibreSSL
+
+EVP_PKEY *EVP_PKEY_new_generate_ecdsa (const char* curve) {
+    // Get NID from curve name
+    int nid = OBJ_sn2nid (curve);
+    if (nid == NID_undef) return NULL;
+
+    // Create EC_KEY
+    EC_KEY *ec_key = EC_KEY_new_by_curve_name (nid);
+    if (!ec_key) return NULL;
+
+    // Generate key
+    if (!EC_KEY_generate_key (ec_key)) {
+        EC_KEY_free (ec_key);
+        return NULL;
+    }
+
+    // Create EVP_PKEY
+    EVP_PKEY *pkey = EVP_PKEY_new ();
+    if (!pkey) {
+        EC_KEY_free (ec_key);
+        return NULL;
+    }
+
+    // Assign EC_KEY to EVP_PKEY
+    if (!EVP_PKEY_assign_EC_KEY (pkey, ec_key)) {
+        EC_KEY_free (ec_key);
+        return NULL;
+    }
+
+    // EVP_PKEY_assign_EC_KEY takes ownership of ec_key, no need to free it explicitly
+    return pkey;
+}
+
+#endif
diff --git a/libdino/src/crypto/openssl/utils.h b/libdino/src/crypto/openssl/utils.h
new file mode 100644
index 00000000..bcc6f53a
--- /dev/null
+++ b/libdino/src/crypto/openssl/utils.h
@@ -0,0 +1,8 @@
+#ifndef DINO_OPENSSL_UTILS_H
+#define DINO_OPENSSL_UTILS_H
+
+#include <openssl/evp.h>
+
+EVP_PKEY *EVP_PKEY_new_generate_ecdsa (const char* curve);
+
+#endif //DINO_OPENSSL_UTILS_H
\ No newline at end of file
diff --git a/libdino/vapi/gnutls.vapi b/libdino/vapi/gnutls.vapi
new file mode 100644
index 00000000..86a8c401
--- /dev/null
+++ b/libdino/vapi/gnutls.vapi
@@ -0,0 +1,420 @@
+[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,
+        ECDSA;
+    }
+
+    [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" : "");
+        }
+    }
+}
\ No newline at end of file
diff --git a/libdino/vapi/openssl.vapi b/libdino/vapi/openssl.vapi
index 87693d37..57e4022c 100644
--- a/libdino/vapi/openssl.vapi
+++ b/libdino/vapi/openssl.vapi
@@ -86,7 +86,7 @@ namespace OpenSSL {
         [CCode (cname = "EVP_PKEY", lower_case_cprefix = "EVP_PKEY_", cprefix = "EVP_PKEY_", ref_function = "EVP_PKEY_up_ref", ref_function_void = true, unref_function = "EVP_PKEY_free")]
         public class Key {
             public Key ();
-            [CCode (cheader_filename = "openssl_utils.h")]
+            [CCode (cheader_filename = "crypto/openssl/utils.h")]
             public Key.generate_ecdsa (string curve);
         }
         [Compact]