android 安全之——文件加密jni实现

上一篇提到了AES加密方式基本实现，这一篇我们不得提出一个问题，就是代码的安全性。我们知道java层代码很容易被反编译，很有可能泄漏我们加密方式与密钥内容，那我们该怎么办呢？我们可以使用c/c++实现加密，编译成So库的形式，可供java实现调用，这样就大大增强程序安全性，因为so反编译结果是arm指令，没有java中smali那么易懂。

完全使用c/c++实现可能会比较麻烦，其实我们也可以简化一部分，只将密钥使用jni实现，其它还是用java实现，这样会简单一些，下面是具体操作；

核心密钥jni实现：

 

#include <jni.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include <android/log.h>

	const char keyValue[] = {
		21, 25, 21, -45, 25, 98, -55, -45, 10, 35, -45, 35,
		26, -5, 25, -65, -78, -99, 85, 45, -5, 10, -0, 11,
		-35, -48, -98, 65, -32, 14, -67, 25, 36, -56, -45, -5,
		12, 15, 35, -15, 25, -14, 62, -25, 33, -45, 55, 12, -8,
	};

	const char iv[] =  {	//16 bit
			-33, 32, -25, 25, 35, -27, 55, -12, -15,32,
			23, 45, -26, 32, 5,16
	};


 jbyteArray Java_com_xiaoyu_jnirelate_JNIDeclaration_getKeyValue(JNIEnv *env, jobject obj)
 {

		jbyteArray kvArray = (*env)->NewByteArray(env, sizeof(keyValue));
		jbyte *bytes = (*env)->GetByteArrayElements(env,kvArray,0);

		int i;
		for (i = 0; i < sizeof(keyValue);i++){
			bytes[i] = (jbyte)keyValue[i];
		}

		(*env)->SetByteArrayRegion(env,kvArray, 0, sizeof(keyValue),bytes);
		(*env)->ReleaseByteArrayElements(env,kvArray,bytes,0);

		return kvArray;
 }

//JNIEXPORT	JNICALL
 jbyteArray Java_com_xiaoyu_jnirelate_JNIDeclaration_getIv(JNIEnv *env, jobject obj)
 {

    jbyteArray ivArray = (*env)->NewByteArray(env, sizeof(iv));
	jbyte *bytes = (*env)->GetByteArrayElements(env,ivArray, 0);

	int i;
	for (i = 0; i < sizeof(iv); i++){
		bytes[i] = (jbyte)iv[i];
	}

	(*env)->SetByteArrayRegion(env,ivArray, 0, sizeof(iv), bytes);
	(*env)->ReleaseByteArrayElements(env,ivArray,bytes,0);

	return ivArray;
 }

 

本地方法声明：

public class JNIDeclaration {
	//AES Key
	public native byte[] getKeyValue();
	public native byte[] getIv();
	
}

 

java加解密实现：

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.spec.AlgorithmParameterSpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;

public class SecurityMag {

	private SecretKey key;
	private AlgorithmParameterSpec paramSpec;
	private Cipher cipher;

	public SecurityMag(SecretKey mkey,AlgorithmParameterSpec mparamSpec,Cipher mcipher){
		this.key=mkey;
		this.paramSpec=mparamSpec;
		this.cipher=mcipher;
	}
	
	public String encode(String msg) {

		String strHex = "";

		try {

			// 用密钥和一组算法参数初始化此 cipher
			cipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
			// 对要加密的内容进行编码处理,
			strHex = byte2hex(cipher.doFinal(msg.getBytes()));
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (InvalidAlgorithmParameterException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		}
		
		return strHex;
	}

	public  String decode(String value) {

		String strContent="";
		try {

			cipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
			// 对要解密的内容进行编码处理
			strContent = new String(cipher.doFinal(hex2byte(value)));
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (InvalidAlgorithmParameterException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		}
		
		return strContent;
	}

	/**
	 * 将二进制转化为16进制字符串
	 * 
	 * @param b
	 *            二进制字节数组
	 * @return String
	 */
	public String byte2hex(byte[] b) {
		String hs = "";
		String stmp = "";
		for (int n = 0; n < b.length; n++) {
			stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
			if (stmp.length() == 1) {
				hs = hs + "0" + stmp;
			} else {
				hs = hs + stmp;
			}
		}
		return hs.toUpperCase();
	}

	/**
	 * 十六进制字符串转化为2进制
	 * 
	 * @param hex
	 * @return
	 */
	public byte[] hex2byte(String hex) {
		byte[] ret = new byte[8];
		byte[] tmp = hex.getBytes();
		for (int i = 0; i < 8; i++) {
			ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
		}
		return ret;
	}

	/**
	 * 将两个ASCII字符合成一个字节； 如："EF"--> 0xEF
	 * 
	 * @param src0
	 *            byte
	 * @param src1
	 *            byte
	 * @return byte
	 */
	public byte uniteBytes(byte src0, byte src1) {
		byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))
				.byteValue();
		_b0 = (byte) (_b0 << 4);
		byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))
				.byteValue();
		byte ret = (byte) (_b0 ^ _b1);
		return ret;
	}
	
}

 
android 调用测试：

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class TestActivity extends Activity {

	final String tag="TestActivity";
	
	private  byte[] keyValue;
	private  byte[] iv;
	private JNIDeclaration declaration_native;
	private SecurityMag secMag;
	
	static {
		System.loadLibrary("aeslib");
	}
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		initKey();
		String mimi="hello are you good!";
		String encrypmimi=encryContent(mimi);
		decrypContent(encrypmimi);
	}
	
	private void initKey(){
		
		declaration_native=new JNIDeclaration();
		keyValue = declaration_native.getKeyValue();
		iv = declaration_native.getIv();

		if (null != keyValue && null != iv) {

			KeyGenerator kgen;
			try {

				kgen = KeyGenerator.getInstance("AES");
				kgen.init(128, new SecureRandom(keyValue));

				SecretKey key = kgen.generateKey();
				IvParameterSpec paramSpec = new IvParameterSpec(iv);
				Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");

				secMag=new SecurityMag(key,paramSpec,cipher);
			} catch (NoSuchAlgorithmException e) {
				e.printStackTrace();
			} catch (NoSuchPaddingException e) {
				e.printStackTrace();
			}

		}
	}
	
	String encryContent(String str){
		String encrypStr=secMag.encode(str);
		Log.i(tag, "encryption content "+encrypStr);
		return encrypStr;
	}
	
	String decrypContent(String str){
		String decrypStr=secMag.decode(str);
		Log.i(tag, "encryption content "+decrypStr);
		return decrypStr;
	}
	
}