Android使用openssl中常用的加密方法_android openssl aes

这篇文章写的是openssl几种加密方式的应用，如果想知道怎么在Mac上编译openssl，请查看MAC编译openssl为Android库
可以点击Demo查看以下具体的实现。

准备

如果你第一次使用NDK请参照Android NDK指南
如果你还没引入openssl库，请先编译openssl然后添加到工程中
目录结构如下

配置CMakeLists.txt

添加静态库

add_library(
        openssl-crypto
        STATIC
        IMPORTED
)

set_target_properties(
        openssl-crypto
        PROPERTIES IMPORTED_LOCATION
        ${CMAKE_SOURCE_DIR}/src/main/cpp/libs/libcrypto.a
)

add_library(
        openssl-ssl
        STATIC
        IMPORTED
)

set_target_properties(
        openssl-ssl
        PROPERTIES IMPORTED_LOCATION
        ${CMAKE_SOURCE_DIR}/src/main/cpp/libs/libssl.a
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

添加到链接库

target_link_libraries(
        # Specifies the target library.
        native-lib

        # Links the target library to the log library
        # included in the NDK.
        ${log-lib}
        openssl-crypto
        openssl-ssl
)
1
2
3
4
5
6
7
8
9
10

编辑build.gradle文件

android {
	externalNativeBuild {
            cmake {
                arguments '-DANDROID_PLATFORM=android-24', '-DANDROID_CPP_FEATURES=rtti exceptions', '-DANDROID_ARM_MODE=arm'
            }
        }

        ndk {
            abiFilters 'armeabi-v7a'
        }
}

externalNativeBuild {
        cmake {
            path file('CMakeLists.txt')
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

使用openssl的Base64编解码

// base64 编码
char * base64Encode(const char *buffer, int length)
{
    BIO *bmem = NULL;
    BIO *b64 = NULL;
    BUF_MEM *bptr;

    b64 = BIO_new(BIO_f_base64());
    bmem = BIO_new(BIO_s_mem());
    b64 = BIO_push(b64, bmem);
    BIO_write(b64, buffer, length);
    BIO_flush(b64);
    BIO_get_mem_ptr(b64, &bptr);
    BIO_set_close(b64, BIO_NOCLOSE);

    char *buff = (char *)malloc(bptr->length + 1);
    memcpy(buff, bptr->data, bptr->length);
    buff[bptr->length] = 0;
    BIO_free_all(b64);

    return buff;
}

// base64 解码
char * base64Decode(char *input, int length)
{
    BIO *b64 = NULL;
    BIO *bmem = NULL;
    char *buffer = (char *)malloc(length);
    memset(buffer, 0, length);
    b64 = BIO_new(BIO_f_base64());
    bmem = BIO_new_mem_buf(input, length);
    bmem = BIO_push(b64, bmem);
    BIO_read(bmem, buffer, length);
    BIO_free_all(bmem);

    return buffer;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

使用openssl的MD5加密

char * md5(char *content) {
    char result[MD5_DIGEST_LENGTH] = {0};
    MD5(content, strlen(content), &result);
    char tmp[3]={0}, buf[33]={'\0'};
    for (int i = 0; i < MD5_DIGEST_LENGTH; ++i) {
        sprintf(tmp, "%02X", result[i]);
        strcat(buf, tmp);
    }
    return buf;
}
1
2
3
4
5
6
7
8
9
10

使用openssl的AES加密

const unsigned char *_key = (const unsigned char *) "0123456789012345";
char *encrypt(char *content) {
    // 待加密的数据
    const unsigned char *vItem = content;
    // 源数据长度
    int inLen = (int) strlen((const char *) vItem);
    // 加密长度
    int encLen = 0;
    // 输出长度
    int outlen = 0;
    // 加密数据长度
    unsigned char encData[1024] = {0};

    LOGW("source: %s\n", vItem);
    // 创建加密上下文
    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
    // 初始化加密上下文
    EVP_CipherInit_ex(ctx, EVP_aes_128_ecb(), NULL, _key, NULL, 1);
    // 加密数据
    EVP_CipherUpdate(ctx, encData, &outlen, vItem, inLen);
    // 拼接长度
    encLen = outlen;
    // 结束加密
    EVP_CipherFinal(ctx, encData + outlen, &outlen);
    // 拼接
    encLen += outlen;
    // 释放
    EVP_CIPHER_CTX_free(ctx);
    // base64编码
    char *baseEnc = base64Encode(encData, encLen);
    LOGW("encrypted : %s\n", baseEnc);
    return baseEnc;
}

char * decrypt(char *baseEnc) {
    // base64解码
    char *encData1 = base64Decode(baseEnc, (int) strlen(baseEnc));
    // 解密长度
    int decLen = 0;
    // 解码数据长度
    int outlen = 0;
    // 解码后的数据
    unsigned char decData[1024];
    // 创建解密上下文
    EVP_CIPHER_CTX *ctx2 = EVP_CIPHER_CTX_new();
    // 初始化解密
    EVP_CipherInit_ex(ctx2, EVP_aes_128_ecb(), NULL, _key, NULL, 0);
    // 执行解密
    EVP_CipherUpdate(ctx2, decData, &outlen, (const unsigned char *) encData1, strlen(encData1));
    // 设置长度
    decLen = outlen;
    // 结束解密
    EVP_CipherFinal(ctx2, decData + outlen, &outlen);
    // 拼接长度
    decLen += outlen;
    // 释放
    EVP_CIPHER_CTX_free(ctx2);
    // 设置字符串结尾标识
    decData[decLen] = '\0';
    LOGW("decrypt %s", decData);
    return decData;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

最后

大家可以参照Demo来对比一下，如有问题请留言。