web-dev-qa-db-fra.com

Compiler le dernier OpenSSL pour Android

J'essaie de générer la bibliothèque partagée pour les fichiers (.so) de OpenSSL1.0.1c pour Android. J'ai trouvé qu'ils ont ajouté trois options pour la compilation pour Android dans le script Android.

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

une fois que j'ai configuré pour le système d'exploitation, puis essayer de compiler, ses erreurs de projection . Actuellement, je travaille sous Windows 7 x86 et installé 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
<builtin>: 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$

S'il vous plaît laissez-moi savoir si quelqu'un a fait face à un problème similaire et obtenu la solution pour résoudre le même.

androidandroid-ndkopenssl
21
Suman

Je ne conseillerais sérieusement pas de prendre quelque chose en dehors du site Web officiel OpenSSL. Vous ne pouvez pas prendre de risque en matière de cryptographie et de 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.04LTS (cela fonctionne avec OpenSSL 1.0.1g)

À partir de votre dossier personnel, exécutez les 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} "

Et puis exécutez votre script de configuration:

./Configure Android-armv7

Et puis construire

PATH=$TOOLCHAIN_PATH:$PATH make

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

Construire pour l'ancien arméa:

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
52
mchiasson

Dans OpenSSL 1.0.1e, 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
15
James Moore

Grâce aux instructions affichées ici et à quelques autres ajouts, j'ai créé un script automatisé qui compile la dernière bibliothèque OpenSSL pour Android avec prise en charge de: armeabi, armeabi-v7a, x86, x86_64 et arm64-v8a:

#!/bin/bash -e
#@author Aleksandar Gotev ([email protected])
#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 <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=$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-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

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

Pour la dernière version, consultez: https://github.com/alexbbb/pjsip-Android-builder/blob/master/openssl-build

8
Alex Gotev

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

  • Prise en charge de la construction pour plusieurs architectures - ARM, ARMv7, X86
  • Utilise les codes source OpenSSL
  • Intégré à Android.mk build
  • Contient OpenSSL 1.0.2h pré-compilé (à utiliser si vous voulez ou compilez le vôtre)

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

2
ph4r05

Au cas où quelqu'un rencontrerait le problème de l'utilisation d'une version vulnérable d'OpenSSL (< 1.0.2f/1.0.1r) dans l'une des bibliothèques natives, j'ajouterai quelques détails supplémentaires et des instructions.

Conditions préalables: Android NDK doit d'abord être configuré.

  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 . Au cas où quelqu'un se demanderait ce qu'il faisait (et vous devriez - c'est une bibliothèque cryptographique !!!): Ils construisent la bibliothèque OpenSSL pour chaque architecture de processeur Android ABI (armeabi, x86, mips, etc ...)

  3. Modifier setenv-Android-mod.sh -> line 18 avec la version de ndk

  4. Modifier setenv-Android-mod.sh -> line 40 avec la version de l'API Android

  5. Modifiez build-all-Arch.sh -> line 7 avec le nom de dossier de la bibliothèque OpenSSL (dans mon cas, il s'agissait de openssl-1.0.1t)

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

Pour ajouter la openSSL au projet en tant que bibliothèques statiques préconstruites, créez:

  1. dossier openssl sous le répertoire jni contenant lib/ (qui contient les fichiers .a pour les architectures prises en charge),
  2. include/ qui a les inclus inclus (vous pouvez trouver que dans la version openssl que vous avez téléchargée, sachez que certains fichiers d’en-tête sont des liens symboliques) 

  3. Modifiez Android.mk dans le dossier jni en ajoutant 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 module jni, ajoutez ce qui suit dans son fichier Android.mk:

LOCAL_C_INCLUDES := $(LOCAL_PATH)/../openssl/include
LOCAL_STATIC_LIBRARIES := libssl libcrypto
1
R. Zagórski

Voici comment compiler OpenSSL sous Windows à l'aide de Cygwin et d'Android NDK

  1. Téléchargez et extrayez le source OpenSSL
  2. Téléchargez le script à partir de https://github.com/pstanoev/OpenSSL-For-Android

  3. Exécutez cmd avec l'administrateur et exécutez 

    SET CYGWIN=winsymlinks:nativestrict

  4. Dans la même fenêtre de commande, ouvrez Cygwin: 

    cygwin.bat

  5. Rendre le script exécutable:

    chmod +x *.sh

  6. Dans Cygwin, exécutez:

    /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 emplacements de NDK Android et les sources

  7. Copiez les fichiers libcrypto.so et inclure/* dans ce module. Utilisez cp -r pour copier pour suivre les liens.

0
peceps

Vous pouvez utiliser ce script pour compiler openssl sous Windows 7 + Cygwin. Tout ce dont vous avez besoin n’est que de changer d’emplacement de NDK et de choisir la version d’API Android.

Mon chemin pas à pas (Win 7 x64 + Cygwin + ndk r10c)

  1. Copiez les fichiers setenv-Android-mod.sh et build-all-Arch.sh dans votre répertoire openssl.

  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" changer à votre version de ndk (ligne 18)
    • _Android_API="Android-19" changer à votre version de l'API (ligne 40)
    • Android_NDK_ROOT="d:/work/Android/android-ndk-r10c-x64" précisez votre répertoire (ligne 42)
    • Android_TOOLCHAIN="d:/work/Android/android-ndk-r10c-x64/toolchains" précisez votre répertoire (ligne 43)
    • export CROSS_COMPILE="aarch64-linux-Android-" à export CROSS_COMPILE="$Android_TOOLCHAIN/aarch64-linux-Android-" (ligne 219), modifiez les mêmes lignes 225, 231, 237, 243 - ajoutez simplement $Android_TOOLCHAIN/ au chemin de compilation croisée.

Exécutez build-all-Arch.sh. 

Toutes les bibliothèques (*.so) seront situées dans le répertoire /prebuilt/.

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

0
vadim_hr

Ce problème et bien d’autres comme il m’a causé une semaine de réflexion, mais j’ai finalement réussi à le résoudre, alors j’ai pensé partager ma solution. OpenSSL peut être compilé pour plus de 21 ans et fonctionne sur les appareils Android 4.03 si vous êtes prêt à pirater le code. Nous utilisons libcurl, nous voulions donc être à jour. Les étapes sont un peu complexes:

Tout d’abord, assurez-vous d’avoir une version à construire 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 le fichier Android.ini dans la version 21 de la "version"

Ensuite, je devais ajouter les fonctions de stub 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 arrête les erreurs redoutées "impossible de localiser le symbole" sur les périphériques 4.03 causées par des modifications apportées aux en-têtes dans 5+ ( https://groups.google.com/forum/#!topic/Android-ndk/RjO9WmG9pfE ).

Ensuite, téléchargez le fichier tar.gz correspondant à la version de openssl que vous voulez construire et décompressez-le quelque part. Editez les fichiers crypto/ui/ui_openssl.c et crypto/des/read_pwd.c et assurez-vous que les #defines de tcsetattr ne sont pas utilisés. J'ai utilisé une force brute #if 0 et #if 1 - notez que cela devrait être possible en tournant le pré-processeur, mais j'ai abandonné à ce stade. Si quelqu'un a envie de partager la bonne magie, faites-le!

Maintenant, vous devez re-tarer le fichier dans le fichier tarballs (en vous assurant de bien y placer le dossier racine:

et courir (dans mon cas)

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

Cela permettra à cocos2d ./build.sh de s'exécuter. Quelque chose comme:

./build.sh -p = Android --libs = openssl, curl --Arch = armv7 --mode = release

Enfin - et cela m’a surpris en termes de création d’un fichier .a universel, mais ne fait pas directement partie de la question, assurez-vous d’utiliser une version qui n’utilise pas les instructions NEON. Les appareils Tegra 2 ont apparemment une FPU mais pas de NEON. Je pense que cela peut être fait en utilisant -mfpu = vfp en tant qu'indicateur de compilation, mais j'ai choisi d'utiliser simplement la version armv5, car les performances ne sont pas vraiment importantes pour moi dans ce domaine (et j'en ai assez des mauvaises surprises du monde réel déjà).

Au final, vous devriez vous procurer un Nice .a qui fonctionne partout et qui peut être utilisé dans des projets ciblant le dernier et meilleur Android. Maintenant, si seulement quelqu'un du projet OpenSSL peut lire ceci et réparer le projet afin qu'il comprenne les éléments Android publiés il y a 2 ans!

Bonne chance!

0
Alexp

Cela ne résout pas votre problème, mais peut-être que cela vous aidera. Un post de groupe Google où ils ont compilé avec succès 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.0a pour Android:

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

0
Cristy

Voici comment je l'ai fait pour 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=<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 entrez les bons chemins NDK dans votre setenv-Android.sh sinon vous aurez des erreurs.

Exemple pour cette version, 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 dans mon fichier setenv-Android.sh:

_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

Remarque ---> J'ai créé un github qui s’engage à répondre à cette question. Voir: https://github.com/rjmangubat23/OpenSSL

J'ai chargé les différents scripts de setenv-Android.sh sur mon github, car 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échargez Openssl ici: ftp://ftp.openssl.org/source

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

0
mangu23