Added cross-compilation support for Android.

.gitignore

@@ -3,6 +3,7 @@
 *.c~
 *.o
 *.exe
+*.bak
 .metadata
 .cproject
 .project

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "extern/ENCRYPTO_utils"]
-	path = extern/ENCRYPTO_utils
-	url = https://github.com/encryptogroup/ENCRYPTO_utils.git

CMakeLists.txt

@@ -1,29 +1,38 @@
-cmake_minimum_required(VERSION 3.12)
-project(OTExtension LANGUAGES CXX)
-
-if (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
-    message(FATAL_ERROR "ENCRYPTO_utils require at least g++-8")
+cmake_minimum_required(VERSION 3.13)
+list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_CURRENT_LIST_DIR}/cmake/Modules")
+include(OTExtensionCacheVariables)
+set(CMAKE_CXX_STANDARD 14)
+project(OTExtension LANGUAGES C CXX)
+
+if(ANDROID)
+     if(ANDROID_ARM_NEON)
+         set(OTExtension_INSTALL_PREFIX "platforms/${ANDROID_PLATFORM}/arch-${ANDROID_SYSROOT_ABI}/NEON")
+     else(ANDROID_ARM_NEON)
+         set(OTExtension_INSTALL_PREFIX "platforms/${ANDROID_PLATFORM}/arch-${ANDROID_SYSROOT_ABI}")
+     endif(ANDROID_ARM_NEON)
+     set(OTExtension_INSTALL_INCLUDE "${OTExtension_INSTALL_PREFIX}/include")
+     set(OTExtension_INSTALL_LIB "${OTExtension_INSTALL_PREFIX}/lib")
+     set(OTExtension_INSTALL_ARCHIVE "${OTExtension_INSTALL_PREFIX}/lib")
+     set(OTExtension_INSTALL_CONFIG "")
+else(ANDROID)
+     set(OTExtension_INSTALL_PREFIX "")
+     set(OTExtension_INSTALL_INCLUDE "include")
+     set(OTExtension_INSTALL_LIB "lib")
+     set(OTExtension_INSTALL_ARCHIVE "lib")
+     set(OTExtension_INSTALL_CONFIG "")
+endif(ANDROID)
+
+if(ANDROID AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    set(CMAKE_INSTALL_PREFIX "${ANDROID_NDK}/usr/local" 
+        CACHE PATH "Default install directory for android builds." FORCE)
 endif()
 
-option(OTEXTENSION_BUILD_EXE "Build executables" OFF)
-
-find_package(ENCRYPTO_utils QUIET)
-if(ENCRYPTO_utils_FOUND)
-    message(STATUS "Found ENCRYPTO_utils")
-elseif(NOT ENCRYPTO_utils_FOUND AND NOT TARGET ENCRYPTO_utils::encrypto_utils)
-    message("ENCRYPTO_utils was not found: add ENCRYPTO_utils subdirectory")
-    if(NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/ENCRYPTO_utils/CMakeLists.txt")
-        find_package(Git REQUIRED)
-        message("initialize Git submodule: extern/ENCRYPTO_utils")
-        execute_process(COMMAND git submodule update --init extern/ENCRYPTO_utils
-                        WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}")
-    endif()
-    add_subdirectory(extern/ENCRYPTO_utils)
-endif()
+include(AddRelic)
+include(AddENCRYPTO_utils)
 find_package(Threads REQUIRED)
 
 
-add_library(otextension
+add_library(otextension ${OTExtension_LIBRARY_TYPE}
     ot/alsz-ot-ext-rec.cpp
     ot/alsz-ot-ext-snd.cpp
 #    ot/asharov-lindell.cpp
@@ -43,52 +52,41 @@ add_library(otextension
 )
 add_library(OTExtension::otextension ALIAS otextension)
 
-target_compile_features(otextension PUBLIC cxx_std_17)
 target_compile_options(otextension PRIVATE "-Wall" "-Wextra")
 #target_compile_options(otextension PUBLIC "-fno-omit-frame-pointer" "-fsanitize=address")
 #target_link_options(otextension PUBLIC "-fno-omit-frame-pointer" "-fsanitize=address")
 
 target_include_directories(otextension
     PUBLIC
-        $<INSTALL_INTERFACE:include>
+        $<INSTALL_INTERFACE:${OTExtension_INSTALL_INCLUDE}>
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
 )
 
 
 target_link_libraries(otextension
     PUBLIC ENCRYPTO_utils::encrypto_utils
     PUBLIC Threads::Threads
+    PRIVATE Relic::relic
 )
 
 
+include(InstallConfig)
+install_config(OTExtension_INSTALL_LOCATION "${PROJECT_NAME}")
+
 install(TARGETS otextension
         EXPORT "${PROJECT_NAME}Targets"
-        ARCHIVE DESTINATION lib
-        LIBRARY DESTINATION lib
-        INCLUDES DESTINATION lib
-)
+        ARCHIVE DESTINATION "${OTExtension_INSTALL_ARCHIVE}"
+        LIBRARY DESTINATION "${OTExtension_INSTALL_LIB}"
+        INCLUDES DESTINATION "${OTExtension_INSTALL_INCLUDE}")
 install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/ot"
-        DESTINATION include
-        FILES_MATCHING PATTERN "*.h"
-)
-export(TARGETS otextension NAMESPACE "${PROJECT_NAME}::" FILE "${PROJECT_NAME}Targets.cmake")
+        DESTINATION "${OTExtension_INSTALL_INCLUDE}"
+        FILES_MATCHING REGEX ".*\\.h(pp|h)?$" REGEX ".*cmake.*" EXCLUDE)
+export(TARGETS otextension ${OTExtension_DEPENDENCIES_TO_EXPORT}
+       NAMESPACE "${PROJECT_NAME}::"
+       FILE "${PROJECT_NAME}Targets.cmake")
 install(EXPORT "${PROJECT_NAME}Targets"
         NAMESPACE "${PROJECT_NAME}::"
-        DESTINATION "lib/cmake/${PROJECT_NAME}"
-)
-
-
-include(CMakePackageConfigHelpers)
-
-configure_package_config_file("${CMAKE_CURRENT_LIST_DIR}/cmake/${PROJECT_NAME}Config.cmake.in"
-    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
-    INSTALL_DESTINATION "lib/cmake/${PROJECT_NAME}"
-)
-
-install(FILES
-    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
-    DESTINATION "lib/cmake/${PROJECT_NAME}"
-)
+        DESTINATION "${OTExtension_INSTALL_LOCATION}")
 
 if(OTEXTENSION_BUILD_EXE)
     add_subdirectory(mains)

cmake/BoostConfig.cmake.in

@@ -0,0 +1,5 @@
+get_filename_component(Boost_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+
+if(NOT TARGET Boost::boost)
+    include("${Boost_CMAKE_DIR}/BoostTargets.cmake")
+endif()

cmake/ForwardConfig.cmake.in

@@ -0,0 +1,14 @@
+include(CMakeFindDependencyMacro)
+set(INSTALL_NAME "@INSTALL_NAME@")
+if(ANDROID AND ANDROID_ARM_NEON)
+    set(PREFIX "${INSTALL_NAME}-${ANDROID_PLATFORM}-${ANDROID_SYSROOT_ABI}-NEON")
+elseif(ANDROID AND NOT ANDROID_ARM_NEON)
+    set(PREFIX "${INSTALL_NAME}-${ANDROID_PLATFORM}-${ANDROID_SYSROOT_ABI}")
+else()
+    set(PREFIX "${INSTALL_NAME}")
+endif()
+if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/${PREFIX}/${PREFIX}Config.cmake")
+    include("${CMAKE_CURRENT_LIST_DIR}/${PREFIX}/${PREFIX}Config.cmake")
+else()
+    set(${INSTALL_NAME}_FOUND FALSE)
+endif()

cmake/ImportIntoAndroidStudio.cmake

@@ -0,0 +1,18 @@
+
+function(import_into_android_studio IMPORT_LOCATION)
+    if(ANDROID AND EXISTS "${IMPORT_LOCATION}")
+        foreach(target ${TARGETS})
+            get_target_property(library_type ${target} TYPE)
+            if("${library_type}" STREQUAL "SHARED_LIBRARY")
+                get_target_property(lib_location ${target} LOCATION)
+                file(COPY "${lib_location}" DESTINATION "${IMPORT_LOCATION}")
+            endif()
+        endforeach()
+    endif()
+endfunction()
+
+if(NOT IMPORT_LOCATION)
+    import_into_android_studio("${PROJECT_SOURCE_DIR}/../jniLibs/${ANDROID_ABI}")
+else()
+    import_into_android_studio("${IMPORT_LOCATION}")
+endif()

cmake/Modules/AddENCRYPTO_utils.cmake

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.13)
+
+set(ENCRYPTO_utils_SOURCE CACHE PATH "Path to ENCRYPTO_utils source.")
+set(ENCRYPTO_utils_REPOSITORY https://github.com/oliver-schick/ENCRYPTO_utils.git CACHE STRING "Git repository of ENCRYPTO_utils project.")
+set(ENCRYPTO_utils_TAG origin/master CACHE STRING "Git tag of downloaded ENCRYPTO_utils project.")
+#Specific commit hash. Please regularly update to maintain compatibility with ABY.
+set(ENCRYPTO_utils_URL https://github.com/oliver-schick/ENCRYPTO_utils/archive/a1e60a51e23b2b81a7cecf6bfacb24952275a0a7.zip CACHE STRING "URL of ENCRYPTO_utils project.")
+#sha256sum of downloaded file. To get it on linux simply type following command line:
+#$ wget -O out [URL] && sha256sum out
+set(ENCRYPTO_utils_URL_HASH SHA256=b43e0a2626d351bf190931bddf9974860cf298727d23d20c75ef6f83302fb18b CACHE STRING "Hash of ENCRYPTO_utils archive.")
+option(DOWNLOAD_ENCRYPTO_utils "Set this option to download a specific commit of ENCRYPTO_utils." OFF)
+mark_as_advanced(ENCRYPTO_utils_REPOSITORY ENCRYPTO_utils_TAG ENCRYPTO_utils_URL ENCRYPTO_utils_URL_HASH DOWNLOAD_ENCRYPTO_utils)
+
+if(NOT TARGET ENCRYPTO_utils::encrypto_utils)
+    if(NOT ENCRYPTO_utils_LIBRARY_TYPE)
+        set(ENCRYPTO_utils_LIBRARY_TYPE ${OTExtension_LIBRARY_TYPE})
+    endif()
+    file(GLOB ENCRYPTO_utils_FILE_LIST "${PROJECT_SOURCE_DIR}/extern/ENCRYPTO_utils/*")
+    list(LENGTH ENCRYPTO_utils_FILE_LIST ENCRYPTO_utils_NUM_FILES)
+    #if ENCRYPTO_utils directory is empty
+    if(ENCRYPTO_utils_NUM_FILES EQUAL 0)
+        message(STATUS "ENCRYPTO_utils was not found. Fetching ENCRYPTO_utils...")
+        include(FetchENCRYPTO_utils)
+    else()
+        message(STATUS "ENCRYPTO_utils was found in: ${PROJECT_SOURCE_DIR}/extern/ENCRYPTO_utils")
+        set(ENCRYPTO_utils_SOURCE "${PROJECT_SOURCE_DIR}/extern/ENCRYPTO_utils"
+            CACHE PATH 
+            "Path to ENCRYPTO_utils source."
+            FORCE
+        )
+        include(FetchENCRYPTO_utils)
+    endif()
+endif()

cmake/Modules/AddRelic.cmake

@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.13)
+
+find_package(Relic QUIET)
+if(Relic_FOUND OR TARGET Relic::relic)
+    message(STATUS "Found Relic.")
+elseif(NOT Relic_FOUND AND NOT TARGET Relic::relic)
+    if(ANDROID)
+        set(Relic_LIBRARY_TYPE "STATIC")
+    else()
+        set(Relic_LIBRARY_TYPE "${ENCRYPTO_utils_LIBRARY_TYPE}")
+    endif()
+    set(LABEL "aby")
+    set(DEBUG off CACHE BOOL "Build relic with debugging support")
+    set(PROFL off CACHE BOOL "Build relic with profiling support")
+    set(CHECK off CACHE BOOL "Build relic with error-checking support")
+    set(ALIGN "16" CACHE STRING "Relic align")
+    set(ARITH CACHE STRING "arithmetic utils used in relic")
+    set(FB_POLYN ${ecclvl} CACHE INTEGER "security level of the ecc binary curve in relic")
+    set(FB_METHD "INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;QUICK;SLIDE;QUICK" CACHE STRING "Methods for fb in relic")
+    set(FB_PRECO on CACHE BOOl "fb preco for relic")
+    set(FB_SQRTF off CACHE BOOL "sqrtf for relic")
+    set(EB_METHD "PROJC;LODAH;COMBS;INTER" CACHE STRING "Methods for eb in relic")
+    set(EC_METHD "CHAR2" CACHE STRING "Methods for ec in relic")
+    set(TIMER "CYCLE" CACHE STRING "Relic timer")
+    set(TESTS "0" CACHE STRING "Relic amount of random tests, 0 for disable")
+    set(BENCH "0" CACHE STRING "Relic amount of benchmarks on random values, 0 for disable")
+    set(WITH "MD;DV;BN;FB;EB;EC" CACHE STRING "Relic algorithms")
+    if(Relic_LIBRARY_TYPE STREQUAL "STATIC")
+        set(SHLIB off CACHE BOOL "Relic shared library")
+        set(STLIB on CACHE BOOL "Relic static library")
+    elseif(Relic_LIBRARY_TYPE STREQUAL "SHARED")
+        set(SHLIB on CACHE BOOL "Relic shared library")
+        set(STLIB off CACHE BOOL "Relic static library")
+    endif()
+    if(ANDROID AND (ANDROID_ABI STREQUAL "armeabi-v7a" OR ANDROID_ABI STREQUAL "x86" OR ANDROID_ABI STREQUAL "mips"))
+        set(WSIZE "32" CACHE STRING "Relic word size in bits")
+    else()
+        set(WSIZE "64" CACHE STRING "Relic word size in bits")
+    endif()
+    if(ANDROID)
+        set(COMP "-O3 -funroll-loops -fomit-frame-pointer" CACHE STRING "Relic compiler options")
+        set(OPSYS "DROID")
+        if(Relic_LIBRARY_TYPE STREQUAL "SHARED")
+            set(TMP ${CMAKE_SHARED_LINKER_FLAGS})
+            string(REPLACE "-Wl,--warn-shared-textrel" "" CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS})
+        endif()
+        if(ANDROID_ABI STREQUAL "armeabi-v7a")
+            set(ARITH "arm-asm-254")
+            set(ARCH "ARM")
+        elseif(ANDROID_ABI STREQUAL "arm64-v8a")
+            set(ARITH "arm-asm-254")
+            set(ARCH "")
+        elseif(ANDROID_ABI STREQUAL "x86")
+            set(ARITH "fiat")
+            set(ARCH "X86")
+        elseif(ANDROID_ABI STREQUAL "x86_64")
+            set(ARITH "fiat")
+            set(ARCH "X64")
+        endif()
+    else()
+        set(COMP "-O3 -funroll-loops -fomit-frame-pointer -march=core2 -msse4.2 -mpclmul" CACHE STRING "Relic compiler options")
+        set(ARITH "curve2251-sse")
+        set(ARCH "X64" CACHE STRING "Architecture to be used in relic")
+    endif()
+    file(GLOB Relic_FILE_LIST "${PROJECT_SOURCE_DIR}/extern/Relic/*")
+    list(LENGTH Relic_FILE_LIST Relic_NUM_FILES)
+    #if Relic directory is empty
+    if(Relic_NUM_FILES EQUAL 0)
+        message(STATUS "Relic was not found. Fetching Relic...")
+    else()
+        message(STATUS "Relic was found in: ${PROJECT_SOURCE_DIR}/extern/Relic")
+        set(Relic_SOURCE "${PROJECT_SOURCE_DIR}/extern/Relic"
+            CACHE PATH 
+            "Path to Relic source."
+            FORCE
+        )
+    endif()
+    include(FetchRelic)
+    if(ANDROID AND Relic_LIBRARY_TYPE STREQUAL "SHARED")
+        set(CMAKE_SHARED_LINKER_FLAGS ${TMP})
+    endif()  
+    include(ExternalBuildHelper)
+    install_imported_library(Relic::relic "Relic")
+
+endif()

cmake/Modules/AndroidCacheVariables.cmake

@@ -0,0 +1,45 @@
+set(ANDROID_NDK CACHE PATH "Path to Android NDK.")
+set(ANDROID_NATIVE_API_LEVEL CACHE STRING "Android API level to compile for. Acceptable values are: [0-9]+ or android-[0-9]+")
+set(ANDROID_PLATFORM CACHE STRING "Alternative way to set Android API level. Acceptable values are: latest or android-[0-9]+")
+set(ANDROID_TOOLCHAIN_FILE CACHE PATH "Android toolchain file.")
+set(ANDROID_ABI CACHE STRING "Target CPU of android device, like e.g. \"armeabi-v7a\".")
+set_property(CACHE ANDROID_ABI PROPERTY STRINGS
+    "armeabi-v7a" 
+    "armeabi-v7a with NEON"
+    "arm64-v8a"
+    "x86"
+    "x86_64"
+)
+
+#Check if user wants to build for Android
+if(NOT "${CMAKE_ANDROID_NDK}" STREQUAL "")
+    set(ANDROID_NDK "${CMAKE_ANDROID_NDK}")
+endif()
+if(NOT "${ANDROID_NDK}" STREQUAL "")
+    set(ANDROID ON)
+elseif(NOT "${ANDROID_TOOLCHAIN_FILE}" STREQUAL "" AND EXISTS "${ANDROID_TOOLCHAIN_FILE}")
+    set(ANDROID ON)
+elseif(NOT "${CMAKE_TOOLCHAIN_FILE}" STREQUAL "" AND EXISTS "${CMAKE_TOOLCHAIN_FILE}")
+    set(ANDROID ON)
+endif()
+
+#Set CMAKE_TOOLCHAIN_FILE and CMAKE_INSTALL_PREFIX for Android builds
+if(ANDROID)
+    #CMAKE_TOOLCHAIN_FILE was not set, but ANDROID_TOOLCHAIN_FILE was set
+    if("${CMAKE_TOOLCHAIN_FILE}" STREQUAL "" AND NOT "${ANDROID_TOOLCHAIN_FILE}" STREQUAL "")
+        set(CMAKE_TOOLCHAIN_FILE "${ANDROID_TOOLCHAIN_FILE}")
+    #Neither toolchain file was set, use toolchain in NDK
+    elseif("${CMAKE_TOOLCHAIN_FILE}" STREQUAL "" AND "${ANDROID_TOOLCHAIN_FILE}" STREQUAL "")
+        set(CMAKE_TOOLCHAIN_FILE "${ANDROID_NDK}/build/cmake/android.toolchain.cmake")
+    else()
+        set(ANDROID_TOOLCHAIN_FILE "${CMAKE_TOOLCHAIN_FILE}")
+    endif()
+    if(NOT EXISTS "${CMAKE_TOOLCHAIN_FILE}")
+        message(FATAL_ERROR 
+            "Could not find file: ${CMAKE_TOOLCHAIN_FILE}. Your NDK might be outdated."
+        )
+    endif()
+    if(NOT CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+        set(CMAKE_INSTALL_PREFIX "${ANDROID_NDK}" CACHE PATH "Default install directory for android builds." FORCE)
+    endif()
+endif(ANDROID)

cmake/Modules/FetchENCRYPTO_utils.cmake

@@ -0,0 +1,4 @@
+cmake_minimum_required(VERSION 3.13)
+
+include(FetchHelper)
+fetch_helper(ENCRYPTO_utils)

cmake/Modules/FetchHelper.cmake

@@ -0,0 +1,45 @@
+cmake_minimum_required(VERSION 3.13)
+macro(fetch_helper content_name)
+    string(TOLOWER "${content_name}" LOWER_CASE_${content_name})
+    if(NOT "${DEPENDENCY_DIR}" STREQUAL "")
+        set(${content_name}_DOWNLOAD_DIR_COMMAND DOWNLOAD_DIR ${DEPENDENCY_DIR})
+    else()
+        set(${content_name}_DOWNLOAD_DIR_COMMAND "")
+    endif()
+    if(NOT "${${content_name}_SOURCE}" STREQUAL "")
+        set(${content_name}_DOWNLOAD_COMMAND1 URL ${${content_name}_SOURCE})
+        set(${content_name}_DOWNLOAD_COMMAND2 "")
+    elseif(DOWNLOAD_${content_name} OR "${${content_name}_REPOSITORY}" STREQUAL "")
+        set(${content_name}_DOWNLOAD_COMMAND1 URL ${${content_name}_URL})
+        set(${content_name}_DOWNLOAD_COMMAND2 URL_HASH ${${content_name}_URL_HASH})
+    else()
+        set(${content_name}_DOWNLOAD_COMMAND1 GIT_REPOSITORY ${${content_name}_REPOSITORY})
+        set(${content_name}_DOWNLOAD_COMMAND2 GIT_TAG ${${content_name}_TAG})
+    endif()
+    include(FetchContent)
+    FetchContent_Declare(${content_name}
+        ${${content_name}_DOWNLOAD_COMMAND1}
+        ${${content_name}_DOWNLOAD_COMMAND2}
+        ${${content_name}_DOWNLOAD_DIR_COMMAND}
+    )
+    FetchContent_GetProperties(${content_name})
+    if(NOT ${LOWER_CASE_${content_name}}_POPULATED)
+        FetchContent_Populate(${content_name})
+        if(NOT "${ARGV1}" STREQUAL "")
+            message(STATUS "Applying patches to ${content_name}...")
+            include("Patch${content_name}")
+        endif()
+        if(NOT "${ARGV2}" STREQUAL "")
+            add_subdirectory(
+                ${${LOWER_CASE_${content_name}}_SOURCE_DIR} 
+                ${${LOWER_CASE_${content_name}}_BINARY_DIR}
+                EXCLUDE_FROM_ALL
+            )
+        else()
+            add_subdirectory(
+                ${${LOWER_CASE_${content_name}}_SOURCE_DIR} 
+                ${${LOWER_CASE_${content_name}}_BINARY_DIR}
+            )
+        endif()
+    endif()
+endmacro()