Compiler Le Dernier OpenSSL pour Android

Je ne conseillerais vraiment pas de prendre quoi que ce soit en dehors du site officiel D'OpenSSL. Vous ne pouvez pas prendre une chance en traitant la cryptographie et la sécurité.

le seul problème que je vois est que vous utilisez le gcc de votre hôte plutôt que les compilateurs croisés d'android.

Voici comment je compilerais L'OpenSSL officiel sur Ubuntu 14.04 LTS (cela fonctionne avec OpenSSL 1.0.1 g)

à partir de votre dossier personnel, Lancez commandes suivantes:

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-androideabi-4.6 --install-dir=`pwd`/android-toolchain-arm
export TOOLCHAIN_PATH=`pwd`/android-toolchain-arm/bin
export TOOL=arm-linux-androideabi
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} "

puis lancez votre script de configuration:

./Configure android-armv7

puis construire

PATH=$TOOLCHAIN_PATH:$PATH make

vous devriez voir qu'il utilise arm-linux-androideabi-gcc au lieu de gcc

à construire pour l'ancienne 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-androideabi-4.6 --install-dir=`pwd`/android-toolchain-arm
export TOOLCHAIN_PATH=`pwd`/android-toolchain-arm/bin
export TOOL=arm-linux-androideabi
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

à construire pour 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

dans OpenSSL 1.0.1 e, Tout ce que je dois faire est:

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

grâce aux instructions affichées ici, plus quelques autres ajouts, j'ai fait un script automatisé qui compile la dernière bibliothèque OpenSSL pour Android avec le soutien pour: armeabi, armeabi-v7a, x86, x86_64 et arm64 - v8a:

#!/bin/bash -e
#@author Aleksandar Gotev (alex.gotev@mobimesh.it)
#Hints and code taken also from /q/compiling-the-latest-openssl-for-android-75348/"$#" -ne 6 ]
then
    echo "Usage:"
    echo "./openssl-build <ANDROID_NDK_PATH> <OPENSSL_SOURCES_PATH> <ANDROID_TARGET_API> \"
    echo "                <ANDROID_TARGET_ABI> <GCC_VERSION> <OUTPUT_PATH>"
    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=
OPENSSL_BASE_FOLDER=
OPENSSL_TARGET_API=
OPENSSL_TARGET_ABI=
OPENSSL_GCC_VERSION=
OPENSSL_OUTPUT_PATH=

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-androideabi-${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-androideabi
    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-androideabi-${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-androideabi
    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

Script docs: https://github.com/alexbbb/pjsip-android-builder#build-only-openssl

pour la dernière version, Vérifiez: https://github.com/alexbbb/pjsip-android-builder/blob/master/openssl-build

j'ai collé ici quelques conseils utiles à un environnement de construction pour OpenSSL pour Android qui fonctionne pour moi.

• prend en charge la construction pour plusieurs architectures-ARM, ARMv7, X86
• utilise les codes source OpenSSL
• intégré avec Android.MK build
• Contient pré-compilé OpenSSL 1.0.2 h (utiliser si vous souhaitez ou faire votre propre)

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

dans le cas où quelqu'un rencontre le problème d'utiliser la version vulnérable D'OpenSSL ( < 1.0.2f/1.0.1r ) dans une des bibliothèques natives, j'ajoute plus de détails et d'instructions.

conditions préalables: Android NDK doit être configuré en premier.

1. tout d'abord, téléchargez la version compatible OpenSSL ( > 1.0.2f/1.0.1r ).

2. téléchargez deux scripts à partir de ce lien . Dans cas quelqu'un se demande ce qu'ils font (et vous devriez - c'est une bibliothèque cryptographique!!!): Ils construisent la bibliothèque OpenSSL pour chaque architecture de processeur ABI android( armeabi , x86 , mips , etc...)

3. modifier setenv-android-mod.sh - > ligne 18 avec la version ndk

4. modifier setenv-android-mod.sh - > ligne 40 avec la version API Android

5. modifier build-all-arch.sh - > ligne 7 avec le nom de dossier de la bibliothèque OpenSSL (dans mon cas c'était openssl-1.0.1t )

6. après la compilation réussie, dans le dossier dist les bibliothèques seront présentes

pour ajouter le openSSL pour projeter en tant que bibliothèques statiques préconstruites, créer:

1. openssl dossier sous jni répertoire contenant lib/ (qui contiennent les fichiers .a pour les architectures supportées),
2. include/ qui a les inclusions nécessaires (vous pouvez trouver que sous la version d'openssl que vous avez téléchargée, soyez conscient que certains des fichiers d'en-tête sont des liens symboliques)

3. Modifier Android.mk à l'intérieur jni dossier adjonction de ce qui suit:

   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)
   

ensuite, pour utiliser la bibliothèque dans un autre jni module ajouter ce qui suit à son Android.mk fichier:

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

cela ne résout pas votre problème, mais peut-être cela aidera. Un poste de google groups où ils ont réussi à compiler OpenSSL 1.0.1 beta2 pour Android.

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

cela pourrait également aider, un projet open source qui construit 1.0.0 a pour Android:

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

C'est comme ça que je l'ai fait pour openssl-1.0.2 g:

$ 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=<Path of your OpenSSL> 

$ 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 

assurez-vous que vous saisissez les bons chemins NDK dans votre setenv-android.sh sinon, vous aurez des erreurs.

exemple pour cette construction J'ai utilisé Android NDK vr10b ( http://dl.google.com/android/ndk/android-ndk32-r10b-darwin-x86.tar.bz2 ) et utilisé les valeurs de chemin ff À l'intérieur de mon setenv-android.sh fichier:

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

référence: https://wiki.openssl.org/index.php/Android

Note - - - > J'ai créé un GitHub s'engager à répondre à cette question, s'il vous plaît voir: https://github.com/rjmangubat23/OpenSSL

j'ai téléchargé les différents scripts pour setenv-android.sh sur mon github, parce que vous aurez besoin de différents types de scripts pour différentes architectures:

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

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

télécharger Openssl ici: ftp://ftp.openssl.org/source

télécharger la liste complète des fichiers NDK Android ici: https://github.com/taka-no-me/android-cmake/blob/master/ndk_links.md

vous pouvez utiliser ce script pour compiler openssl sous Windows 7 + Cygwin. Tout ce dont vous avez besoin est de changer l'emplacement de ndk et de choisir la version de l'api android.

à Ma façon, étape par étape (Win 7 x64 + Cygwin + ndk r10c)

1. Copier le fichier setenv-android-mod.sh et build-all-arch.sh à votre openssl répertoire.

2. modifier le fichier build-all-arch.sh

   • cd openssl-1.0.1j à #cd openssl-1.0.1j (ligne 56)

   • cd .. à #cd .. (ligne 80)

3. modifier le fichier setend-android-mod.sh

   • _ANDROID_NDK="android-ndk-r10c-x64" changement à votre version ndk (ligne 18)
   • _ANDROID_API="android-19" modifier votre version api (ligne 40)
   • ANDROID_NDK_ROOT="d:/work/android/android-ndk-r10c-x64" précisez votre dir (ligne 42)
   • ANDROID_TOOLCHAIN="d:/work/android/android-ndk-r10c-x64/toolchains" précisez votre dir (ligne 43)
   • export CROSS_COMPILE="aarch64-linux-android-" à export CROSS_COMPILE="$ANDROID_TOOLCHAIN/aarch64-linux-android-" (ligne 219), le changement même des lignes 225, 231, 237, 243 - il suffit d'ajouter $ANDROID_TOOLCHAIN/ pour la compilation croisée de chemin.

Exécuter build-all-arch.sh .

Toutes les bibliothèques ( *.so ) sera situé dans /prebuilt/ dir.

P. S. J'ai eu un peu plus d'erreurs à cause de liens symboliques erronés, mais tout allait bien après avoir exécuté la commande suivante export CYGWIN="winsymlinks:native" voir ici pour plus de détails.

ce problème et beaucoup d'autres comme celui-ci m'ont causé une semaine ou deux de merdes, mais je l'ai finalement résolu et j'ai pensé que je partagerais ma solution. OpenSSL peut être compilé pour 21+ et fonctionner sur les appareils Android 4.03 si vous êtes prêt à hacker le code. Nous utilisons libcurl, voulais tellement être à jour. Les étapes sont un peu complexes:

assurez-vous D'abord d'avoir une version compilable de libcurl. Je recommande comme bon point de départ https://github.com/cocos2d/cocos2d-x-3rd-party-libs-src

ils tiennent à jour les scripts de construction.

d'abord pirater l'androïde.ini dans "Construire" à la version 21

ensuite, j'ai dû ajouter les fonctions de raccourci suivantes au projet JNI quelque part:

// 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;
}

notez que la fonction de signal pourrait être meilleure, mais pour nous ce n'est pas important. Cela stoppe les erreurs redoutées du symbole "impossible de trouver" le 4.03 dispositifs causés par des changements dans les en-têtes en 5+ ( https://groups.google.com/forum/#!topic / android-ndk / RjO9WmG9pfE ).

à suivre téléchargez le tar.gz pour la version d'openssl que vous voulez construire et déballer quelque part. Modifier crypto / ui / ui_openssl.c et crypto/des/read_pwd.c et s'assurer que les # definitions pour tcsetattr ne sont pas utilisées. J'ai utilisé une force brute # si 0 et # si 1-notez que cela devrait être possible en tournant le préprocesseur, mais j'ai abandonné à ceci point. Si quelqu'un veut partager la magie correcte, faites-le!

Maintenant vous devez re-Tarr up le fichier dans le fichier tarballs (en s'assurant que vous l'obtenez le dossier racine là:

et l'exécuter (dans mon cas)

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

cela permettra le cocos2d ./build.sh pour courir. Quelque chose comme:

. /build.sh -p=android --libs=openssl, curl --arch=armv7 --mode=libération

enfin - et cela m'a surpris en termes de faire un universel .un fichier, mais ne fait pas directement partie de la question, assurez-vous d'utiliser une version qui n'utilise pas d'instructions néon. Les appareils Tegra 2 ont apparemment un FPU mais pas de néon. Je pense que cela peut être fait en utilisant-mfpu=vfp comme drapeau de compilateur, mais j'ai choisi d'utiliser simplement la construction armv5 à la place, car la performance n'est pas vraiment importante pour moi dans ce domaine (et j'ai eu assez de mauvaises surprises dans le monde réel à partir de ce déjà).

À la fin, vous devriez obtenir une jolie .un qui fonctionne partout, et peut être utilisé dans des projets ciblant la dernière et plus grand Android. Maintenant, si seulement quelqu'un du projet OpenSSL peut lire ceci et corriger le projet pour qu'il comprenne les trucs android publiés il y a 2 ans!

bonne chance!

Voici comment construire OpenSSL sur Windows en utilisant Cygwin et Android NDK

1. Télécharger et extraire OpenSSL source
2. télécharger le script de https://github.com/pstanoev/OpenSSL-For-Android

3. Exécuter cmd avec d'utilisateur de l'Administrateur et exécutez

   SET CYGWIN=winsymlinks:nativestrict

4. dans la même fenêtre cmd, ouverte Cygwin:

   cygwin.bat

5. Rendre le script exécutable:

   chmod +x *.sh

6. Dans Cygwin exécuter:

   /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

   • Modifier pour vos sites de Android NDK et sources

7. Copie libcrypto.donc et incluez les fichiers/* dans ce module. Utilisez cp -r pour copier pour suivre les liens.