前言

需求：需要在NDK層對一個Java層的字串進行RSA加密，然後對加密的結果進行Base64返回到Java層
方案：選擇使用OpenSSL來實現。

編譯libssl.a和libcrypto.a靜態庫

在github上找到了一個專案，可以直接將OpenSSL編譯成Android可以使用的，專案地址為

但是這個專案有點小問題，部分編譯指令碼需要做點改動，改動後的專案見

主要做了3個改動:

1. 將最低版本支援從Android 21改到了Android 14
2. 修復一個armeabi-v7a無法編譯出來的問題
3. 升級了openssl的版本到openssl-1.1.0e

之後將專案clone下來，進入到tools目錄，執行build-openssl4android.sh編譯指令碼

./build-openssl4android.sh android-armeabi armeabi-v7a
./build-openssl4android.sh android armeabi

這裡只編譯了armeabi-va7和armeabi架構CPU的so，如果有需要，請自行更改命令引數編譯X86等架構的so。

經過很長時間的編譯。。。大概要10來分鐘吧。。。在根目錄下的output會產生一個android目錄，裡面有openssl-armeabi和openssl-armeabi-v7a兩個資料夾，包含了openssl的標頭檔案以及編譯好的.a靜態庫

實現JNI函式

編譯好後.a靜態庫，就可以建立jni專案了

進入jni專案根目錄，建立Application.mk檔案

APP_ABI := armeabi armeabi-v7a
APP_PLATFORM := android-14
APP_OPTIM := release
APP_STL := c++_static

APP_THIN_ARCHIVE := true
APP_CPPFLAGS := -fpic -fexceptions -frtti
APP_GNUSTL_FORCE_CPP_FEATURES := pic exceptions rtti

進入jni專案根目錄，建立Android.mk檔案

LOCAL_PATH := $(call my-dir)

#引用libcrypto.a
include $(CLEAR_VARS)
LOCAL_MODULE := libcrypto
LOCAL_SRC_FILES := $(LOCAL_PATH)/openssl/$(TARGET_ARCH_ABI)/lib/libcrypto.a
include $(PREBUILT_STATIC_LIBRARY)

#引用libssl.a
include $(CLEAR_VARS)
LOCAL_MODULE := libssl
LOCAL_SRC_FILES := $(LOCAL_PATH)/openssl/$(TARGET_ARCH_ABI)/lib/libssl.a
include $(PREBUILT_STATIC_LIBRARY)

include $(CLEAR_VARS)

LOCAL_MODULE            := test
LOCAL_SRC_FILES         := \
native.cpp \

LOCAL_C_INCLUDES        :=$(LOCAL_PATH)/openssl/openssl-$(TARGET_ARCH_ABI)/include

TARGET_PLATFORM         := android-14

#靜態庫依賴
LOCAL_STATIC_LIBRARIES  := libssl libcrypto

LOCAL_LDLIBS += -latomic -lz -llog
include $(BUILD_SHARED_LIBRARY)
 

進入jni專案根目錄，拷貝編譯好的openssl檔案

接著將第一步編譯好的靜態庫檔案進行拷貝，將output目錄下android整個目錄進行拷貝，拷貝到jni專案根目錄下，拷貝完成後將android目錄重新命名為openssl

進入jni專案根目錄，建立native.cpp，搭建基礎的結構

#include "jni.h"

template<typename T, int N>
char (&ArraySizeHelper(T (&array)[N]))[N];

#define NELEMS(x) (sizeof(ArraySizeHelper(x)))

#ifndef CLASSNAME
#define CLASSNAME "com/fucknmb/Test"
#endif

jstring native_rsa(JNIEnv *env, jobject thiz, jstring base64PublicKey, jstring content) {
    return NULL;
}

static const JNINativeMethod sMethods[] = {
    {
        const_cast<char *>("native_rsa"),
        const_cast<char *>("(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
        reinterpret_cast<void *>(native_rsa)
    }
};

int registerNativeMethods(JNIEnv *env, const char *className, const JNINativeMethod *methods,
                          const int numMethods) {
    jclass clazz = env->FindClass(className);
    if (!clazz) {
        return JNI_FALSE;
    }
    if (env->RegisterNatives(clazz, methods, numMethods) != 0) {
        env->DeleteLocalRef(clazz);
        return JNI_FALSE;
    }
    env->DeleteLocalRef(clazz);
    return JNI_TRUE;
}

jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env;
    if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
        return -1;
    }
    registerNativeMethods(env, CLASSNAME, sMethods, NELEMS(sMethods));
    return JNI_VERSION_1_6;
}

宣告java層函式

在Java層建立com/fucknmb/Test類，宣告一個native函式

package com.fucknmb;

import java.util.List;

public class Test {
    public static native final String native_rsa(String base64PublicKey, String content);

    static {
        System.loadLibrary("test");
    }
}

實現native_rsa函式

native_rsa函式有兩個引數，一個是base64之後的公鑰（不含頭部和尾部，以及沒換行），第二個是待加密的明文內容，該函式的返回值是加密後的密文進行base64。

對於第一個引數，我們需要將其轉為公鑰檔案字串，追加頭部和尾部，其實現如下：

/**
 * 根據公鑰base64字串（沒換行）生成公鑰文字內容
 * @param base64EncodedKey
 * @return
 */
std::string generatePublicKey(std::string base64EncodedKey) {
    std::string publicKey = base64EncodedKey;
    size_t base64Length = 64;//每64個字元一行
    size_t publicKeyLength = base64EncodedKey.size();
    for (size_t i = base64Length; i < publicKeyLength; i += base64Length) {
        //每base64Length個字元，增加一個換行
        if (base64EncodedKey[i] != '\n') {
            publicKey.insert(i, "\n");
        }
        i++;
    }
    //最前面追加公鑰begin字串
    publicKey.insert(0, "-----BEGIN PUBLIC KEY-----\n");
    //最前面追加公鑰end字串
    publicKey.append("\n-----END PUBLIC KEY-----");
    return publicKey;
}

openssl rsa加密後，我們需要對密文進行Base64，openssl同樣提供了Base64演算法，實現如下

/**
 * base64 encode
 * @param decoded_bytes
 * @return
 */
std::string base64_encode(const std::string &decoded_bytes) {
    BIO *bio, *b64;
    BUF_MEM *bufferPtr;

    b64 = BIO_new(BIO_f_base64());
    //不換行
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
    bio = BIO_new(BIO_s_mem());
    bio = BIO_push(b64, bio);
    //encode
    BIO_write(bio, decoded_bytes.c_str(), (int) decoded_bytes.length());
    BIO_flush(bio);
    BIO_get_mem_ptr(bio, &bufferPtr);
    //這裡的第二個引數很重要，必須賦值
    std::string result(bufferPtr->data, bufferPtr->length);
    BIO_free_all(bio);
    return result;
}

這個函式有一點需要注意的就是這一行

std::string result(bufferPtr->data, bufferPtr->length);

第二個引數表示長度，不能少，否則base64後的字串長度會出現異常，導致decode的時候末尾會出現一大堆的亂碼，而網上大多數的程式碼，是缺失這一個引數的。

接下來就是rsa的實現了

/**
 * 使用公鑰對明文加密
 * @param publicKey
 * @param from
 * @return
 */
std::string encryptRSA(const std::string &publicKey, const std::string &from) {
    BIO *bio = NULL;
    RSA *rsa_public_key = NULL;

    //從字串讀取RSA公鑰串
    if ((bio = BIO_new_mem_buf((void *) publicKey.c_str(), -1)) == NULL) {
        std::cout << "BIO_new_mem_buf failed!" << std::endl;
        return NULL;
    }
    //讀取公鑰
    rsa_public_key = PEM_read_bio_RSA_PUBKEY(bio, NULL, NULL, NULL);

    //異常處理
    if (rsa_public_key == NULL) {
        //資源釋放
        BIO_free_all(bio);
        RSA_free(rsa_public_key);
        //清除管理CRYPTO_EX_DATA的全域性hash表中的資料，避免記憶體洩漏
        CRYPTO_cleanup_all_ex_data();
        return NULL;
    }

    //rsa模的位數
    int rsa_size = RSA_size(rsa_public_key);

    //RSA_PKCS1_PADDING 最大加密長度 為 128 -11
    //RSA_NO_PADDING 最大加密長度為  128
    rsa_size = rsa_size - RSA_PKCS1_PADDING_SIZE;

    //動態分配記憶體，用於儲存加密後的密文
    unsigned char *to = (unsigned char *) malloc(rsa_size + 1);
    //填充0
    memset(to, 0, rsa_size + 1);

    //明文長度
    int flen = from.length();

    //加密，返回值為加密後的密文長度，-1表示失敗
    int status = RSA_public_encrypt(flen, (const unsigned char *) from.c_str(), to, rsa_public_key,
                                    RSA_PKCS1_PADDING);
    //異常處理
    if (status < 0) {
        //資源釋放
        free(to);
        BIO_free_all(bio);
        RSA_free(rsa_public_key);
        //清除管理CRYPTO_EX_DATA的全域性hash表中的資料，避免記憶體洩漏
        CRYPTO_cleanup_all_ex_data();
        return NULL;
    }

    //賦值密文
    static std::string result((char *) to, status);

    //資源釋放
    free(to);
    BIO_free_all(bio);
    RSA_free(rsa_public_key);
    //清除管理CRYPTO_EX_DATA的全域性hash表中的資料，避免記憶體洩漏
    CRYPTO_cleanup_all_ex_data();
    return result;
}

同樣這個函式也有幾個地方需要注意：

第一點：

static std::string result((char *) to, status);

第二個引數表示密文長度，一般來說，這個值會是128，如果第二個值不傳，會導致加密後的密文經過string的建構函式後，丟失一部分資料，導致資料的不正確

第二點:

rsa_size = rsa_size - RSA_PKCS1_PADDING_SIZE;

對於RSA_PKCS1_PADDING_SIZE，最大加密長度為需要減去11

第三點:

//明文長度
int flen = from.length();

//加密，返回值為加密後的密文長度，-1表示失敗
int status = RSA_public_encrypt(flen, (const unsigned char *) from.c_str(), to, rsa_public_key,
                                RSA_PKCS1_PADDING);

RSA_public_encrypt函式的第一個引數傳的是明文長度，而不是最大加密長度rsa_size，網上的所有程式碼這個引數都是傳錯的，傳了rsa_size，而實際上這個引數的引數名是flen，表示from字串的length。如果這個引數傳了最大加密長度，將直接導致java層無法正確解密JNI層加密後的資料。

最後不要忘記加標頭檔案的引用

#include <openssl/bio.h>
#include <openssl/buffer.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <iostream>
using std::string;

需要的函式都有了，實現以下native_rsa函式，簡單組裝一下以上函式即可

jstring native_rsa(JNIEnv *env, jobject thiz, jstring base64PublicKey, jstring content) {
    //jstring 轉 char*
    char *base64PublicKeyChars = (char *) env->GetStringUTFChars(base64PublicKey, NULL);
    //char* 轉 string
    string base64PublicKeyString = string(base64PublicKeyChars);
    //生成公鑰字串
    string generatedPublicKey = generatePublicKey(base64PublicKeyString);
    //釋放
    env->ReleaseStringUTFChars(base64PublicKey, base64PublicKeyChars);
    //jstring 轉 char*
    char *contentChars = (char *) env->GetStringUTFChars(content, NULL);
    //char* 轉 string
    string contentString = string(contentChars);
    //釋放
    env->ReleaseStringUTFChars(content, contentChars);

    //呼叫RSA加密函式加密
    string rsaResult = encryptRSA(generatedPublicKey, contentString);
    if (rsaResult.empty()) {
        return NULL;
    }
    //將密文進行base64
    string base64RSA = base64_encode(rsaResult);
    if (base64RSA.empty()) {
        return NULL;
    }
    //string -> char* -> jstring 返回
    jstring result = env->NewStringUTF(base64RSA.c_str());
    return result;
}

私鑰解密

如果你還需要用的私鑰解密部分，可以繼續實現base64的decode函式，以及rsa的私鑰串生成函式，rsa的解密函式

base64 decode函式的實現如下：

/**
 * base64 decode
 * @param encoded_bytes
 * @return
 */
std::string base64_decode(const std::string &encoded_bytes) {
    BIO *bioMem, *b64;

    bioMem = BIO_new_mem_buf((void *) encoded_bytes.c_str(), -1);
    b64 = BIO_new(BIO_f_base64());
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
    bioMem = BIO_push(b64, bioMem);

    //獲得解碼長度
    size_t buffer_length = BIO_get_mem_data(bioMem, NULL);

    char *decode = (char *) malloc(buffer_length + 1);
    //填充0
    memset(decode, 0, buffer_length + 1);

    BIO_read(bioMem, (void *) decode, (int) buffer_length);

    static std::string decoded_bytes(decode);

    BIO_free_all(bioMem);

    return decoded_bytes;
}

rsa的私鑰串生成函式的試下如下：

/**
 * 根據私鑰base64字串（沒換行）生成私鑰文字內容
 * @param base64EncodedKey
 * @return
 */
std::string generatePrivateKey(std::string base64EncodedKey) {
    std::string privateKey = base64EncodedKey;
    size_t base64Length = 64;//每64個字元一行
    size_t privateKeyLength = base64EncodedKey.size();
    for (size_t i = base64Length; i < privateKeyLength; i += base64Length) {
        //每base64Length個字元，增加一個換行
        if (base64EncodedKey[i] != '\n') {
            privateKey.insert(i, "\n");
        }
        i++;
    }
    //最前面追加私鑰begin字串
    privateKey.insert(0, "-----BEGIN PRIVATE KEY-----\n");
    //最後面追加私鑰end字串
    privateKey.append("\n-----END PRIVATE KEY-----");
    return privateKey;
}

私鑰解密函式的實現如下：

/**
 * 使用私鑰對密文解密
 * @param privetaKey
 * @param from
 * @return
 */
std::string decryptRSA(const std::string &privetaKey, const std::string &from) {
    BIO *bio = NULL;
    RSA *rsa_private_key = NULL;
    //從字串讀取RSA公鑰串
    if ((bio = BIO_new_mem_buf((void *) privetaKey.c_str(), -1)) == NULL) {
        std::cout << "BIO_new_mem_buf failed!" << std::endl;
        return NULL;
    }
    //讀取私鑰
    rsa_private_key = PEM_read_bio_RSAPrivateKey(bio, NULL, NULL, NULL);

    //異常處理
    if (rsa_private_key == NULL) {
        //資源釋放
        BIO_free_all(bio);
        RSA_free(rsa_private_key);
        //清除管理CRYPTO_EX_DATA的全域性hash表中的資料，避免記憶體洩漏
        CRYPTO_cleanup_all_ex_data();
        return NULL;
    }

    //rsa模的位數
    int rsa_size = RSA_size(rsa_private_key);

    //動態分配記憶體，用於儲存解密後的明文
    unsigned char *to = (unsigned char *) malloc(rsa_size + 1);
    //填充0
    memset(to, 0, rsa_size + 1);

    //密文長度
    int flen = from.length();

    // RSA_NO_PADDING
    // RSA_PKCS1_PADDING
    //解密，返回值為解密後的名文長度，-1表示失敗
    int status = RSA_private_decrypt(flen, (const unsigned char *) from.c_str(), to, rsa_private_key,
                                     RSA_PKCS1_PADDING);
    //異常處理率
    if (status < 0) {
        //釋放資源
        free(to);
        BIO_free_all(bio);
        RSA_free(rsa_private_key);
        //清除管理CRYPTO_EX_DATA的全域性hash表中的資料，避免記憶體洩漏
        CRYPTO_cleanup_all_ex_data();
        return NULL;
    }

    //賦值明文，是否需要指定to的長度？
    static std::string result((char *) to);

    //釋放資源
    free(to);
    BIO_free_all(bio);
    RSA_free(rsa_private_key);
    //清除管理CRYPTO_EX_DATA的全域性hash表中的資料，避免記憶體洩漏
    CRYPTO_cleanup_all_ex_data();
    return result;
}

如果你要解密公鑰加密後的密文，只需要這樣呼叫即可返回明文

//公鑰串和私鑰串
string generatedPublicKey = generatePublicKey(base64PublicKey);
string generatedPrivetKey = generatePrivateKey(base64PrivateKey);

string content("just a test");
//加密
string result = encryptRSA(generatedPublicKey, content);
//encode
string base64RSA = base64_encode(result);

//decode
string decodeBase64RSA = base64_decode(base64RSA);
//解密
string origin = decryptRSA(generatedPrivetKey, decodeBase64RSA);

最後注意一下base64PublicKey和base64PrivateKey，這兩個字串是不包含換行的，就是私鑰和公鑰的encoded之後的位元組陣列base64後的值，因此需要自己呼叫generatePublicKey和generatePrivateKey追加頭和尾。

RSA公鑰和私鑰的生成

生成私鑰

openssl genrsa -out rsa_private_key.pem 1024

這條命令讓openssl隨機生成了一份私鑰，加密長度是1024位。加密長度是指理論上最大允許”被加密的資訊“長度的限制，也就是明文的長度限制。隨著這個引數的增大（比方說2048），允許的明文長度也會增加，但同時也會造成計算複雜度的極速增長。一般推薦的長度就是1024位（128位元組，之前的程式碼的最大加密長度128就是這麼來的）。

生成公鑰

openssl rsa -in rsa_private_key.pem -out rsa_public_key.pem -pubout

金鑰檔案最終將資料通過Base64編碼進行儲存。可以看到上述生成的金鑰檔案內容每一行的長度都很規律。這是由於RFC2045中規定：The encoded output stream must be represented in lines of no more than 76 characters each。也就是說Base64編碼的資料每行最多不超過76字元，對於超長資料需要按行分割。

上面的generatePublicKey和generatePrivateKey函式我們是按64位一行進行分割的，如果你有需要，可以將值修改為76。

第一步生成私鑰檔案不能直接使用，需要進行PKCS#8編碼：

openssl pkcs8 -topk8 -in rsa_private_key.pem -out pkcs8_rsa_private_key.pem -nocrypt

第二步和第三步生成的公鑰和私鑰就可以用了，這裡有個問題需要注意，如果你的公鑰和私鑰是類似下面這種格式的

-----BEGIN PUBLIC KEY-----
....
-----END PUBLIC KEY-----

-----BEGIN PRIVATE KEY-----
....
-----END PRIVATE KEY-----

那麼，你無需呼叫generatePublicKey或者generatePrivateKey函式，此時已經是需要的公鑰串和私鑰串，但是如果你的公鑰和私鑰沒有頭部和尾部，並且不是換行的，就需要呼叫一下進行轉換，因為我這邊Java層傳入的是後者，所以需要呼叫generatePublicKey或者generatePrivateKey進行轉換。

Java層呼叫公鑰加密函式部分

String base64PublicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDP0tzYxBF5IGfNvuIHzAqvza/ZxfH8aEiPFA4nY/W3js+cG3JUU86Jkc7jUG9XfGdW6SJ38ANs5tyWqYkJyoUErB2PjQQQDmHhbgpBUSeOdwGr/LPtrTrotrNXwpRY9eodkcbcMlbT0gvdnohRSISCjJ2KmFcBMkeO9R2DWe6oIwIDAQAB";
String result = com.fucknmb.Test.native_rsa(base64PublicKey,"I am test");