Add support for MbedTLS

9 files changed, 626 insertions, 202 deletions

diff --git a/README.md b/README.md
index 71d7754..2f561aa 100644
--- a/README.md
+++ b/README.md
@@ -94,10 +94,19 @@ make
 sudo make install
 ```
 
-By default, OpenSSL will be used. If you prefer GnuTLS, configure with
-`--disable-openssl` like this:
+By default, OpenSSL will be used as TLS/SSL library. If you prefer GnuTLS,
+configure with `--with-gnutls` like this:
 ```bash
-./autogen.sh --disable-openssl
+./autogen.sh --with-gnutls
+```
+
+MbedTLS is also supported and can be enabled by passing `--with-mbedtls` to
+configure. If mbedTLS is not installed in a default location, you need to set
+the environment variables `mbedtls_INCLUDES` to the path that contains the
+MbedTLS headers and `mbedtls_LIBDIR` to set the library path. Optionally,
+`mbedtls_LIBS` can be used to set the library names directly. Example:
+```bash
+./autogen.sh --with-mbedtls mbedtls_INCLUDES=/opt/local/include mbedtls_LIBDIR=/opt/local/lib
 ```
 
 ## Usage
@@ -179,4 +188,4 @@ iPadOS, tvOS, watchOS, and macOS are trademarks of Apple Inc.
 This project is an independent software and has not been authorized, sponsored,
 or otherwise approved by Apple Inc.
 
-README Updated on: 2020-06-12
+README Updated on: 2021-07-27
diff --git a/common/userpref.c b/common/userpref.c
index a5aa7cb..0c6050f 100644
--- a/common/userpref.c
+++ b/common/userpref.c
@@ -2,6 +2,7 @@
  * userpref.c
  * contains methods to access user specific certificates IDs and more.
  *
+ * Copyright (c) 2013-2021 Nikias Bassen, All Rights Reserved.
  * Copyright (c) 2013-2014 Martin Szulecki All Rights Reserved.
  * Copyright (c) 2008 Jonathan Beck All Rights Reserved.
  *
@@ -36,7 +37,7 @@
 #endif
 #include <unistd.h>
 #include <usbmuxd.h>
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
 #include <openssl/bn.h>
 #include <openssl/pem.h>
 #include <openssl/rsa.h>
@@ -47,12 +48,20 @@
 #define X509_set1_notBefore X509_set_notBefore
 #define X509_set1_notAfter X509_set_notAfter
 #endif
-#else
+#elif defined(HAVE_GNUTLS)
 #include <gnutls/gnutls.h>
 #include <gnutls/crypto.h>
 #include <gnutls/x509.h>
 #include <gcrypt.h>
 #include <libtasn1.h>
+#elif defined(HAVE_MBEDTLS)
+#include <mbedtls/ssl.h>
+#include <mbedtls/entropy.h>
+#include <mbedtls/ctr_drbg.h>
+#include <mbedtls/asn1write.h>
+#include <mbedtls/oid.h>
+#else
+#error No supported TLS/SSL library enabled
 #endif
 
 #include <dirent.h>
@@ -68,7 +77,7 @@
 #include "debug.h"
 #include "utils.h"
 
-#ifndef HAVE_OPENSSL
+#if defined(HAVE_GNUTLS)
 const ASN1_ARRAY_TYPE pkcs1_asn1_tab[] = {
         {"PKCS1", 536872976, 0},
         {0, 1073741836, 0},
@@ -343,7 +352,7 @@ userpref_error_t userpref_delete_pair_record(const char *udid)
         return res == 0 ? USERPREF_E_SUCCESS: USERPREF_E_UNKNOWN_ERROR;
 }
 
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
 static int X509_add_ext_helper(X509 *cert, int nid, char *value)
 {
         X509_EXTENSION *ex;
@@ -364,6 +373,31 @@ static int X509_add_ext_helper(X509 *cert, int nid, char *value)
 
         return 1;
 }
+#elif defined(HAVE_MBEDTLS)
+static int _mbedtls_x509write_crt_set_basic_constraints_critical(mbedtls_x509write_cert *ctx, int is_ca, int max_pathlen)
+{
+        int ret;
+        unsigned char buf[9];
+        unsigned char *c = buf + sizeof(buf);
+        size_t len = 0;
+
+        memset( buf, 0, sizeof(buf) );
+
+        if (is_ca && max_pathlen > 127)
+                return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
+
+        if (is_ca) {
+                if (max_pathlen >= 0) {
+                        MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_int( &c, buf, max_pathlen ) );
+                }
+                MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_bool( &c, buf, 1 ) );
+        }
+
+        MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &c, buf, len ) );
+        MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &c, buf, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) );
+
+        return mbedtls_x509write_crt_set_extension( ctx, MBEDTLS_OID_BASIC_CONSTRAINTS, MBEDTLS_OID_SIZE( MBEDTLS_OID_BASIC_CONSTRAINTS ), 1, buf + sizeof(buf) - len, len );
+}
 #endif
 
 /**
@@ -390,7 +424,7 @@ userpref_error_t pair_record_generate_keys_and_certs(plist_t pair_record, key_da
 
         debug_info("Generating keys and certificates...");
 
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
         BIGNUM *e = BN_new();
         RSA* root_keypair = RSA_new();
         RSA* host_keypair = RSA_new();
@@ -579,7 +613,7 @@ userpref_error_t pair_record_generate_keys_and_certs(plist_t pair_record, key_da
 
         X509_free(host_cert);
         X509_free(root_cert);
-#else
+#elif defined(HAVE_GNUTLS)
         gnutls_x509_privkey_t root_privkey;
         gnutls_x509_crt_t root_cert;
         gnutls_x509_privkey_t host_privkey;
@@ -749,6 +783,211 @@ userpref_error_t pair_record_generate_keys_and_certs(plist_t pair_record, key_da
         gnutls_free(exponent.data);
 
         gnutls_free(der_pub_key.data);
+#elif defined(HAVE_MBEDTLS)
+        time_t now = time(NULL);
+        struct tm* timestamp = gmtime(&now);
+        char notbefore[16];
+        strftime(notbefore, sizeof(notbefore), "%Y%m%d%H%M%S", timestamp);
+        time_t then = now + 60 * 60 * 24 * 365 * 10;
+        char notafter[16];
+        timestamp = gmtime(&then);
+        strftime(notafter, sizeof(notafter), "%Y%m%d%H%M%S", timestamp);
+
+        mbedtls_mpi sn;
+        mbedtls_mpi_init(&sn);
+        mbedtls_mpi_lset(&sn, 1); /* 0 doesn't work, so we have to use 1 (like GnuTLS) */
+
+        mbedtls_ctr_drbg_context ctr_drbg;
+        mbedtls_ctr_drbg_init(&ctr_drbg);
+
+        mbedtls_pk_context root_pkey;
+        mbedtls_pk_init(&root_pkey);
+
+        mbedtls_pk_context host_pkey;
+        mbedtls_pk_init(&host_pkey);
+
+        mbedtls_pk_context dev_public_key;
+        mbedtls_pk_init(&dev_public_key);
+
+        mbedtls_entropy_context entropy;
+        mbedtls_entropy_init(&entropy);
+
+        mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)"limd", 4);
+
+        /* ----- root key & cert ----- */
+        ret = mbedtls_pk_setup(&root_pkey, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA));
+        if (ret != 0) {
+                debug_info("mbedtls_pk_setup returned -0x%04x", -ret);
+                goto cleanup;
+        }
+
+        ret = mbedtls_rsa_gen_key(mbedtls_pk_rsa(root_pkey), mbedtls_ctr_drbg_random, &ctr_drbg, 2048, 65537);
+        if (ret != 0) {
+                debug_info("mbedtls_rsa_gen_key returned -0x%04x", -ret);
+                goto cleanup;
+        }
+
+        mbedtls_x509write_cert cert;
+        mbedtls_x509write_crt_init(&cert);
+
+        /* set serial number */
+        mbedtls_x509write_crt_set_serial(&cert, &sn);
+
+        /* set version */
+        mbedtls_x509write_crt_set_version(&cert, 2);
+
+        /* set x509v3 basic constraints */
+        _mbedtls_x509write_crt_set_basic_constraints_critical(&cert, 1, -1);
+
+        /* use root public key for root cert */
+        mbedtls_x509write_crt_set_subject_key(&cert, &root_pkey);
+
+        /* set x509v3 subject key identifier */
+        mbedtls_x509write_crt_set_subject_key_identifier(&cert);
+
+        /* set key validity */
+        mbedtls_x509write_crt_set_validity(&cert, notbefore, notafter);
+
+        /* sign root cert with root private key */
+        mbedtls_x509write_crt_set_issuer_key(&cert, &root_pkey);
+        mbedtls_x509write_crt_set_md_alg(&cert, MBEDTLS_MD_SHA1);
+
+        unsigned char outbuf[16384];
+
+        /* write root private key */
+        mbedtls_pk_write_key_pem(&root_pkey, outbuf, sizeof(outbuf));
+        root_key_pem.size = strlen((const char*)outbuf);
+        root_key_pem.data = malloc(root_key_pem.size+1);
+        memcpy(root_key_pem.data, outbuf, root_key_pem.size);
+        root_key_pem.data[root_key_pem.size] = '\0';
+
+        /* write root certificate */
+        mbedtls_x509write_crt_pem(&cert, outbuf, sizeof(outbuf), mbedtls_ctr_drbg_random, &ctr_drbg);
+        root_cert_pem.size = strlen((const char*)outbuf);
+        root_cert_pem.data = malloc(root_cert_pem.size+1);
+        memcpy(root_cert_pem.data, outbuf, root_cert_pem.size);
+        root_cert_pem.data[root_cert_pem.size] = '\0';
+
+        mbedtls_x509write_crt_free(&cert);
+
+
+        /* ----- host key & cert ----- */
+        ret = mbedtls_pk_setup(&host_pkey, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA));
+        if (ret != 0) {
+                debug_info("mbedtls_pk_setup returned -0x%04x", -ret);
+                goto cleanup;
+        }
+
+        ret = mbedtls_rsa_gen_key(mbedtls_pk_rsa(host_pkey), mbedtls_ctr_drbg_random, &ctr_drbg, 2048, 65537);
+        if (ret != 0) {
+                debug_info("mbedtls_rsa_gen_key returned -0x%04x", -ret);
+                goto cleanup;
+        }
+
+        mbedtls_x509write_crt_init(&cert);
+
+        /* set serial number */
+        mbedtls_x509write_crt_set_serial(&cert, &sn);
+
+        /* set version */
+        mbedtls_x509write_crt_set_version(&cert, 2);
+
+        /* set x509v3 basic constraints */
+        _mbedtls_x509write_crt_set_basic_constraints_critical(&cert, 0, -1);
+
+        /* use host public key for host cert */
+        mbedtls_x509write_crt_set_subject_key(&cert, &host_pkey);
+
+        /* set x509v3 subject key identifier */
+        mbedtls_x509write_crt_set_subject_key_identifier(&cert);
+
+        /* set x509v3 key usage */
+        mbedtls_x509write_crt_set_key_usage(&cert, MBEDTLS_X509_KU_DIGITAL_SIGNATURE | MBEDTLS_X509_KU_KEY_ENCIPHERMENT);
+
+        /* set key validity */
+        mbedtls_x509write_crt_set_validity(&cert, notbefore, notafter);
+
+        /* sign host cert with root private key */
+        mbedtls_x509write_crt_set_issuer_key(&cert, &root_pkey);
+        mbedtls_x509write_crt_set_md_alg(&cert, MBEDTLS_MD_SHA1);
+
+        /* write host private key */
+        mbedtls_pk_write_key_pem(&host_pkey, outbuf, sizeof(outbuf));
+        host_key_pem.size = strlen((const char*)outbuf);
+        host_key_pem.data = malloc(host_key_pem.size+1);
+        memcpy(host_key_pem.data, outbuf, host_key_pem.size);
+        host_key_pem.data[host_key_pem.size] = '\0';
+
+        /* write host certificate */
+        mbedtls_x509write_crt_pem(&cert, outbuf, sizeof(outbuf), mbedtls_ctr_drbg_random, &ctr_drbg);
+        host_cert_pem.size = strlen((const char*)outbuf);
+        host_cert_pem.data = malloc(host_cert_pem.size+1);
+        memcpy(host_cert_pem.data, outbuf, host_cert_pem.size);
+        host_cert_pem.data[host_cert_pem.size] = '\0';
+
+        mbedtls_x509write_crt_free(&cert);
+
+
+        /* ----- device certificate ----- */
+        unsigned char* pubkey_data = malloc(public_key.size+1);
+        if (!pubkey_data) {
+                debug_info("malloc() failed\n");
+                goto cleanup;
+        }
+        memcpy(pubkey_data, public_key.data, public_key.size);
+        pubkey_data[public_key.size] = '\0';
+
+        int pr = mbedtls_pk_parse_public_key(&dev_public_key, pubkey_data, public_key.size+1);
+        free(pubkey_data);
+        if (pr != 0) {
+                debug_info("Failed to read device public key: -0x%x\n", -pr);
+                goto cleanup;
+        }
+
+        mbedtls_x509write_crt_init(&cert);
+
+        /* set serial number */
+        mbedtls_x509write_crt_set_serial(&cert, &sn);
+
+        /* set version */
+        mbedtls_x509write_crt_set_version(&cert, 2);
+
+        /* set x509v3 basic constraints */
+        _mbedtls_x509write_crt_set_basic_constraints_critical(&cert, 0, -1);
+
+        /* use root public key for dev cert subject key */
+        mbedtls_x509write_crt_set_subject_key(&cert, &dev_public_key);
+
+        /* set x509v3 subject key identifier */
+        mbedtls_x509write_crt_set_subject_key_identifier(&cert);
+
+        /* set x509v3 key usage */
+        mbedtls_x509write_crt_set_key_usage(&cert, MBEDTLS_X509_KU_DIGITAL_SIGNATURE | MBEDTLS_X509_KU_KEY_ENCIPHERMENT);
+
+        /* set key validity */
+        mbedtls_x509write_crt_set_validity(&cert, notbefore, notafter);
+
+        /* sign device certificate with root private key */
+        mbedtls_x509write_crt_set_issuer_key(&cert, &root_pkey);
+        mbedtls_x509write_crt_set_md_alg(&cert, MBEDTLS_MD_SHA1);
+
+        /* write device certificate */
+        mbedtls_x509write_crt_pem(&cert, outbuf, sizeof(outbuf), mbedtls_ctr_drbg_random, &ctr_drbg);
+        dev_cert_pem.size = strlen((const char*)outbuf);
+        dev_cert_pem.data = malloc(dev_cert_pem.size+1);
+        memcpy(dev_cert_pem.data, outbuf, dev_cert_pem.size);
+        dev_cert_pem.data[dev_cert_pem.size] = '\0';
+
+        mbedtls_x509write_crt_free(&cert);
+
+        /* cleanup */
+cleanup:
+        mbedtls_mpi_free(&sn);
+        mbedtls_pk_free(&dev_public_key);
+        mbedtls_entropy_free(&entropy);
+        mbedtls_pk_free(&host_pkey);
+        mbedtls_pk_free(&root_pkey);
+        mbedtls_ctr_drbg_free(&ctr_drbg);
 #endif
 
         /* make sure that we have all we need */
@@ -783,32 +1022,31 @@ userpref_error_t pair_record_generate_keys_and_certs(plist_t pair_record, key_da
  *
  * @return 1 if the key was successfully imported.
  */
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL) || defined(HAVE_MBEDTLS)
 userpref_error_t pair_record_import_key_with_name(plist_t pair_record, const char* name, key_data_t* key)
-#else
+#elif defined(HAVE_GNUTLS)
 userpref_error_t pair_record_import_key_with_name(plist_t pair_record, const char* name, gnutls_x509_privkey_t key)
 #endif
 {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL) || defined(HAVE_MBEDTLS)
         if (!key)
                 return USERPREF_E_SUCCESS;
 #endif
         userpref_error_t ret = USERPREF_E_INVALID_CONF;
 
-#ifdef HAVE_OPENSSL
-                ret = pair_record_get_item_as_key_data(pair_record, name, key);
-#else
-                key_data_t pem = { NULL, 0 };
-                ret = pair_record_get_item_as_key_data(pair_record, name, &pem);
-                if (ret == USERPREF_E_SUCCESS && GNUTLS_E_SUCCESS == gnutls_x509_privkey_import(key, &pem, GNUTLS_X509_FMT_PEM))
-                        ret = USERPREF_E_SUCCESS;
-                else
-                        ret = USERPREF_E_SSL_ERROR;
-
-                if (pem.data)
-                        free(pem.data);
-#endif
+#if defined(HAVE_OPENSSL) || defined(HAVE_MBEDTLS)
+        ret = pair_record_get_item_as_key_data(pair_record, name, key);
+#elif defined(HAVE_GNUTLS)
+        key_data_t pem = { NULL, 0 };
+        ret = pair_record_get_item_as_key_data(pair_record, name, &pem);
+        if (ret == USERPREF_E_SUCCESS && GNUTLS_E_SUCCESS == gnutls_x509_privkey_import(key, &pem, GNUTLS_X509_FMT_PEM))
+                ret = USERPREF_E_SUCCESS;
+        else
+                ret = USERPREF_E_SSL_ERROR;
 
+        if (pem.data)
+                free(pem.data);
+#endif
         return ret;
 }
 
@@ -820,32 +1058,31 @@ userpref_error_t pair_record_import_key_with_name(plist_t pair_record, const cha
  *
  * @return IDEVICE_E_SUCCESS if the certificate was successfully imported.
  */
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL) || defined(HAVE_MBEDTLS)
 userpref_error_t pair_record_import_crt_with_name(plist_t pair_record, const char* name, key_data_t* cert)
 #else
 userpref_error_t pair_record_import_crt_with_name(plist_t pair_record, const char* name, gnutls_x509_crt_t cert)
 #endif
 {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL) || defined(HAVE_MBEDTLS)
         if (!cert)
                 return USERPREF_E_SUCCESS;
 #endif
         userpref_error_t ret = USERPREF_E_INVALID_CONF;
 
-#ifdef HAVE_OPENSSL
-                ret = pair_record_get_item_as_key_data(pair_record, name, cert);
-#else
-                key_data_t pem = { NULL, 0 };
-                ret = pair_record_get_item_as_key_data(pair_record, name, &pem);
-                if (ret == USERPREF_E_SUCCESS && GNUTLS_E_SUCCESS == gnutls_x509_crt_import(cert, &pem, GNUTLS_X509_FMT_PEM))
-                        ret = USERPREF_E_SUCCESS;
-                else
-                        ret = USERPREF_E_SSL_ERROR;
-
-                if (pem.data)
-                        free(pem.data);
-#endif
+#if defined(HAVE_OPENSSL) || defined(HAVE_MBEDTLS)
+        ret = pair_record_get_item_as_key_data(pair_record, name, cert);
+#elif defined(HAVE_GNUTLS)
+        key_data_t pem = { NULL, 0 };
+        ret = pair_record_get_item_as_key_data(pair_record, name, &pem);
+        if (ret == USERPREF_E_SUCCESS && GNUTLS_E_SUCCESS == gnutls_x509_crt_import(cert, &pem, GNUTLS_X509_FMT_PEM))
+                ret = USERPREF_E_SUCCESS;
+        else
+                ret = USERPREF_E_SSL_ERROR;
 
+        if (pem.data)
+                free(pem.data);
+#endif
         return ret;
 }
 
@@ -880,9 +1117,10 @@ userpref_error_t pair_record_get_item_as_key_data(plist_t pair_record, const cha
 
         if (node && plist_get_node_type(node) == PLIST_DATA) {
                 plist_get_data_val(node, &buffer, &length);
-                value->data = (unsigned char*)malloc(length);
+                value->data = (unsigned char*)malloc(length+1);
                 memcpy(value->data, buffer, length);
-                value->size = length;
+                value->data[length] = '\0';
+                value->size = length+1;
                 free(buffer);
                 buffer = NULL;
         } else {
diff --git a/common/userpref.h b/common/userpref.h
index 4ea630f..072721a 100644
--- a/common/userpref.h
+++ b/common/userpref.h
@@ -27,7 +27,7 @@
 #include <config.h>
 #endif
 
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL) || defined(HAVE_MBEDTLS)
 typedef struct {
         unsigned char *data;
         unsigned int size;
@@ -68,7 +68,7 @@ userpref_error_t userpref_save_pair_record(const char *udid, uint32_t device_id,
 userpref_error_t userpref_delete_pair_record(const char *udid);
 
 userpref_error_t pair_record_generate_keys_and_certs(plist_t pair_record, key_data_t public_key);
-#ifdef HAVE_OPENSSL
+#if  defined(HAVE_OPENSSL) || defined(HAVE_MBEDTLS)
 userpref_error_t pair_record_import_key_with_name(plist_t pair_record, const char* name, key_data_t* key);
 userpref_error_t pair_record_import_crt_with_name(plist_t pair_record, const char* name, key_data_t* cert);
 #else
diff --git a/configure.ac b/configure.ac
index 82038e1..bd061fc 100644
--- a/configure.ac
+++ b/configure.ac
@@ -128,43 +128,92 @@ fi
 AM_CONDITIONAL([HAVE_CYTHON],[test "x$CYTHON_SUB" = "xcython"])
 AC_SUBST([CYTHON_SUB])
 
-AC_ARG_ENABLE([openssl],
-            [AS_HELP_STRING([--disable-openssl],
+default_openssl=yes
+
+AC_ARG_WITH([mbedtls],
+            [AS_HELP_STRING([--without-mbedtls],
+            [Do not look for mbedtls])],
+            [use_mbedtls=$withval],
+            [use_mbedtls=no])
+if test "x$use_mbedtls" == "xyes"; then
+  default_openssl=no
+fi
+AC_ARG_WITH([gnutls],
+            [AS_HELP_STRING([--without-gnutls],
+            [Do not look for GnuTLS])],
+            [use_gnutls=$withval],
+            [use_gnutls=no])
+if test "x$use_gnutls" == "xyes"; then
+  default_openssl=no
+fi
+AC_ARG_WITH([openssl],
+            [AS_HELP_STRING([--without-openssl],
             [Do not look for OpenSSL])],
-            [use_openssl=$enableval],
-            [use_openssl=yes])
-
-pkg_req_openssl="openssl >= 0.9.8"
-PKG_CHECK_MODULES(openssl, $pkg_req_openssl, have_openssl=yes, have_openssl=no)
-if test "x$have_openssl" = "xyes"; then
-  if test "x$use_openssl" != "xyes"; then
-    enable_openssl=no
-    echo "*** Note: OpenSSL support explicitly disabled ***"
-  else
-    enable_openssl=yes
+            [use_openssl=$withval],
+            [use_openssl=$default_openssl])
+
+if test "x$use_mbedtls" == "xyes"; then
+  CACHED_CFLAGS="$CFLAGS"
+  conf_mbedtls_CFLAGS=""
+  if test -n "$mbedtls_INCLUDES"; then
+    CFLAGS=" -I$mbedtls_INCLUDES"
+    conf_mbedtls_CFLAGS="-I$mbedtls_INCLUDES"
   fi
-else
-  if test "x$use_openssl" == "xyes" -a "x$have_openssl" != "xyes"; then
-    AC_MSG_ERROR([OpenSSL support explicitly requested but OpenSSL could not be found])
+  conf_mbedtls_LIBS=""
+  if test -n "$mbedtls_LIBDIR"; then
+    conf_mbedtls_LIBS+=" -L$mbedtls_LIBDIR"
   fi
-fi
-
-if test "x$enable_openssl" = "xyes"; then
-  AC_DEFINE(HAVE_OPENSSL, 1, [Define if you have OpenSSL support])
-  AC_SUBST(openssl_CFLAGS)
-  AC_SUBST(openssl_LIBS)
-  ssl_provider="OpenSSL";
-  ssl_requires="$pkg_req_openssl"
+  if test -n "$mbedtls_LIBS"; then
+    conf_mbedtls_LIBS+=" $mbedtls_LIBS"
+  else
+    conf_mbedtls_LIBS+=" -lmbedtls -lmbedx509 -lmbedcrypto"
+  fi
+  AC_CHECK_HEADER(mbedtls/ssl.h, [break], [AC_MSG_ERROR([MbedTLS support explicitly requested, but includes could not be found. Try setting mbedtls_INCLUDES=/path/to/mbedtls/include])])
+  CFLAGS="$CACHED_CFLAGS"
+  AC_DEFINE(HAVE_MBEDTLS, 1, [Define if you have MbedTLS support])
+  ssl_lib_CFLAGS="$conf_mbedtls_CFLAGS"
+  ssl_lib_LIBS="$conf_mbedtls_LIBS"
+  AC_SUBST(ssl_lib_CFLAGS)
+  AC_SUBST(ssl_lib_LIBS)
+  ssl_provider="MbedTLS";
+  ssl_requires=""
   AC_SUBST(ssl_requires)
 else
-  pkg_req_gnutls="gnutls >= 2.2.0"
-  pkg_req_libtasn1="libtasn1 >= 1.1"
-  PKG_CHECK_MODULES(libgnutls, $pkg_req_gnutls)
-  AC_CHECK_LIB(gcrypt, gcry_control, [AC_SUBST(libgcrypt_LIBS,[-lgcrypt])], [AC_MSG_ERROR([libgcrypt is required to build libimobiledevice with GnuTLS])])
-  PKG_CHECK_MODULES(libtasn1, $pkg_req_libtasn1)
-  ssl_provider="GnuTLS"
-  ssl_requires="$pkg_req_gnutls $pkg_req_libtasn1"
-  AC_SUBST(ssl_requires)
+  if test "x$use_openssl" == "xyes"; then
+    pkg_req_openssl="openssl >= 0.9.8"
+    PKG_CHECK_MODULES(openssl, $pkg_req_openssl, have_openssl=yes, have_openssl=no)
+    if test "x$have_openssl" != "xyes"; then
+      AC_MSG_ERROR([OpenSSL support explicitly requested but OpenSSL could not be found])
+    else
+      AC_DEFINE(HAVE_OPENSSL, 1, [Define if you have OpenSSL support])
+      ssl_lib_CFLAGS="$openssl_CFLAGS"
+      ssl_lib_LIBS="$openssl_LIBS"
+      AC_SUBST(ssl_lib_CFLAGS)
+      AC_SUBST(ssl_lib_LIBS)
+      ssl_provider="OpenSSL";
+      ssl_requires="$pkg_req_openssl"
+      AC_SUBST(ssl_requires)
+    fi
+  else
+    if test "x$use_gnutls" == "xyes"; then
+      pkg_req_gnutls="gnutls >= 2.2.0"
+      pkg_req_libtasn1="libtasn1 >= 1.1"
+      PKG_CHECK_MODULES(libgnutls, $pkg_req_gnutls)
+      AC_CHECK_LIB(gcrypt, gcry_control, [AC_SUBST(libgcrypt_LIBS,[-lgcrypt])], [AC_MSG_ERROR([libgcrypt is required to build libimobiledevice with GnuTLS])])
+      PKG_CHECK_MODULES(libtasn1, $pkg_req_libtasn1)
+
+      AC_DEFINE(HAVE_GNUTLS, 1, [Define if you have GnuTLS support])
+      ssl_lib_CFLAGS="$libgnutls_CFLAGS $libtasn1_CFLAGS $libgcrypt_CFLAGS"
+      ssl_lib_LIBS="$libgnutls_LIBS $libtasn1_LIBS $libgcrypt_LIBS"
+      AC_SUBST(ssl_lib_CFLAGS)
+      AC_SUBST(ssl_lib_LIBS)
+      ssl_provider="GnuTLS"
+      ssl_requires="$pkg_req_gnutls $pkg_req_libtasn1"
+      AC_SUBST(ssl_requires)
+    else
+      AC_MSG_ERROR([No SSL library configured. $PACKAGE cannot be built without a supported SSL library.])
+    fi
+  fi
 fi
 
 AC_ARG_ENABLE([debug],
diff --git a/src/Makefile.am b/src/Makefile.am
index 1ef47fc..96fe963 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -5,20 +5,15 @@ AM_CPPFLAGS = \
 AM_CFLAGS = \
         $(GLOBAL_CFLAGS) \
         $(libusbmuxd_CFLAGS) \
-        $(libgnutls_CFLAGS) \
-        $(libtasn1_CFLAGS) \
         $(libplist_CFLAGS) \
+        $(ssl_lib_CFLAGS) \
         $(LFS_CFLAGS) \
-        $(openssl_CFLAGS) \
         $(PTHREAD_CFLAGS)
 
 AM_LDFLAGS = \
-        $(libgnutls_LIBS) \
-        $(libtasn1_LIBS) \
-        $(libplist_LIBS) \
         $(libusbmuxd_LIBS) \
-        $(libgcrypt_LIBS) \
-        $(openssl_LIBS) \
+        $(libplist_LIBS) \
+        $(ssl_lib_LIBS) \
         $(PTHREAD_LIBS)
 
 lib_LTLIBRARIES = libimobiledevice-1.0.la
diff --git a/src/idevice.c b/src/idevice.c
index e67a649..5b9c1ac 100644
--- a/src/idevice.c
+++ b/src/idevice.c
@@ -2,7 +2,7 @@
  * idevice.c
  * Device discovery and communication interface.
  *
- * Copyright (c) 2009-2019 Nikias Bassen. All Rights Reserved.
+ * Copyright (c) 2009-2021 Nikias Bassen. All Rights Reserved.
  * Copyright (c) 2014 Martin Szulecki All Rights Reserved.
  * Copyright (c) 2008 Zach C. All Rights Reserved.
  *
@@ -31,12 +31,21 @@
 #include <time.h>
 
 #include <usbmuxd.h>
-#ifdef HAVE_OPENSSL
+
+#if defined(HAVE_OPENSSL)
 #include <openssl/err.h>
 #include <openssl/rsa.h>
 #include <openssl/ssl.h>
-#else
+#elif defined(HAVE_GNUTLS)
 #include <gnutls/gnutls.h>
+#elif defined(HAVE_MBEDTLS)
+#include <mbedtls/rsa.h>
+#include <mbedtls/ssl.h>
+#include <mbedtls/entropy.h>
+#include <mbedtls/ctr_drbg.h>
+#include <mbedtls/debug.h>
+#else
+#error No supported TLS/SSL library enabled
 #endif
 
 #include "idevice.h"
@@ -106,7 +115,7 @@ static void id_function(CRYPTO_THREADID *thread)
 
 static void internal_idevice_init(void)
 {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
         int i;
         SSL_library_init();
@@ -124,14 +133,16 @@ static void internal_idevice_init(void)
 #endif
         CRYPTO_set_locking_callback(locking_function);
 #endif
-#else
+#elif defined(HAVE_GNUTLS)
         gnutls_global_init();
+#elif defined(HAVE_MBEDTLS)
+        // NO-OP
 #endif
 }
 
 static void internal_idevice_deinit(void)
 {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
         int i;
         if (mutex_buf) {
@@ -152,8 +163,10 @@ static void internal_idevice_deinit(void)
         SSL_COMP_free_compression_methods();
         openssl_remove_thread_state();
 #endif
-#else
+#elif defined(HAVE_GNUTLS)
         gnutls_global_deinit();
+#elif defined(HAVE_MBEDTLS)
+        // NO-OP
 #endif
 }
 
@@ -556,7 +569,11 @@ static idevice_error_t internal_connection_send(idevice_connection_t connection,
 
 LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_send(idevice_connection_t connection, const char *data, uint32_t len, uint32_t *sent_bytes)
 {
-        if (!connection || !data || (connection->ssl_data && !connection->ssl_data->session)) {
+        if (!connection || !data
+#if defined(HAVE_OPENSSL) || defined(HAVE_GNUTLS)
+                || (connection->ssl_data && !connection->ssl_data->session)
+#endif
+        ) {
                 return IDEVICE_E_INVALID_ARG;
         }
 
@@ -564,7 +581,7 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_send(idevice_connection_
                 connection->status = IDEVICE_E_SUCCESS;
                 uint32_t sent = 0;
                 while (sent < len) {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
                         int s = SSL_write(connection->ssl_data->session, (const void*)(data+sent), (int)(len-sent));
                         if (s <= 0) {
                                 int sslerr = SSL_get_error(connection->ssl_data->session, s);
@@ -573,8 +590,10 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_send(idevice_connection_
                                 }
                                 break;
                         }
-#else
+#elif defined(HAVE_GNUTLS)
                         ssize_t s = gnutls_record_send(connection->ssl_data->session, (void*)(data+sent), (size_t)(len-sent));
+#elif defined(HAVE_MBEDTLS)
+                        int s = mbedtls_ssl_write(&connection->ssl_data->ctx, (const unsigned char*)(data+sent), (size_t)(len-sent));
 #endif
                         if (s < 0) {
                                 break;
@@ -662,7 +681,12 @@ static idevice_error_t internal_connection_receive_timeout(idevice_connection_t
 
 LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_receive_timeout(idevice_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes, unsigned int timeout)
 {
-        if (!connection || (connection->ssl_data && !connection->ssl_data->session) || len == 0) {
+        if (!connection
+#if defined(HAVE_OPENSSL) || defined(HAVE_GNUTLS)
+                || (connection->ssl_data && !connection->ssl_data->session)
+#endif
+                || len == 0
+        ) {
                 return IDEVICE_E_INVALID_ARG;
         }
 
@@ -678,7 +702,7 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_receive_timeout(idevice_
                 connection->ssl_recv_timeout = timeout;
                 connection->status = IDEVICE_E_SUCCESS;
                 while (received < len) {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
                         int r = SSL_read(connection->ssl_data->session, (void*)((char*)(data+received)), (int)len-received);
                         if (r > 0) {
                                 received += r;
@@ -689,13 +713,20 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_receive_timeout(idevice_
                                 }
                                 break;
                         }
-#else
+#elif defined(HAVE_GNUTLS)
                         ssize_t r = gnutls_record_recv(connection->ssl_data->session, (void*)(data+received), (size_t)len-received);
                         if (r > 0) {
                                 received += r;
                         } else {
                                 break;
                         }
+#elif defined(HAVE_MBEDTLS)
+                        int r = mbedtls_ssl_read(&connection->ssl_data->ctx, (void*)(data+received), (size_t)len-received);
+                        if (r > 0) {
+                                received += r;
+                        } else {
+                                break;
+                        }
 #endif
                 }
                 connection->ssl_recv_timeout = (unsigned int)-1;
@@ -744,7 +775,11 @@ static idevice_error_t internal_connection_receive(idevice_connection_t connecti
 
 LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_receive(idevice_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes)
 {
-        if (!connection || (connection->ssl_data && !connection->ssl_data->session)) {
+        if (!connection
+#if defined(HAVE_OPENSSL) || defined(HAVE_GNUTLS)
+                || (connection->ssl_data && !connection->ssl_data->session)
+#endif
+        ) {
                 return IDEVICE_E_INVALID_ARG;
         }
 
@@ -753,11 +788,13 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_receive(idevice_connecti
                         debug_info("WARNING: ssl_recv_timeout was not properly reset in idevice_connection_receive_timeout");
                         connection->ssl_recv_timeout = (unsigned int)-1;
                 }
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
                 int received = SSL_read(connection->ssl_data->session, (void*)data, (int)len);
                 debug_info("SSL_read %d, received %d", len, received);
-#else
+#elif defined(HAVE_GNUTLS)
                 ssize_t received = gnutls_record_recv(connection->ssl_data->session, (void*)data, (size_t)len);
+#elif defined(HAVE_MBEDTLS)
+                int received = mbedtls_ssl_read(&connection->ssl_data->ctx, (unsigned char*)data, (size_t)len);
 #endif
                 if (received > 0) {
                         *recv_bytes = received;
@@ -806,10 +843,16 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_get_udid(idevice_t device, char **u
         return IDEVICE_E_SUCCESS;
 }
 
+#if defined(HAVE_OPENSSL) || defined(HAVE_GNUTLS)
+typedef ssize_t ssl_cb_ret_type_t;
+#elif defined(HAVE_MBEDTLS)
+typedef int ssl_cb_ret_type_t;
+#endif
+
 /**
  * Internally used SSL callback function for receiving encrypted data.
  */
-static ssize_t internal_ssl_read(idevice_connection_t connection, char *buffer, size_t length)
+static ssl_cb_ret_type_t internal_ssl_read(idevice_connection_t connection, char *buffer, size_t length)
 {
         uint32_t bytes = 0;
         uint32_t pos = 0;
@@ -849,7 +892,7 @@ static ssize_t internal_ssl_read(idevice_connection_t connection, char *buffer,
 /**
  * Internally used SSL callback function for sending encrypted data.
  */
-static ssize_t internal_ssl_write(idevice_connection_t connection, const char *buffer, size_t length)
+static ssl_cb_ret_type_t internal_ssl_write(idevice_connection_t connection, const char *buffer, size_t length)
 {
         uint32_t bytes = 0;
         idevice_error_t res;
@@ -871,14 +914,14 @@ static void internal_ssl_cleanup(ssl_data_t ssl_data)
         if (!ssl_data)
                 return;
 
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
         if (ssl_data->session) {
                 SSL_free(ssl_data->session);
         }
         if (ssl_data->ctx) {
                 SSL_CTX_free(ssl_data->ctx);
         }
-#else
+#elif defined(HAVE_GNUTLS)
         if (ssl_data->session) {
                 gnutls_deinit(ssl_data->session);
         }
@@ -897,6 +940,13 @@ static void internal_ssl_cleanup(ssl_data_t ssl_data)
         if (ssl_data->host_privkey) {
                 gnutls_x509_privkey_deinit(ssl_data->host_privkey);
         }
+#elif defined(HAVE_MBEDTLS)
+        mbedtls_pk_free(&ssl_data->root_privkey);
+        mbedtls_x509_crt_free(&ssl_data->certificate);
+        mbedtls_entropy_free(&ssl_data->entropy);
+        mbedtls_ctr_drbg_free(&ssl_data->ctr_drbg);
+        mbedtls_ssl_config_free(&ssl_data->config);
+        mbedtls_ssl_free(&ssl_data->ctx);
 #endif
 }
 
@@ -961,7 +1011,7 @@ static const char *ssl_error_to_string(int e)
 #endif
 #endif
 
-#ifndef HAVE_OPENSSL
+#if defined(HAVE_GNUTLS)
 /**
  * Internally used gnutls callback function that gets called during handshake.
  */
@@ -992,6 +1042,23 @@ static int internal_cert_callback(gnutls_session_t session, const gnutls_datum_t
         }
         return res;
 }
+#elif defined(HAVE_MBEDTLS)
+static void _mbedtls_log_cb(void* ctx, int level, const char* filename, int line, const char* message)
+{
+        fprintf(stderr, "[mbedtls][%d] %s:%d => %s", level, filename, line, message);
+}
+
+static int cert_verify_cb(void* ctx, mbedtls_x509_crt* cert, int depth, uint32_t *flags)
+{
+        *flags = 0;
+        return 0;
+}
+
+static int _mbedtls_f_rng(void* p_rng, unsigned char* buf, size_t len)
+{
+        memset(buf, 4, len);
+        return 0;
+}
 #endif
 
 LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection)
@@ -1008,7 +1075,7 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_enable_ssl(idevice_conne
                 return ret;
         }
 
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
         key_data_t root_cert = { NULL, 0 };
         key_data_t root_privkey = { NULL, 0 };
 
@@ -1118,7 +1185,7 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_enable_ssl(idevice_conne
         }
         /* required for proper multi-thread clean up to prevent leaks */
         openssl_remove_thread_state();
-#else
+#elif defined(HAVE_GNUTLS)
         ssl_data_t ssl_data_loc = (ssl_data_t)malloc(sizeof(struct ssl_data_private));
 
         /* Set up GnuTLS... */
@@ -1176,6 +1243,82 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_enable_ssl(idevice_conne
                 ret = IDEVICE_E_SUCCESS;
                 debug_info("SSL mode enabled");
         }
+#elif defined(HAVE_MBEDTLS)
+        key_data_t root_cert = { NULL, 0 };
+        key_data_t root_privkey = { NULL, 0 };
+
+        pair_record_import_crt_with_name(pair_record, USERPREF_ROOT_CERTIFICATE_KEY, &root_cert);
+        pair_record_import_key_with_name(pair_record, USERPREF_ROOT_PRIVATE_KEY_KEY, &root_privkey);
+
+        plist_free(pair_record);
+
+        ssl_data_t ssl_data_loc = (ssl_data_t)malloc(sizeof(struct ssl_data_private));
+
+        mbedtls_ssl_init(&ssl_data_loc->ctx);
+        mbedtls_ssl_config_init(&ssl_data_loc->config);
+        mbedtls_entropy_init(&ssl_data_loc->entropy);
+        mbedtls_ctr_drbg_init(&ssl_data_loc->ctr_drbg);
+
+        int r = mbedtls_ctr_drbg_seed(&ssl_data_loc->ctr_drbg, mbedtls_entropy_func, &ssl_data_loc->entropy, NULL, 0);
+        if (r != 0) {
+                debug_info("ERROR: [mbedtls] mbedtls_ctr_drbg_seed failed: %d", r);
+                return ret;
+        }
+
+        if (mbedtls_ssl_config_defaults(&ssl_data_loc->config, MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT) != 0) {
+                debug_info("ERROR: [mbedtls] Failed to set config defaults");
+                return ret;
+        }
+
+        mbedtls_ssl_conf_rng(&ssl_data_loc->config, mbedtls_ctr_drbg_random, &ssl_data_loc->ctr_drbg);
+
+        mbedtls_ssl_conf_dbg(&ssl_data_loc->config, _mbedtls_log_cb, NULL);
+
+        mbedtls_ssl_conf_verify(&ssl_data_loc->config, cert_verify_cb, NULL);
+
+        mbedtls_ssl_setup(&ssl_data_loc->ctx, &ssl_data_loc->config);
+
+        mbedtls_ssl_set_bio(&ssl_data_loc->ctx, connection, (mbedtls_ssl_send_t*)&internal_ssl_write, (mbedtls_ssl_recv_t*)&internal_ssl_read, NULL);
+
+        mbedtls_x509_crt_init(&ssl_data_loc->certificate);
+
+        int crterr = mbedtls_x509_crt_parse(&ssl_data_loc->certificate, root_cert.data, root_cert.size);
+        if (crterr < 0) {
+                debug_info("ERROR: [mbedtls] parsing root cert failed: %d", crterr);
+                return ret;
+        }
+
+        mbedtls_ssl_conf_ca_chain(&ssl_data_loc->config, &ssl_data_loc->certificate, NULL);
+
+        mbedtls_pk_init(&ssl_data_loc->root_privkey);
+
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+        int pkerr = mbedtls_pk_parse_key(&ssl_data_loc->root_privkey, root_privkey.data, root_privkey.size, NULL, 0, &_mbedtls_f_rng, NULL);
+#else
+        int pkerr = mbedtls_pk_parse_key(&ssl_data_loc->root_privkey, root_privkey.data, root_privkey.size, NULL, 0);
+#endif
+        if (pkerr < 0) {
+                debug_info("ERROR: [mbedtls] parsing private key failed: %d (size=%d)", pkerr, root_privkey.size);
+                return ret;
+        }
+
+        mbedtls_ssl_conf_own_cert(&ssl_data_loc->config, &ssl_data_loc->certificate, &ssl_data_loc->root_privkey);
+
+        int return_me = 0;
+        do {
+                return_me = mbedtls_ssl_handshake(&ssl_data_loc->ctx);
+        } while (return_me == MBEDTLS_ERR_SSL_WANT_READ || return_me == MBEDTLS_ERR_SSL_WANT_WRITE);
+
+        if (return_me != 0) {
+                debug_info("ERROR during SSL handshake: %d", return_me);
+                internal_ssl_cleanup(ssl_data_loc);
+                free(ssl_data_loc);
+        } else {
+                connection->ssl_data = ssl_data_loc;
+                ret = IDEVICE_E_SUCCESS;
+                debug_info("SSL mode enabled, %s, cipher: %s", mbedtls_ssl_get_version(&ssl_data_loc->ctx), mbedtls_ssl_get_ciphersuite(&ssl_data_loc->ctx));
+                debug_info("SSL mode enabled");
+        }
 #endif
         return ret;
 }
@@ -1197,7 +1340,7 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_disable_bypass_ssl(idevi
         // some services require plain text communication after SSL handshake
         // sending out SSL_shutdown will cause bytes
         if (!sslBypass) {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
                 if (connection->ssl_data->session) {
                         /* see: https://www.openssl.org/docs/ssl/SSL_shutdown.html#RETURN_VALUES */
                         if (SSL_shutdown(connection->ssl_data->session) == 0) {
@@ -1210,10 +1353,12 @@ LIBIMOBILEDEVICE_API idevice_error_t idevice_connection_disable_bypass_ssl(idevi
                                 }
                         }
                 }
-#else
+#elif defined(HAVE_GNUTLS)
                 if (connection->ssl_data->session) {
                         gnutls_bye(connection->ssl_data->session, GNUTLS_SHUT_RDWR);
                 }
+#elif defined(HAVE_MBEDTLS)
+                mbedtls_ssl_close_notify(&connection->ssl_data->ctx);
 #endif
         }
 
diff --git a/src/idevice.h b/src/idevice.h
index 4e53a7f..7a8f4ce 100644
--- a/src/idevice.h
+++ b/src/idevice.h
@@ -26,11 +26,15 @@
 #include <config.h>
 #endif
 
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
 #include <openssl/ssl.h>
-#else
+#elif defined(HAVE_GNUTLS)
 #include <gnutls/gnutls.h>
 #include <gnutls/x509.h>
+#elif defined(HAVE_MBEDTLS)
+#include <mbedtls/ssl.h>
+#include <mbedtls/entropy.h>
+#include <mbedtls/ctr_drbg.h>
 #endif
 
 #ifdef WIN32
@@ -49,16 +53,23 @@
 #define DEVICE_VERSION(maj, min, patch) (((maj & 0xFF) << 16) | ((min & 0xFF) << 8) | (patch & 0xFF))
 
 struct ssl_data_private {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
         SSL *session;
         SSL_CTX *ctx;
-#else
+#elif defined(HAVE_GNUTLS)
         gnutls_certificate_credentials_t certificate;
         gnutls_session_t session;
         gnutls_x509_privkey_t root_privkey;
         gnutls_x509_crt_t root_cert;
         gnutls_x509_privkey_t host_privkey;
         gnutls_x509_crt_t host_cert;
+#elif defined(HAVE_MBEDTLS)
+        mbedtls_ssl_context ctx;
+        mbedtls_ssl_config config;
+        mbedtls_entropy_context entropy;
+        mbedtls_ctr_drbg_context ctr_drbg;
+        mbedtls_x509_crt certificate;
+        mbedtls_pk_context root_privkey;
 #endif
 };
 typedef struct ssl_data_private *ssl_data_t;
diff --git a/tools/Makefile.am b/tools/Makefile.am
index 04a5faa..b78f3f2 100644
--- a/tools/Makefile.am
+++ b/tools/Makefile.am
@@ -4,18 +4,10 @@ AM_CPPFLAGS = \
 
 AM_CFLAGS = \
         $(GLOBAL_CFLAGS) \
-        $(libgnutls_CFLAGS) \
-        $(libtasn1_CFLAGS) \
-        $(libgcrypt_CFLAGS) \
-        $(openssl_CFLAGS) \
         $(libplist_CFLAGS) \
         $(LFS_CFLAGS)
 
 AM_LDFLAGS = \
-        $(libgnutls_LIBS) \
-        $(libtasn1_LIBS) \
-        $(libgcrypt_LIBS) \
-        $(openssl_LIBS) \
         $(libplist_LIBS)
 
 bin_PROGRAMS = \
@@ -49,8 +41,8 @@ idevicename_LDFLAGS = $(AM_LDFLAGS)
 idevicename_LDADD = $(top_builddir)/src/libimobiledevice-1.0.la
 
 idevicepair_SOURCES = idevicepair.c
-idevicepair_CFLAGS = -I$(top_srcdir) $(AM_CFLAGS)
-idevicepair_LDFLAGS = $(AM_LDFLAGS) $(libusbmuxd_LIBS)
+idevicepair_CFLAGS = -I$(top_srcdir) $(AM_CFLAGS) $(ssl_lib_CFLAGS)
+idevicepair_LDFLAGS = $(AM_LDFLAGS) $(libusbmuxd_LIBS) $(ssl_lib_LIBS)
 idevicepair_LDADD = $(top_builddir)/src/libimobiledevice-1.0.la $(top_builddir)/common/libinternalcommon.la
 
 idevicesyslog_SOURCES = idevicesyslog.c
@@ -64,8 +56,8 @@ idevice_id_LDFLAGS = $(AM_LDFLAGS)
 idevice_id_LDADD = $(top_builddir)/src/libimobiledevice-1.0.la
 
 idevicebackup_SOURCES = idevicebackup.c
-idevicebackup_CFLAGS = $(AM_CFLAGS)
-idevicebackup_LDFLAGS = $(AM_LDFLAGS)
+idevicebackup_CFLAGS = $(AM_CFLAGS) $(ssl_lib_CFLAGS)
+idevicebackup_LDFLAGS = $(AM_LDFLAGS) $(ssl_lib_LIBS)
 idevicebackup_LDADD = $(top_builddir)/src/libimobiledevice-1.0.la $(top_builddir)/common/libinternalcommon.la
 
 idevicebackup2_SOURCES = idevicebackup2.c
diff --git a/tools/idevicebackup.c b/tools/idevicebackup.c
index dfd7b8b..8d0f74b 100644
--- a/tools/idevicebackup.c
+++ b/tools/idevicebackup.c
@@ -31,10 +31,20 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <signal.h>
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
 #include <openssl/sha.h>
-#else
+#elif defined(HAVE_GNUTLS)
 #include <gcrypt.h>
+#elif defined(HAVE_MBEDTLS)
+#include <mbedtls/sha1.h>
+#if MBEDTLS_VERSION_NUMBER < 0x03000000
+#define mbedtls_sha1         mbedtls_sha1_ret
+#define mbedtls_sha1_starts  mbedtls_sha1_starts_ret
+#define mbedtls_sha1_update  mbedtls_sha1_update_ret
+#define mbedtls_sha1_finish  mbedtls_sha1_finish_ret
+#endif
+#else
+#error No supported crypto library enabled
 #endif
 #include <unistd.h>
 #include <ctype.h>
@@ -78,10 +88,12 @@ enum device_link_file_status_t {
 
 static void sha1_of_data(const char *input, uint32_t size, unsigned char *hash_out)
 {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
         SHA1((const unsigned char*)input, size, hash_out);
-#else
+#elif defined(HAVE_GNUTLS)
         gcry_md_hash_buffer(GCRY_MD_SHA1, hash_out, input, size);
+#elif defined(HAVE_MBEDTLS)
+        mbedtls_sha1((unsigned char*)input, size, hash_out);
 #endif
 }
 
@@ -96,12 +108,24 @@ static int compare_hash(const unsigned char *hash1, const unsigned char *hash2,
         return 1;
 }
 
+static void _sha1_update(void* context, const char* data, size_t len)
+{
+#if defined(HAVE_OPENSSL)
+        SHA1_Update(context, data, len);
+#elif defined(HAVE_GNUTLS)
+        gcry_md_write(context, data, len);
+#elif defined(HAVE_MBEDTLS)
+        mbedtls_sha1_update(context, (const unsigned char*)data, len);
+#endif
+}
+
 static void compute_datahash(const char *path, const char *destpath, uint8_t greylist, const char *domain, const char *appid, const char *version, unsigned char *hash_out)
 {
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
         SHA_CTX sha1;
         SHA1_Init(&sha1);
-#else
+        void* psha1 = &sha1;
+#elif defined(HAVE_GNUTLS)
         gcry_md_hd_t hd = NULL;
         gcry_md_open(&hd, GCRY_MD_SHA1, 0);
         if (!hd) {
@@ -109,102 +133,63 @@ static void compute_datahash(const char *path, const char *destpath, uint8_t gre
                 return;
         }
         gcry_md_reset(hd);
+        void* psha1 = hd;
+#elif defined(HAVE_MBEDTLS)
+        mbedtls_sha1_context sha1;
+        mbedtls_sha1_init(&sha1);
+        mbedtls_sha1_starts(&sha1);
+        void* psha1 = &sha1;
 #endif
         FILE *f = fopen(path, "rb");
         if (f) {
                 unsigned char buf[16384];
                 size_t len;
                 while ((len = fread(buf, 1, 16384, f)) > 0) {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, buf, len);
-#else
-                        gcry_md_write(hd, buf, len);
-#endif
+                        _sha1_update(psha1, (const char*)buf, len);
                 }
                 fclose(f);
-#ifdef HAVE_OPENSSL
-                SHA1_Update(&sha1, destpath, strlen(destpath));
-                SHA1_Update(&sha1, ";", 1);
-#else
-                gcry_md_write(hd, destpath, strlen(destpath));
-                gcry_md_write(hd, ";", 1);
-#endif
+                _sha1_update(psha1, destpath, strlen(destpath));
+                _sha1_update(psha1, ";", 1);
+
                 if (greylist == 1) {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, "true", 4);
-#else
-                        gcry_md_write(hd, "true", 4);
-#endif
+                        _sha1_update(psha1, "true", 4);
                 } else {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, "false", 5);
-#else
-                        gcry_md_write(hd, "false", 5);
-#endif
+                        _sha1_update(psha1, "false", 5);
                 }
-#ifdef HAVE_OPENSSL
-                SHA1_Update(&sha1, ";", 1);
-#else
-                gcry_md_write(hd, ";", 1);
-#endif
+                _sha1_update(psha1, ";", 1);
+
                 if (domain) {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, domain, strlen(domain));
-#else
-                        gcry_md_write(hd, domain, strlen(domain));
-#endif
+                        _sha1_update(psha1, domain, strlen(domain));
                 } else {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, "(null)", 6);
-#else
-                        gcry_md_write(hd, "(null)", 6);
-#endif
+                        _sha1_update(psha1, "(null)", 6);
                 }
-#ifdef HAVE_OPENSSL
-                SHA1_Update(&sha1, ";", 1);
-#else
-                gcry_md_write(hd, ";", 1);
-#endif
+                _sha1_update(psha1, ";", 1);
+
                 if (appid) {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, appid, strlen(appid));
-#else
-                        gcry_md_write(hd, appid, strlen(appid));
-#endif
+                        _sha1_update(psha1, appid, strlen(appid));
                 } else {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, "(null)", 6);
-#else
-                        gcry_md_write(hd, "(null)", 6);
-#endif
+                        _sha1_update(psha1, "(null)", 6);
                 }
-#ifdef HAVE_OPENSSL
-                SHA1_Update(&sha1, ";", 1);
-#else
-                gcry_md_write(hd, ";", 1);
-#endif
+                _sha1_update(psha1, ";", 1);
+
                 if (version) {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, version, strlen(version));
-#else
-                        gcry_md_write(hd, version, strlen(version));
-#endif
+                        _sha1_update(psha1, version, strlen(version));
                 } else {
-#ifdef HAVE_OPENSSL
-                        SHA1_Update(&sha1, "(null)", 6);
-#else
-                        gcry_md_write(hd, "(null)", 6);
-#endif
+                        _sha1_update(psha1, "(null)", 6);
                 }
-#ifdef HAVE_OPENSSL
+#if defined(HAVE_OPENSSL)
                 SHA1_Final(hash_out, &sha1);
-#else
+#elif defined(HAVE_GNUTLS)
                 unsigned char *newhash = gcry_md_read(hd, GCRY_MD_SHA1);
                 memcpy(hash_out, newhash, 20);
+#elif defined(HAVE_MBEDTLS)
+                mbedtls_sha1_finish(&sha1, hash_out);
 #endif
         }
-#ifndef HAVE_OPENSSL
+#if defined(HAVE_GNUTLS)
         gcry_md_close(hd);
+#elif defined(HAVE_MBEDTLS)
+        mbedtls_sha1_free(&sha1);
 #endif
 }