Comstackndo el último OpenSSL para Android

Estoy intentando generar la biblioteca compartida para los archivos (.so) de OpenSSL1.0.1c para Android. Descubrí que agregaron tres opciones para comstackr para Android en la secuencia de comandos de Android.

./Configure android-armv7 (or) ./Configure android-x86 (or) ./Configure android 

una vez que configuré para el SO y luego trato de comstackr, sus errores de lanzamiento. Actualmente estoy trabajando x86 windows7 e instalado Cygwin, Android SDK R20, Android NDK r8

 sh-4.1$ make making all in crypto... make[1]: Entering directory `/cygdrive/d/SourceCodes/OpenSSL/openssl-1.0.1c/crypto' gcc -I. -I.. -I../include -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -march=armv7-a -mandroid -I/include -B/lib -O3 -fomit-frame-pointer -Wall -DOPENSSL_BN_ASM_MONT -DOP ENSSL_BN_ASM_GF2m -DSHA1_ASM -DSHA256_ASM -DSHA512_ASM -DAES_ASM -DGHASH_ASM -c -o cryptlib.o cryptlib.c cc1: error: unrecognized command line option "-mandroid" cryptlib.c:1:0: error: bad value (armv7-a) for -march= switch : recipe for target `cryptlib.o' failed make[1]: *** [cryptlib.o] Error 1 make[1]: Leaving directory `/cygdrive/d/SourceCodes/OpenSSL/openssl-1.0.1c/crypto' Makefile:278: recipe for target `build_crypto' failed make: *** [build_crypto] Error 1 sh-4.1$ 

Por favor, avíseme si alguien se enfrentó a un problema similar y obtuvo la solución para resolverlo.

En serio, no aconsejaría tomar nada fuera del sitio web oficial de OpenSSL. No puede arriesgarse cuando se trata de criptografía y seguridad.

El único problema que veo es que estás usando el gcc de tu host en lugar de usar los comstackdores cruzados de Android.

Aquí es cómo comstackría el OpenSSL oficial en Ubuntu 14.04LTS (esto funciona con OpenSSL 1.0.1g)

Desde su carpeta de inicio, ejecute los siguientes comandos:

 tar xzvf ~/Downloads/openssl-1.0.1g.tar.gz cd openssl-1.0.1g export NDK=~/android-ndk-r9d $NDK/build/tools/make-standalone-toolchain.sh --platform=android-9 --toolchain=arm-linux-androidabi-4.6 --install-dir=`pwd`/android-toolchain-arm export TOOLCHAIN_PATH=`pwd`/android-toolchain-arm/bin export TOOL=arm-linux-androidabi export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL} export CC=$NDK_TOOLCHAIN_BASENAME-gcc export CXX=$NDK_TOOLCHAIN_BASENAME-g++ export LINK=${CXX} export LD=$NDK_TOOLCHAIN_BASENAME-ld export AR=$NDK_TOOLCHAIN_BASENAME-ar export RANLIB=$NDK_TOOLCHAIN_BASENAME-ranlib export STRIP=$NDK_TOOLCHAIN_BASENAME-strip export ARCH_FLAGS="-march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16" export ARCH_LINK="-march=armv7-a -Wl,--fix-cortex-a8" export CPPFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export CXXFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 -frtti -fexceptions " export CFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export LDFLAGS=" ${ARCH_LINK} " 

Y luego ejecuta tu script de configuración:

 ./Configure android-armv7 

Y luego construir

 PATH=$TOOLCHAIN_PATH:$PATH make 

Debería ver que está utilizando arm-linux-androidabi-gcc lugar de gcc

Para construir para el viejo Armeabi:

 tar xzvf ~/Downloads/openssl-1.0.1g.tar.gz cd openssl-1.0.1g export NDK=~/android-ndk-r9d $NDK/build/tools/make-standalone-toolchain.sh --platform=android-9 --toolchain=arm-linux-androidabi-4.6 --install-dir=`pwd`/android-toolchain-arm export TOOLCHAIN_PATH=`pwd`/android-toolchain-arm/bin export TOOL=arm-linux-androidabi export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL} export CC=$NDK_TOOLCHAIN_BASENAME-gcc export CXX=$NDK_TOOLCHAIN_BASENAME-g++ export LINK=${CXX} export LD=$NDK_TOOLCHAIN_BASENAME-ld export AR=$NDK_TOOLCHAIN_BASENAME-ar export RANLIB=$NDK_TOOLCHAIN_BASENAME-ranlib export STRIP=$NDK_TOOLCHAIN_BASENAME-strip export ARCH_FLAGS="-mthumb" export ARCH_LINK= export CPPFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export CXXFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 -frtti -fexceptions " export CFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export LDFLAGS=" ${ARCH_LINK} " ./Configure android make clean PATH=$TOOLCHAIN_PATH:$PATH make 

para construir para x86:

 tar xzvf ~/Downloads/openssl-1.0.1g.tar.gz cd openssl-1.0.1g export NDK=~/android-ndk-r9d $NDK/build/tools/make-standalone-toolchain.sh --platform=android-9 --toolchain=x86-4.6 --install-dir=`pwd`/android-toolchain-x86 export TOOLCHAIN_PATH=`pwd`/android-toolchain-x86/bin export TOOL=i686-linux-android export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL} export CC=$NDK_TOOLCHAIN_BASENAME-gcc export CXX=$NDK_TOOLCHAIN_BASENAME-g++ export LINK=${CXX} export LD=$NDK_TOOLCHAIN_BASENAME-ld export AR=$NDK_TOOLCHAIN_BASENAME-ar export RANLIB=$NDK_TOOLCHAIN_BASENAME-ranlib export STRIP=$NDK_TOOLCHAIN_BASENAME-strip export ARCH_FLAGS="-march=i686 -msse3 -mstackrealign -mfpmath=sse" export ARCH_LINK= export CPPFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export CXXFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 -frtti -fexceptions " export CFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export LDFLAGS=" ${ARCH_LINK} " ./Configure android-x86 make clean PATH=$TOOLCHAIN_PATH:$PATH make 

En OpenSSL 1.0.1e, todo lo que necesito hacer es:

 CC=~/android-ndk-r9/toolchains/arm-linux-androidabi-4.8/prebuilt/darwin-x86_64/bin/arm-linux-androidabi-gcc ./Configure android-armv7 ANDROID_DEV=~/android-ndk-r9//platforms/android-8/arch-arm/usr make build_libs 

Gracias a las instrucciones publicadas aquí, además de algunas otras adiciones, hice un script automatizado que comstack la última biblioteca OpenSSL para Android con soporte para: armeabi, armeabi-v7a, x86, x86_64 y arm64-v8a:

 #!/bin/bash -e #@author Aleksandar Gotev (alex.gotev@mobimesh.it) #Hints and code taken also from http://stackoverflow.com/questions/11929773/compiling-the-latest-openssl-for-android if [ "$#" -ne 6 ] then echo "Usage:" echo "./openssl-build    \\" echo "   " echo echo "Supported target ABIs: armeabi, armeabi-v7a, x86, x86_64, arm64-v8a" echo echo "Example using GCC 4.8, NDK 10e, OpenSSL 1.0.2d and Android API 21 for armeabi-v7a." echo "./openssl-build /home/user/android-ndk-r10e \\" echo " /home/user/openssl-1.0.2d \\" echo " 21 \\" echo " armeabi-v7a \\" echo " 4.8 \\" echo " /home/user/output/armeabi-v7a" exit 1 fi NDK_DIR=$1 OPENSSL_BASE_FOLDER=$2 OPENSSL_TARGET_API=$3 OPENSSL_TARGET_ABI=$4 OPENSSL_GCC_VERSION=$5 OPENSSL_OUTPUT_PATH=$6 NDK_MAKE_TOOLCHAIN="$NDK_DIR/build/tools/make-standalone-toolchain.sh" OPENSSL_TMP_FOLDER="/tmp/openssl" rm -rf "$OPENSSL_TMP_FOLDER" mkdir -p "$OPENSSL_TMP_FOLDER" cp -r ${OPENSSL_BASE_FOLDER} ${OPENSSL_TMP_FOLDER} function build_library { mkdir -p ${OPENSSL_OUTPUT_PATH} export PATH=$TOOLCHAIN_PATH:$PATH make && make install rm -rf ${OPENSSL_TMP_FOLDER} echo "Build completed! Check output libraries in ${OPENSSL_OUTPUT_PATH}" } if [ "$OPENSSL_TARGET_ABI" == "armeabi-v7a" ] then ${NDK_MAKE_TOOLCHAIN} --platform=android-${OPENSSL_TARGET_API} \ --toolchain=arm-linux-androidabi-${OPENSSL_GCC_VERSION} \ --install-dir="${OPENSSL_TMP_FOLDER}/android-toolchain-arm" export TOOLCHAIN_PATH="${OPENSSL_TMP_FOLDER}/android-toolchain-arm/bin" export TOOL=arm-linux-androidabi export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL} export CC=$NDK_TOOLCHAIN_BASENAME-gcc export CXX=$NDK_TOOLCHAIN_BASENAME-g++ export LINK=${CXX} export LD=$NDK_TOOLCHAIN_BASENAME-ld export AR=$NDK_TOOLCHAIN_BASENAME-ar export RANLIB=$NDK_TOOLCHAIN_BASENAME-ranlib export STRIP=$NDK_TOOLCHAIN_BASENAME-strip export ARCH_FLAGS="-march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16" export ARCH_LINK="-march=armv7-a -Wl,--fix-cortex-a8" export CPPFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export CXXFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 -frtti -fexceptions " export CFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export LDFLAGS=" ${ARCH_LINK} " cd ${OPENSSL_TMP_FOLDER} ./Configure android-armv7 --openssldir=${OPENSSL_OUTPUT_PATH} build_library elif [ "$OPENSSL_TARGET_ABI" == "arm64-v8a" ] then ${NDK_MAKE_TOOLCHAIN} --platform=android-${OPENSSL_TARGET_API} \ --toolchain=aarch64-linux-android-4.9 \ --install-dir="${OPENSSL_TMP_FOLDER}/android-toolchain-arm64" export TOOLCHAIN_PATH="${OPENSSL_TMP_FOLDER}/android-toolchain-arm64/bin" export TOOL=aarch64-linux-android export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL} export CC=$NDK_TOOLCHAIN_BASENAME-gcc export CXX=$NDK_TOOLCHAIN_BASENAME-g++ export LINK=${CXX} export LD=$NDK_TOOLCHAIN_BASENAME-ld export AR=$NDK_TOOLCHAIN_BASENAME-ar export RANLIB=$NDK_TOOLCHAIN_BASENAME-ranlib export STRIP=$NDK_TOOLCHAIN_BASENAME-strip export ARCH_FLAGS= export ARCH_LINK= export CPPFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export CXXFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 -frtti -fexceptions " export CFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export LDFLAGS=" ${ARCH_LINK} " cd ${OPENSSL_TMP_FOLDER} ./Configure android --openssldir=${OPENSSL_OUTPUT_PATH} build_library elif [ "$OPENSSL_TARGET_ABI" == "armeabi" ] then ${NDK_MAKE_TOOLCHAIN} --platform=android-${OPENSSL_TARGET_API} \ --toolchain=arm-linux-androidabi-${OPENSSL_GCC_VERSION} \ --install-dir="${OPENSSL_TMP_FOLDER}/android-toolchain-arm" export TOOLCHAIN_PATH="${OPENSSL_TMP_FOLDER}/android-toolchain-arm/bin" export TOOL=arm-linux-androidabi export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL} export CC=$NDK_TOOLCHAIN_BASENAME-gcc export CXX=$NDK_TOOLCHAIN_BASENAME-g++ export LINK=${CXX} export LD=$NDK_TOOLCHAIN_BASENAME-ld export AR=$NDK_TOOLCHAIN_BASENAME-ar export RANLIB=$NDK_TOOLCHAIN_BASENAME-ranlib export STRIP=$NDK_TOOLCHAIN_BASENAME-strip export ARCH_FLAGS="-mthumb" export ARCH_LINK= export CPPFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export CXXFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 -frtti -fexceptions " export CFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export LDFLAGS=" ${ARCH_LINK} " cd ${OPENSSL_TMP_FOLDER} ./Configure android --openssldir=${OPENSSL_OUTPUT_PATH} build_library elif [ "$OPENSSL_TARGET_ABI" == "x86" ] then ${NDK_MAKE_TOOLCHAIN} --platform=android-${OPENSSL_TARGET_API} \ --toolchain=x86-${OPENSSL_GCC_VERSION} \ --install-dir="${OPENSSL_TMP_FOLDER}/android-toolchain-x86" export TOOLCHAIN_PATH="${OPENSSL_TMP_FOLDER}/android-toolchain-x86/bin" export TOOL=i686-linux-android export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL} export CC=$NDK_TOOLCHAIN_BASENAME-gcc export CXX=$NDK_TOOLCHAIN_BASENAME-g++ export LINK=${CXX} export LD=$NDK_TOOLCHAIN_BASENAME-ld export AR=$NDK_TOOLCHAIN_BASENAME-ar export RANLIB=$NDK_TOOLCHAIN_BASENAME-ranlib export STRIP=$NDK_TOOLCHAIN_BASENAME-strip export ARCH_FLAGS="-march=i686 -msse3 -mstackrealign -mfpmath=sse" export ARCH_LINK= export CPPFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export CXXFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 -frtti -fexceptions " export CFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export LDFLAGS=" ${ARCH_LINK} " cd ${OPENSSL_TMP_FOLDER} ./Configure android-x86 --openssldir=${OPENSSL_OUTPUT_PATH} build_library elif [ "$OPENSSL_TARGET_ABI" == "x86_64" ] then ${NDK_MAKE_TOOLCHAIN} --platform=android-${OPENSSL_TARGET_API} \ --toolchain=x86_64-4.9 \ --install-dir="${OPENSSL_TMP_FOLDER}/android-toolchain-x86_64" export TOOLCHAIN_PATH="${OPENSSL_TMP_FOLDER}/android-toolchain-x86_64/bin" export TOOL=x86_64-linux-android export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL} export CC=$NDK_TOOLCHAIN_BASENAME-gcc export CXX=$NDK_TOOLCHAIN_BASENAME-g++ export LINK=${CXX} export LD=$NDK_TOOLCHAIN_BASENAME-ld export AR=$NDK_TOOLCHAIN_BASENAME-ar export RANLIB=$NDK_TOOLCHAIN_BASENAME-ranlib export STRIP=$NDK_TOOLCHAIN_BASENAME-strip export CPPFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export CXXFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 -frtti -fexceptions " export CFLAGS=" ${ARCH_FLAGS} -fpic -ffunction-sections -funwind-tables -fstack-protector -fno-strict-aliasing -finline-limit=64 " export LDFLAGS=" ${ARCH_LINK} " cd ${OPENSSL_TMP_FOLDER} ./Configure linux-x86_64 --openssldir=${OPENSSL_OUTPUT_PATH} build_library else echo "Unsupported target ABI: $OPENSSL_TARGET_ABI" exit 1 fi 

Documentos de script: https://github.com/alexbbb/pjsip-android-builder#build-only-openssl

Para la última versión, verifique: https://github.com/alexbbb/pjsip-android-builder/blob/master/openssl-build

He unido algunos consejos útiles aquí para un entorno de construcción para OpenSSL para Android que funciona para mí.

  • Admite construcción para múltiples architectures: ARM, ARMv7, X86
  • Utiliza códigos fuente OpenSSL
  • Integrado con la construcción de Android.mk
  • Contiene OpenSSL 1.0.2h precomstackdo (use si quiere o compile el suyo)

https://github.com/ph4r05/android-openssl

En caso de que alguien encuentre el problema de utilizar una versión vulnerable de OpenSSL ( < 1.0.2f/1.0.1r ) en una de las bibliotecas nativas, agrego algunos detalles e instrucciones.

Condiciones previas: Android NDK debe configurarse primero.

  1. En primer lugar, descargue la versión compatible con OpenSSL ( > 1.0.2f/1.0.1r ).
  2. Descarga dos scripts desde este enlace . En caso de que alguien se pregunte qué hacen (y debería hacerlo, ¡es una biblioteca criptográfica!): Construyen la biblioteca OpenSSL para cada architecture de procesador Android ABI ( armeabi , x86 , mips , etc.)

  3. Modificar setenv-android-mod.sh -> línea 18 con la versión ndk

  4. Modificar setenv-android-mod.sh -> línea 40 con la versión API de Android

  5. Modifique build-all-arch.sh -> línea 7 con el nombre de la carpeta de la biblioteca OpenSSL (en mi caso fue openssl-1.0.1t )

  6. Después de la comstackción exitosa, dentro de la carpeta dist las bibliotecas estarán presentes

Para agregar el openSSL para proyectar como bibliotecas estáticas openSSL , cree:

  1. carpeta openssl en el directorio jni contiene lib/ (que contiene los archivos .a para las architectures compatibles),
  2. include/ which tiene los includes necesarios (puede encontrar que bajo la versión de openssl que descargó, tenga en cuenta que algunos de los archivos de encabezado son enlaces simbólicos)
  3. Modifique Android.mk dentro de la carpeta jni agregando lo siguiente:

     include $(CLEAR_VARS) LOCAL_MODULE := libssl LOCAL_SRC_FILES := lib/$(TARGET_ARCH_ABI)/libssl.a include $(PREBUILT_STATIC_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := libcrypto LOCAL_SRC_FILES := lib/$(TARGET_ARCH_ABI)/libcrypto.a include $(PREBUILT_STATIC_LIBRARY) 

Luego, para usar la biblioteca dentro de otro módulo jni , agregue lo siguiente a su archivo Android.mk :

 LOCAL_C_INCLUDES := $(LOCAL_PATH)/../openssl/include LOCAL_STATIC_LIBRARIES := libssl libcrypto 

Esto no resuelve su problema, pero quizás ayude. Una publicación de Google Groups donde han comstackdo con éxito OpenSSL 1.0.1 beta2 para Android.

https://groups.google.com/forum/?fromgroups#!topic/android-security-discuss/5-_gCAmEo-M

Esto también podría ayudar, un proyecto de código abierto que comstack 1.0.0a para Android:

https://github.com/eighthave/openssl-android

Así es como lo hice para openssl-1.0.2g:

 $ rm -rf openssl-1.0.2g/ $ tar xzf openssl-1.0.2g.tar.gz $ chmod a+x setenv-android.sh $ . ./setenv-android.sh ---> Note: make sure in the same folder of your openssl-1.0.2g $ cd openssl-1.0.2g/ $ perl -pi -e 's/install: all install_docs install_sw/install: install_docs install_sw/g' Makefile.org $ ./config shared no-ssl2 no-ssl3 no-comp no-hw no-engine --openssldir= $ make depend $ make clean $ make all before make install, ---Delete the "include" folder (path/of/your/openssl-1.0.2g/include) or you may move it to another directory for safe keeping. $ make install 

Asegúrese de ingresar las rutas correctas NDK en su setenv-android.sh o de lo contrario tendrá errores.

Ejemplo para esta comstackción utilicé Android NDK vr10b ( http://dl.google.com/android/ndk/android-ndk32-r10b-darwin-x86.tar.bz2 ) y usé los valores de ruta ff dentro de mi setenv-android. archivo sh:

 _ANDROID_NDK="android-ndk-r10b" (Line 12) _ANDROID_EABI="arm-linux-androidabi-4.8"(Line 16) _ANDROID_API="android-19"(Line 24) 

Referencia: https://wiki.openssl.org/index.php/Android

Nota —> Creé un commit de github para responder esta pregunta, por favor consulte: https://github.com/rjmangubat23/OpenSSL

Cargué los diferentes scripts para setenv-android.sh en mi github, porque necesitará diferentes tipos de scripts para diferentes architectures:

Para x86: https://github.com/rjmangubat23/OpenSSL/tree/master/x86

Para ArmV7: https://github.com/rjmangubat23/OpenSSL/tree/master/ArmV7

Descargue Openssl aquí: ftp://ftp.openssl.org/source

Descargue la lista completa de archivos Android NDK aquí: https://github.com/taka-no-me/android-cmake/blob/master/ndk_links.md

Puede usar esta secuencia de comandos para comstackr openssl en Windows 7 + Cygwin. Todo lo que necesitas es solo cambiar la ubicación de ndk y elegir la versión de Android api.

Mi camino paso a paso (Win 7 x64 + Cygwin + ndk r10c)

  1. Copie el archivo setenv-android-mod.sh y build-all-arch.sh en su directorio de openssl.

  2. Modificar el archivo build-all-arch.sh

    • cd openssl-1.0.1j a #cd openssl-1.0.1j (línea 56)

    • cd .. a #cd .. (línea 80)

  3. Modificar el archivo setend-android-mod.sh

    • _ANDROID_NDK="android-ndk-r10c-x64" cambia a su versión ndk (línea 18)
    • _ANDROID_API="android-19" cambia a su versión de API (línea 40)
    • ANDROID_NDK_ROOT="d:/work/android/android-ndk-r10c-x64" especifique su directorio (línea 42)
    • ANDROID_TOOLCHAIN="d:/work/android/android-ndk-r10c-x64/toolchains" especifique su directorio (línea 43)
    • export CROSS_COMPILE="aarch64-linux-android-" para export CROSS_COMPILE="$ANDROID_TOOLCHAIN/aarch64-linux-android-" (línea 219), cambiar las mismas líneas 225, 231, 237, 243 – simplemente agregue $ANDROID_TOOLCHAIN/ a la cruz comstackr camino

Ejecute build-all-arch.sh .

Todas las bibliotecas ( *.so ) estarán ubicadas en /prebuilt/ dir.

PD: tuve algunos errores más debido a los enlaces simbólicos incorrectos, pero todo estuvo bien después de ejecutar el siguiente comando export CYGWIN="winsymlinks:native" ver aquí para más detalles.

Este problema y muchos otros me causaron una semana más o menos de burla, pero finalmente lo descifré, así que pensé en compartir mi solución. OpenSSL se puede comstackr para mayores de 21 años y funcionar en dispositivos Android 4.03 si está dispuesto a hackear el código. Usamos libcurl, así que queríamos estar actualizados. Los pasos son un poco complejos:

Primero asegúrese de tener una versión editable de libcurl. Recomiendo como un buen punto de partida https://github.com/cocos2d/cocos2d-x-3rd-party-libs-src

Mantienen las secuencias de comandos de comstackción actualizadas.

Primero hackear el android.ini en “comstackción” a la versión 21

A continuación, tuve que agregar las siguientes funciones de código auxiliar al proyecto jni en alguna parte:

 // SPECIAL API 21+ functions required for android to build on newer platform targets. float strtof (const char* str, char** endptr) { return (float)strtod(str, endptr); } int __isnanf(float x) { return (x != x); } double atof (const char* s) { double rez = 0, fact = 1; if (*s == '-'){ s++; fact = -1; }; for (int point_seen = 0; *s; s++){ if (*s == '.'){ point_seen = 1; continue; }; int d = *s - '0'; if (d >= 0 && d <= 9){ if (point_seen) fact /= 10.0f; rez = rez * 10.0f + (float)d; }; }; return rez * fact; } void srandom(unsigned int seed) { std::srand(seed); } static unsigned long _next = 1; void srand(unsigned int seed) { _next = seed; } long random() { return rand(); } int rand() { _next = _next * 1103515245 + 12345; return (unsigned int)(_next/65536) % 32768; } /* the default is bsd */ __sighandler_t signal(int s, __sighandler_t f) { return 0; } 

Tenga en cuenta que la función de señal podría ser mejor, pero para nosotros no es importante. Esto detiene los temidos errores "no se puede ubicar el símbolo" en dispositivos 4.03 causados ​​por cambios en los encabezados en 5+ ( https://groups.google.com/forum/#!topic/android-ndk/RjO9WmG9pfE ).

A continuación, descargue tar.gz para la versión de openssl que desea construir y descomprímalo en algún lugar. Edite crypto / ui / ui_openssl.c y crypto / des / read_pwd.c y asegúrese de que #defines para tcsetattr no se usen. Utilicé una fuerza bruta #if 0 y #if 1 - note que esto debería ser posible haciendo girar el preprocesador, pero me di por vencido en este momento. Si alguien tiene ganas de compartir la magia correcta, ¡por favor hazlo!

Ahora necesita volver a subir el archivo en el archivo tarballs (asegurándose de que tenga su carpeta raíz allí:

y correr (en mi caso)

shasum -a 512 curl-7.50.0.tar.gz> ../src/curl/SHA512SUMS

Esto permitirá que cocos2d ./build.sh se ejecute. Algo como:

./build.sh -p = android --libs = openssl, curl --arch = armv7 --mode = lanzamiento

Finalmente, y esto me sorprendió en términos de crear un archivo .a universal, pero no es directamente parte de la pregunta, asegúrese de usar una versión que no use las instrucciones NEON. Los dispositivos Tegra 2 aparentemente tienen FPU pero no NEON. Creo que esto se puede hacer utilizando -mfpu = vfp como indicador del comstackdor, pero opté por usar el build de armv5, ya que el rendimiento no es realmente importante para mí en esta área (y he tenido suficientes sorpresas desagradables del mundo real de este ya).

Al final, deberías obtener un buen archivo .a que funcione en todas partes y se pueda utilizar en proyectos que tengan como objective el último y mejor Android. ¡Ahora si solo alguien del proyecto OpenSSL puede leer esto y arreglar el proyecto para que comprenda las cosas de Android lanzadas hace 2 años!

¡Buena suerte!

Aquí es cómo construir OpenSSL en Windows usando Cygwin y Android NDK

  1. Descargue y extraiga la fuente OpenSSL
  2. Descargar el script desde https://github.com/pstanoev/OpenSSL-For-Android
  3. Ejecute cmd con el usuario Administrador y ejecute

    SET CYGWIN=winsymlinks:nativestrict

  4. En la misma ventana de cmd, abra Cygwin:

    cygwin.bat

  5. Hacer script ejecutable:

    chmod +x *.sh

  6. En Cygwin ejecuta:

    /cygdrive/c/dev/openssl-source/openssl-build.sh /cygdrive/c/dev/android-ndk-r12b /cygdrive/c/dev/openssl-source/openssl-1.0.2j 15 armeabi-v7a 4.9 /home/user/openssl

    • Modificar para sus ubicaciones de Android NDK y fonts
  7. Copie libcrypto.so e incluya / * archivos en este módulo. Use cp -r para copiar y seguir enlaces.