Add support for mbedtls (formely polarssl)

diff --git a/cmake/FindPolarSSL.cmake b/cmake/FindPolarSSL.cmake
index 0a958e0086981e59b12dfedcfa6537ab7cb69ee1..e4e1ac61c5ea0cbd7395ee068b341f673dc7f94b 100644 (file)
--- a/cmake/FindPolarSSL.cmake
+++ b/cmake/FindPolarSSL.cmake
@@ -8,21 +8,36 @@ if(POLARSSL_PREFER_STATIC_LIB)
 endif()
 
 if(UNIX)
-  find_package(PkgConfig QUIET)
-  pkg_check_modules(_POLARSSL QUIET polarssl)
+    find_package(PkgConfig QUIET)
+    pkg_check_modules(_MBEDTLS QUIET mbedtls)
 endif()
 
-find_path(POLARSSL_INCLUDE_DIR NAMES polarssl/version.h HINTS ${_POLARSSL_INCLUDEDIR})
-find_library(POLARSSL_LIBRARY NAMES polarssl HINTS ${_POLARSSL_LIBDIR})
+find_path(MBEDTLS_INCLUDE_DIR NAMES mbedtls/version.h HINTS ${_MBEDTLS_INCLUDEDIR})
+find_library(MBEDTLS_LIBRARY NAMES mbedtls HINTS ${_MBEDTLS_LIBDIR})
+if(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARY)
+    set(POLARSSL_INCLUDE_DIR ${MBEDTLS_INCLUDE_DIR})
+    set(POLARSSL_LIBRARY ${MBEDTLS_LIBRARY})
+    set(POLARSSL_VERSION ${_MBEDTLS_VERSION})
+    set(POLARSSL_IS_MBEDTLS ON)
+else()
+    if(UNIX)
+        pkg_check_modules(_POLARSSL QUIET polarssl)
+    endif()
+
+    find_path(POLARSSL_INCLUDE_DIR NAMES polarssl/version.h HINTS ${_POLARSSL_INCLUDEDIR})
+    find_library(POLARSSL_LIBRARY NAMES polarssl HINTS ${_POLARSSL_LIBDIR})
+    set(POLARSSL_VERSION ${_POLARSSL_VERSION})
+    set(POLARSSL_IS_MBEDTLS OFF)
+endif()
 
-if(POLARSSL_INCLUDE_DIR)
-    if(_POLARSSL_VERSION)
-        set(POLARSSL_VERSION ${_POLARSSL_VERSION})
+if(NOT POLARSSL_VERSION AND POLARSSL_INCLUDE_DIR)
+    if(POLARSSL_IS_MBEDTLS)
+        file(STRINGS "${POLARSSL_INCLUDE_DIR}/mbedtls/version.h" POLARSSL_VERSION_STR REGEX "^#define[\t ]+MBEDTLS_VERSION_STRING[\t ]+\"[^\"]+\"")
     else()
         file(STRINGS "${POLARSSL_INCLUDE_DIR}/polarssl/version.h" POLARSSL_VERSION_STR REGEX "^#define[\t ]+POLARSSL_VERSION_STRING[\t ]+\"[^\"]+\"")
-        if(POLARSSL_VERSION_STR MATCHES "\"([^\"]+)\"")
-            set(POLARSSL_VERSION "${CMAKE_MATCH_1}")
-        endif()
+    endif()
+    if(POLARSSL_VERSION_STR MATCHES "\"([^\"]+)\"")
+        set(POLARSSL_VERSION "${CMAKE_MATCH_1}")
     endif()
 endif()
 
@@ -39,7 +54,7 @@ find_package_handle_standard_args(PolarSSL
         POLARSSL_VERSION
 )
 
-mark_as_advanced(POLARSSL_INCLUDE_DIR POLARSSL_LIBRARY)
+mark_as_advanced(MBEDTLS_INCLUDE_DIR MBEDTLS_LIBRARY POLARSSL_INCLUDE_DIR POLARSSL_LIBRARY)
 
 if(POLARSSL_PREFER_STATIC_LIB)
     set(CMAKE_FIND_LIBRARY_SUFFIXES ${POLARSSL_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})

diff --git a/configure.ac b/configure.ac
index e6262598e6f9975bfccbcdb54c0b0a4d400cc5e4..01772232223d2d6bbd8052650b495c87b12660c5 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -149,23 +149,26 @@ AS_IF([test "x$want_crypto" = "xauto" -o "x$want_crypto" = "xcyassl"], [
     )
 ])
 AS_IF([test "x$want_crypto" = "xauto" -o "x$want_crypto" = "xpolarssl"], [
-    AC_CHECK_HEADER([polarssl/version.h],
-        [AC_EGREP_CPP([version_ok], [#include <polarssl/version.h>
-                                     #if defined (POLARSSL_VERSION_NUMBER) && POLARSSL_VERSION_NUMBER >= $POLARSSL_MINIMUM
-                                     version_ok
-                                     #endif],
-            [AC_CHECK_LIB([polarssl], [dhm_calc_secret],
-                [want_crypto="polarssl"; CRYPTO_PKG="polarssl"; CRYPTO_CFLAGS=""; CRYPTO_LIBS="-lpolarssl"],
+    PKG_CHECK_MODULES(MBEDTLS, [mbedtls >= $POLARSSL_MINIMUM],
+        [want_crypto="polarssl"; CRYPTO_PKG="polarssl"; CRYPTO_CFLAGS="$MBEDTLS_CFLAGS"; CRYPTO_LIBS="$MBEDTLS_LIBS"; POLARSSL_IS_MBEDTLS=yes],
+        [AC_CHECK_HEADER([polarssl/version.h],
+            [AC_EGREP_CPP([version_ok], [#include <polarssl/version.h>
+                                         #if defined (POLARSSL_VERSION_NUMBER) && POLARSSL_VERSION_NUMBER >= $POLARSSL_MINIMUM
+                                         version_ok
+                                         #endif],
+                [AC_CHECK_LIB([polarssl], [dhm_calc_secret],
+                    [want_crypto="polarssl"; CRYPTO_PKG="polarssl"; CRYPTO_CFLAGS=""; CRYPTO_LIBS="-lpolarssl"],
+                    [AS_IF([test "x$want_crypto" = "xpolarssl"],
+                        [AC_MSG_ERROR([PolarSSL support requested, but library not found.])]
+                    )]
+                )],
                 [AS_IF([test "x$want_crypto" = "xpolarssl"],
-                    [AC_MSG_ERROR([PolarSSL support requested, but library not found.])]
+                    [AC_MSG_ERROR([PolarSSL support requested, but version not suitable.])]
                 )]
             )],
             [AS_IF([test "x$want_crypto" = "xpolarssl"],
-                [AC_MSG_ERROR([PolarSSL support requested, but version not suitable.])]
+                [AC_MSG_ERROR([PolarSSL support requested, but headers not found.])]
             )]
-        )],
-        [AS_IF([test "x$want_crypto" = "xpolarssl"],
-            [AC_MSG_ERROR([PolarSSL support requested, but headers not found.])]
         )]
     )
 ])
@@ -180,6 +183,7 @@ AS_IF([test "x$CRYPTO_PKG" = "x"], [
 AM_CONDITIONAL([CRYPTO_USE_OPENSSL],[test "x$CRYPTO_PKG" = "xopenssl"])
 AM_CONDITIONAL([CRYPTO_USE_CYASSL],[test "x$CRYPTO_PKG" = "xcyassl"])
 AM_CONDITIONAL([CRYPTO_USE_POLARSSL],[test "x$CRYPTO_PKG" = "xpolarssl"])
+AM_CONDITIONAL([POLARSSL_IS_MBEDTLS],[test "x$POLARSSL_IS_MBEDTLS" = "xyes"])
 AC_SUBST(CRYPTO_PKG)
 AC_SUBST(CRYPTO_CFLAGS)
 AC_SUBST(CRYPTO_LIBS)

diff --git a/libtransmission/CMakeLists.txt b/libtransmission/CMakeLists.txt
index 5111f9ce4321a4e9de0c57ace5bc118b83bee336..c7d096e401e08114dc3c7d62afb4b8d826d989e0 100644 (file)
--- a/libtransmission/CMakeLists.txt
+++ b/libtransmission/CMakeLists.txt
@@ -196,6 +196,10 @@ if(USE_SYSTEM_B64)
     add_definitions(-DUSE_SYSTEM_B64)
 endif()
 
+if(POLARSSL_IS_MBEDTLS)
+    add_definitions(-DPOLARSSL_IS_MBEDTLS)
+endif()
+
 include_directories(
     ${PROJECT_SOURCE_DIR}
     ${PROJECT_BINARY_DIR}

diff --git a/libtransmission/Makefile.am b/libtransmission/Makefile.am
index 0b35305f868bdd91d615b9a9dcd2a283aac9c3a6..24b1a7a72a09fe0e8aaacb54d9c9473fb6e7f6a3 100644 (file)
--- a/libtransmission/Makefile.am
+++ b/libtransmission/Makefile.am
@@ -103,6 +103,9 @@ libtransmission_a_SOURCES += crypto-utils-cyassl.c
 endif
 if CRYPTO_USE_POLARSSL
 libtransmission_a_SOURCES += crypto-utils-polarssl.c
+if POLARSSL_IS_MBEDTLS
+AM_CPPFLAGS += -DPOLARSSL_IS_MBEDTLS
+endif
 endif
 
 noinst_HEADERS = \

diff --git a/libtransmission/crypto-utils-polarssl.c b/libtransmission/crypto-utils-polarssl.c
index 0099978eb9e685a5dc5ace862c7b446db4980610..d3d796ea1cecc971f774e495d6f32dbf0380f697 100644 (file)
--- a/libtransmission/crypto-utils-polarssl.c
+++ b/libtransmission/crypto-utils-polarssl.c
@@ -1,20 +1,30 @@
 /*
- * This file Copyright (C) 2014-2015 Mnemosyne LLC
+ * This file Copyright (C) 2014-2016 Mnemosyne LLC
  *
  * It may be used under the GNU GPL versions 2 or 3
  * or any future license endorsed by Mnemosyne LLC.
  *
  */
 
+#if defined (POLARSSL_IS_MBEDTLS)
+ #define API_HEADER(x) <mbedtls/x>
+ #define API(x) mbedtls_##x
+ #define API_VERSION_NUMBER MBEDTLS_VERSION_NUMBER
+#else
+ #define API_HEADER(x) <polarssl/x>
+ #define API(x) x
+ #define API_VERSION_NUMBER POLARSSL_VERSION_NUMBER
+#endif
+
 #include <assert.h>
 
-#include <polarssl/arc4.h>
-#include <polarssl/base64.h>
-#include <polarssl/ctr_drbg.h>
-#include <polarssl/dhm.h>
-#include <polarssl/error.h>
-#include <polarssl/sha1.h>
-#include <polarssl/version.h>
+#include API_HEADER (arc4.h)
+#include API_HEADER (base64.h)
+#include API_HEADER (ctr_drbg.h)
+#include API_HEADER (dhm.h)
+#include API_HEADER (error.h)
+#include API_HEADER (sha1.h)
+#include API_HEADER (version.h)
 
 #include "transmission.h"
 #include "crypto-utils.h"
@@ -40,7 +50,9 @@ log_polarssl_error (int          error_code,
     {
       char error_message[256];
 
-#if POLARSSL_VERSION_NUMBER >= 0x01030000
+#if defined (POLARSSL_IS_MBEDTLS)
+      mbedtls_strerror (error_code, error_message, sizeof (error_message));
+#elif API_VERSION_NUMBER >= 0x01030000
       polarssl_strerror (error_code, error_message, sizeof (error_message));
 #else
       error_strerror (error_code, error_message, sizeof (error_message));
@@ -50,7 +62,7 @@ log_polarssl_error (int          error_code,
     }
 }
 
-#define log_error(error_code) log_polarssl_error(error_code, __FILE__, __LINE__)
+#define log_error(error_code) log_polarssl_error ((error_code), __FILE__, __LINE__)
 
 static bool
 check_polarssl_result (int          result,
@@ -82,15 +94,20 @@ my_rand (void * context UNUSED, unsigned char * buffer, size_t buffer_size)
   return 0;
 }
 
-static ctr_drbg_context *
+static API (ctr_drbg_context) *
 get_rng (void)
 {
-  static ctr_drbg_context rng;
+  static API (ctr_drbg_context) rng;
   static bool rng_initialized = false;
 
   if (!rng_initialized)
     {
-      if (!check_result (ctr_drbg_init (&rng, &my_rand, NULL, NULL, 0)))
+#if API_VERSION_NUMBER >= 0x02000000
+      API (ctr_drbg_init) (&rng);
+      if (!check_result (API (ctr_drbg_seed) (&rng, &my_rand, NULL, NULL, 0)))
+#else
+      if (!check_result (API (ctr_drbg_init) (&rng, &my_rand, NULL, NULL, 0)))
+#endif
         return NULL;
       rng_initialized = true;
     }
@@ -116,13 +133,13 @@ get_rng_lock (void)
 tr_sha1_ctx_t
 tr_sha1_init (void)
 {
-  sha1_context * handle = tr_new0 (sha1_context, 1);
+  API (sha1_context) * handle = tr_new0 (API (sha1_context), 1);
 
-#if POLARSSL_VERSION_NUMBER >= 0x01030800
-  sha1_init (handle);
+#if API_VERSION_NUMBER >= 0x01030800
+  API (sha1_init) (handle);
 #endif
 
-  sha1_starts (handle);
+  API (sha1_starts) (handle);
   return handle;
 }
 
@@ -138,7 +155,7 @@ tr_sha1_update (tr_sha1_ctx_t   handle,
 
   assert (data != NULL);
 
-  sha1_update (handle, data, data_length);
+  API (sha1_update) (handle, data, data_length);
   return true;
 }
 
@@ -150,11 +167,11 @@ tr_sha1_final (tr_sha1_ctx_t   handle,
     {
       assert (handle != NULL);
 
-      sha1_finish (handle, hash);
+      API (sha1_finish) (handle, hash);
     }
 
-#if POLARSSL_VERSION_NUMBER >= 0x01030800
-  sha1_free (handle);
+#if API_VERSION_NUMBER >= 0x01030800
+  API (sha1_free) (handle);
 #endif
 
   tr_free (handle);
@@ -168,10 +185,10 @@ tr_sha1_final (tr_sha1_ctx_t   handle,
 tr_rc4_ctx_t
 tr_rc4_new (void)
 {
-  arc4_context * handle = tr_new0 (arc4_context, 1);
+  API (arc4_context) * handle = tr_new0 (API (arc4_context), 1);
 
-#if POLARSSL_VERSION_NUMBER >= 0x01030800
-  arc4_init (handle);
+#if API_VERSION_NUMBER >= 0x01030800
+  API (arc4_init) (handle);
 #endif
 
   return handle;
@@ -180,8 +197,8 @@ tr_rc4_new (void)
 void
 tr_rc4_free (tr_rc4_ctx_t handle)
 {
-#if POLARSSL_VERSION_NUMBER >= 0x01030800
-  arc4_free (handle);
+#if API_VERSION_NUMBER >= 0x01030800
+  API (arc4_free) (handle);
 #endif
 
   tr_free (handle);
@@ -195,7 +212,7 @@ tr_rc4_set_key (tr_rc4_ctx_t    handle,
   assert (handle != NULL);
   assert (key != NULL);
 
-  arc4_setup (handle, key, key_length);
+  API (arc4_setup) (handle, key, key_length);
 }
 
 void
@@ -212,7 +229,7 @@ tr_rc4_process (tr_rc4_ctx_t   handle,
   assert (input != NULL);
   assert (output != NULL);
 
-  arc4_crypt (handle, length, input, output);
+  API (arc4_crypt) (handle, length, input, output);
 }
 
 /***
@@ -225,19 +242,19 @@ tr_dh_new (const uint8_t * prime_num,
            const uint8_t * generator_num,
            size_t          generator_num_length)
 {
-  dhm_context * handle = tr_new0 (dhm_context, 1);
+  API (dhm_context) * handle = tr_new0 (API (dhm_context), 1);
 
   assert (prime_num != NULL);
   assert (generator_num != NULL);
 
-#if POLARSSL_VERSION_NUMBER >= 0x01030800
-  dhm_init (handle);
+#if API_VERSION_NUMBER >= 0x01030800
+  API (dhm_init) (handle);
 #endif
 
-  if (!check_result (mpi_read_binary (&handle->P, prime_num, prime_num_length)) ||
-      !check_result (mpi_read_binary (&handle->G, generator_num, generator_num_length)))
+  if (!check_result (API (mpi_read_binary) (&handle->P, prime_num, prime_num_length)) ||
+      !check_result (API (mpi_read_binary) (&handle->G, generator_num, generator_num_length)))
     {
-      dhm_free (handle);
+      API (dhm_free) (handle);
       return NULL;
     }
 
@@ -252,7 +269,7 @@ tr_dh_free (tr_dh_ctx_t handle)
   if (handle == NULL)
     return;
 
-  dhm_free (handle);
+  API (dhm_free) (handle);
 }
 
 bool
@@ -261,7 +278,7 @@ tr_dh_make_key (tr_dh_ctx_t   raw_handle,
                 uint8_t     * public_key,
                 size_t      * public_key_length)
 {
-  dhm_context * handle = raw_handle;
+  API (dhm_context) * handle = raw_handle;
 
   assert (handle != NULL);
   assert (public_key != NULL);
@@ -269,8 +286,8 @@ tr_dh_make_key (tr_dh_ctx_t   raw_handle,
   if (public_key_length != NULL)
     *public_key_length = handle->len;
 
-  return check_result (dhm_make_public (handle, private_key_length, public_key,
-                                        handle->len, my_rand, NULL));
+  return check_result (API (dhm_make_public) (handle, private_key_length, public_key,
+                                                      handle->len, my_rand, NULL));
 }
 
 tr_dh_secret_t
@@ -278,26 +295,29 @@ tr_dh_agree (tr_dh_ctx_t     raw_handle,
              const uint8_t * other_public_key,
              size_t          other_public_key_length)
 {
-  dhm_context * handle = raw_handle;
+  API (dhm_context) * handle = raw_handle;
   struct tr_dh_secret * ret;
   size_t secret_key_length;
 
   assert (handle != NULL);
   assert (other_public_key != NULL);
 
-  if (!check_result (dhm_read_public (handle, other_public_key,
-                                      other_public_key_length)))
+  if (!check_result (API (dhm_read_public )(handle, other_public_key,
+                                                    other_public_key_length)))
     return NULL;
 
   ret = tr_dh_secret_new (handle->len);
 
   secret_key_length = handle->len;
 
-#if POLARSSL_VERSION_NUMBER >= 0x01030000
-  if (!check_result (dhm_calc_secret (handle, ret->key,
-                                      &secret_key_length, my_rand, NULL)))
+#if API_VERSION_NUMBER >= 0x02000000
+  if (!check_result (API (dhm_calc_secret) (handle, ret->key, secret_key_length,
+                                                    &secret_key_length, my_rand, NULL)))
+#elif API_VERSION_NUMBER >= 0x01030000
+  if (!check_result (API (dhm_calc_secret) (handle, ret->key,
+                                                    &secret_key_length, my_rand, NULL)))
 #else
-  if (!check_result (dhm_calc_secret (handle, ret->key, &secret_key_length)))
+  if (!check_result (API (dhm_calc_secret) (handle, ret->key, &secret_key_length)))
 #endif
     {
       tr_dh_secret_free (ret);
@@ -323,7 +343,7 @@ tr_rand_buffer (void   * buffer,
   assert (buffer != NULL);
 
   tr_lockLock (rng_lock);
-  ret = check_result (ctr_drbg_random (get_rng (), buffer, length));
+  ret = check_result (API (ctr_drbg_random) (get_rng (), buffer, length));
   tr_lockUnlock (rng_lock);
 
   return ret;