openssl在多平台和多语言之间进行RSA加解密注意事项

首先说一下平台和语言：

系统平台为CentOS6.3，RSA加解密时使用NOPADDING进行填充

1）使用C/C++调用系统自带的openssl

2）Android4.2模拟器，第三方openssl（android-external-openssl-master），使用ndk编译静态库，然后使用C/C++进行调用

3）使用Java自身的类库（javax.crypto和java.security)

在linux下，使用如下命令，生成RSA加解密时使用的public和private的key

openssl genrsa -out rsa_private_key.pem 1024　　//生成私钥

openssl rsa -in rsa_private_key.pem -out rsa_public_key.pem -pubout 　　//生成公钥

openssl pkcs8 -topk8 -in rsa_private_key.pem -out pkcs8_rsa_private_key.pem -nocrypt　　//转化成PKCS#8编码编码，供Java解密时，进行调用

假如我们要对字符串"12345678”进行加解密

1）C/C++调用系统自带的openssl加解密

//============================================================================
// Name        : HelloPlus.cpp
// Author      : 
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
//#include <iostream>
#include <sys/types.h>
#include <string.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>

#define PUBSSLKEY "rsa_public_key.pem"
#define PRISSLKEY "rsa_private_key.pem"
#define BUFFSIZE 1024
#define MAX_PATH 256

pid_t get_pid_from_proc_self();
char * get_self_executable_directory();
unsigned char *my_encrypt(unsigned char *str,char *pubPath,char *priPath);
unsigned char *byteArrayToString(unsigned char *data,int dataLen);

//using namespace std;

unsigned char *encode64(unsigned char *data,int dataLen)
{
	/*
	char base64code[] = {
		'A','B','C','D','E','F','G','H','I','J','K','L','M','N'
		,'O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b'
		,'c','d','e','f','g','h','i','j','k','l','m','n','o','p'
		,'q','r','s','t','u','v','w','x','y','z','0','1','2','3'
		,'4','5','6','7','8','9','+','/'};
	*/
	//char base64code[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmlopqrstuvwxyz0123456789+/";
	unsigned char *base64code = (unsigned char*)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmlopqrstuvwxyz0123456789+/";
	int times = dataLen%3;
	int page = dataLen/3;

	unsigned char *outData = (unsigned char*)malloc(4 * (page + 1) + 1);
	memset(outData,0,4 * (page + 1) + 1);

	unsigned char buff[3];
	unsigned char instr[4] = {0};
	unsigned char *ptr = data;
	unsigned char *outPtr = outData;
	for(int i = 0; i < page; i++)
	{
		memset(buff,0,3);
		memcpy(buff,ptr,3);
		ptr += 3;

		instr[0] = buff[0] >> 2;
		instr[1] = (buff[0] & 0x03) << 4 | buff[1] >> 4;
		instr[2] = (buff[1] & 0x0f << 2) | buff[2] >> 6;
		instr[3] = buff[2] & 0x3f;
				
		*outPtr++ = base64code[instr[0]];
		*outPtr++ = base64code[instr[1]];
		*outPtr++ = base64code[instr[2]];
		*outPtr++ = base64code[instr[3]];
	}
	int mod = dataLen%3;
	if(mod == 1)
	{
		buff[0] = *ptr;
		*outPtr++ = base64code[buff[0] >> 2];
		*outPtr++ = base64code[(buff[0] & 0x03) << 4 ];
		*outPtr++ = '=';
		*outPtr++ = '=';
	}
	else if(mod == 2)
	{
		buff[0] = *ptr++;
		buff[1] = *ptr;
		*outPtr++ = base64code[buff[0] >> 2];
		*outPtr++ = base64code[((buff[0] & 0x03) << 4) | (buff[1] >> 4)];
		*outPtr++ = base64code[(buff[1] & 0x0f) << 2];
		*outPtr++ = '=';
	}
	return outData;
}

unsigned char *char2hex(unsigned char *data,int dataLen)
{
	unsigned char *tmp = (unsigned char*)malloc(dataLen * 2 + 1);
	memset(tmp,0,dataLen * 2 + 1);
	char *ptr = (char*)tmp;
	for(int i = 0; i < dataLen; i++)
	{
		sprintf(ptr,"%02X",data[i]);
		ptr += 2;
	}
	return tmp;
}

unsigned char *my_encrypt(unsigned char *str,char *pubPath,char *priPath)
{
	unsigned char *p_en;
	RSA *p_rsa;
	FILE *file;
	int flen,rsa_len;

	
	if((file = fopen(pubPath,"r")) == NULL) {
		perror("open pub key file error");
		return NULL;
	}
	

	/*	
	BIO *key = NULL;
	key = BIO_new(BIO_s_file());
	BIO_read_filename(key,pubPath);
	if((p_rsa = PEM_read_bio_RSA_PUBKEY(key,NULL,NULL,NULL)) == NULL) {
	//if((p_rsa = PEM_read_bio_RSAPrivateKey(key,NULL,NULL,NULL)) == NULL) {
		ERR_print_errors_fp(stdout);
		BIO_free_all(key);
		return NULL;
	}
	*/

	
	if((p_rsa = PEM_read_RSA_PUBKEY(file,NULL,NULL,NULL)) == NULL) {
		ERR_print_errors_fp(stdout);
		return NULL;
	}
	

	/*	
	BIO *bio;
	X509 *centificate;
	bio = BIO_new(BIO_s_file());
	BIO_read_filename(bio,keyPath);
	centificate = PEM_read_bio_X509(bio,NULL,NULL,NULL);
	EVP_PKEY *pubKey = X509_get_pubkey(centificate);
	RSA *rsa_pkey = EVP_PKEY_get1_RSA(pubKey);

	if(!PEM_read_RSAPublicKey(file,&rsa_pkey,NULL,NULL))
	{
		ERR_print_errors_fp(stdout);
		return NULL;
	}
	*/	

	flen = strlen((char*)str);
	rsa_len = RSA_size(p_rsa);
	p_en = (unsigned char *)malloc(rsa_len + 1);
	memset(p_en,0,rsa_len + 1);
	int iret = RSA_public_encrypt(rsa_len,str,p_en,p_rsa,RSA_NO_PADDING);
	if(iret < 0)
	{
		return NULL;
	}
	RSA_free(p_rsa);
	fclose(file);
	
	if((file = fopen(priPath,"r")) == NULL) {
		perror("open key file error");
		return NULL;
	}

	
	if((p_rsa = PEM_read_RSAPrivateKey(file,NULL,NULL,NULL)) == NULL) {
		ERR_print_errors_fp(stdout);
		return NULL;
	}

	unsigned char p_de[1024] = {0};
	iret = RSA_private_decrypt(iret,p_en,p_de,p_rsa,RSA_NO_PADDING);
	if(iret < 0)
		return NULL;

	printf("content is [%s]
",p_de);
	RSA_free(p_rsa);
	fclose(file);
	
	return p_en;
}

pid_t get_pid_from_proc_self()
{
	char target[32];
	int pid;
	readlink("/proc/self",target,sizeof(target));
	sscanf(target,"%d",&pid);
	return pid;
}

char * get_self_executable_directory()
{
	int rval;
	char link_target[1024];
	char *last_slash;
	size_t result_length;
	char *result;

	rval =readlink("/proc/self/exe",link_target,sizeof(link_target));
	if(rval == -1)
		abort();
	else
		link_target[rval] = '';

	last_slash = strrchr(link_target,'/');
	if(last_slash == NULL || last_slash == link_target)
		abort();

	result_length = last_slash-link_target;
	result = (char*)malloc(result_length + 1);
	strncpy(result,link_target,result_length);
	result[result_length] = '';
	return result;
}

unsigned char *byteArrayToString(unsigned char *data,int dataLen) {
	char hex_char[] = "0123456789abcdef";
	
	unsigned char *output = (unsigned char*)malloc(dataLen * 2 + 1);
	bzero(output,dataLen * 2 + 1);
	unsigned char *ptr = output;
	for(int i = 0; i < dataLen; i++) {
		*ptr++ = hex_char[(data[i] & 0xf0) >> 4];
		*ptr++ = hex_char[(data[i] & 0x0f)];
	}
	return output;
}

int main() {
	/*
	printf("/proc/self reports process id %d
",get_pid_from_proc_self());
	printf("getpid() reports process id %d
",getpid());
	printf("current program path is %s
",get_self_executable_directory());
	*/

	char *msg = (char*)"12345678";
	unsigned char *buf = (unsigned char *)malloc(128);
	memset(buf,0,128);
	memcpy(buf,msg,strlen(msg));
	char pubPath[MAX_PATH] = {0};
	char priPath[MAX_PATH] = {0};
	char *executePath = get_self_executable_directory();
	sprintf(pubPath,"%s/%s",executePath,PUBSSLKEY);
	sprintf(priPath,"%s/%s",executePath,PRISSLKEY);

	printf("rsa pub key path is [%s]
",pubPath);
	printf("rsa pri key path is [%s]
",priPath);

	unsigned char *ptr_en = my_encrypt(buf,pubPath,priPath);
	//char *data = char2hex((unsigned char*)ptr_en,strlen(ptr_en));
	char *base64Data = (char*)encode64(ptr_en,128);
	printf("encrypt base64 data is [%s]
",base64Data);

	char *hexData = (char*)byteArrayToString(ptr_en,128);
	printf("encrypt hex data is [%s]
",hexData);
	return 0;
}

　　

2)Android4.2下，使用的加解密代码与之相同，只是编译时需要使用第三方openssl，然后使用ndk-build进行编译，编译成功后，使用如下命令上传到模拟器中：

使用命令 "emulator -avd android4_2"或"emulator-arm -avd android4_2",启动模拟器，我的模拟器是android4_2，如果你的和我不一样，换成你的名称。

使用adb shell登陆模拟器，在data目录下创建文件夹RSATest，将编译成功的可执行文件和rsa_public_key.pem和rsa_private_key.pem上传到该目录

3)Java使用的RSA加解密代码如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

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

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import sun.misc.BASE64Decoder;

public class RSAEncrypt {
	
	private static final String DEFAULT_PUBLIC_KEY= 
		"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrUUwBjj0lVWubst1p49N9Y9ti" + "
" +
		"Xh/L4SH5TneNCr1WZHKXDJJM7sLV071UgTl3ENfrnsndNKPXgDDoMBuNnwhCzKHJ" + "
" +
		"Hu+stxrCWBUKfF/1NawwgBdxz+HIIcwyMVfWGDvc9KSSUXVwTg9frgj9i1FF3TUB" + "
" +
		"66qVIx3fNOwrjlz+0QIDAQAB" + "
";
	
	private static final String DEFAULT_PRIVATE_KEY=
		"MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAOtRTAGOPSVVa5uy" + "
" +
		"3Wnj031j22JeH8vhIflOd40KvVZkcpcMkkzuwtXTvVSBOXcQ1+ueyd00o9eAMOgw" + "
" +
		"G42fCELMocke76y3GsJYFQp8X/U1rDCAF3HP4cghzDIxV9YYO9z0pJJRdXBOD1+u" + "
" +
		"CP2LUUXdNQHrqpUjHd807CuOXP7RAgMBAAECgYBlwRK/vXT9VtGgUxjhOA30s6Bj" + "
" +
		"CdZv/9sEBgU2LQWwfOD8JgiBUeFYOyYsi3CA5vynO1OI3sFWZ20+icbwV2tnOt4w" + "
" +
		"A0kevQsnTTgR3RzutqPdMxJT7HseukGCrLcq0FK2UxZwOxFA9ACGQB70YlYk7sbX" + "
" +
		"p4xYMJXXiz7KIVvuXQJBAPz88QLAkdcxZC/Nmbfvwv/DuyYkZpFmnK5bQUQ26GCU" + "
" +
		"KIsfeXWdupOCias8ksOHT+XqE0WIGGz6aTA78VcQADsCQQDuHn/NsNpNQ0+lbPcA" + "
" +
		"2Nd0elCFvS1iIssRu5qAOOqvzyzbhABNGaCGWa+jzz1yoB2Bm0EMhTB8z8z7n/IX" + "
" +
		"YDhjAkBKw9XWImL3XblmBzTujwTp4UZlt0w4nEKhpIZdSnzSTfbNZrfWco65GVLm" + "
" +
		"MDiPYGXUZKDdY6MUUczUXGKugCQRAkEAvZAgNFK/Z1TXuh0mAlGeLEcXhXCWCZMj" + "
" +
		"UImmNL+a7b0ju9m5F6f4KByL+/+GrpMTClPblCkP8bzINeUeKEfcewJBAM6HcCA7" + "
" +
		"G4Xbg/PeY2338D9IdWdhsRTLBbWBJUGDXXWXumwmZu1Nrqd5sjK111TQilfLTg4G" + "
" +
		"jb5e2Gx7BcieoS4=" + "
";

	/**
	 * 私钥
	 */
	private RSAPrivateKey privateKey;

	/**
	 * 公钥
	 */
	private RSAPublicKey publicKey;
	
	/**
	 * 字节数据转字符串专用集合
	 */
	private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
	

	/**
	 * 获取私钥
	 * @return 当前的私钥对象
	 */
	public RSAPrivateKey getPrivateKey() {
		return privateKey;
	}

	/**
	 * 获取公钥
	 * @return 当前的公钥对象
	 */
	public RSAPublicKey getPublicKey() {
		return publicKey;
	}

	/**
	 * 随机生成密钥对
	 */
	public void genKeyPair(){
		KeyPairGenerator keyPairGen= null;
		try {
			keyPairGen= KeyPairGenerator.getInstance("RSA");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		keyPairGen.initialize(1024, new SecureRandom());
		KeyPair keyPair= keyPairGen.generateKeyPair();
		this.privateKey= (RSAPrivateKey) keyPair.getPrivate();
		this.publicKey= (RSAPublicKey) keyPair.getPublic();
	}

	/**
	 * 从文件中输入流中加载公钥
	 * @param in 公钥输入流
	 * @throws Exception 加载公钥时产生的异常
	 */
	public void loadPublicKey(InputStream in) throws Exception{
		try {
			BufferedReader br= new BufferedReader(new InputStreamReader(in));
			String readLine= null;
			StringBuilder sb= new StringBuilder();
			while((readLine= br.readLine())!=null){
				if(readLine.charAt(0)=='-'){
					continue;
				}else{
					sb.append(readLine);
					sb.append('
');
				}
			}
			loadPublicKey(sb.toString());
		} catch (IOException e) {
			throw new Exception("公钥数据流读取错误");
		} catch (NullPointerException e) {
			throw new Exception("公钥输入流为空");
		}
	}


	/**
	 * 从字符串中加载公钥
	 * @param publicKeyStr 公钥数据字符串
	 * @throws Exception 加载公钥时产生的异常
	 */
	public void loadPublicKey(String publicKeyStr) throws Exception{
		try {
			BASE64Decoder base64Decoder= new BASE64Decoder();
			byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
			KeyFactory keyFactory= KeyFactory.getInstance("RSA");
			X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);
			this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("无此算法");
		} catch (InvalidKeySpecException e) {
			throw new Exception("公钥非法");
		} catch (IOException e) {
			throw new Exception("公钥数据内容读取错误");
		} catch (NullPointerException e) {
			throw new Exception("公钥数据为空");
		}
	}

	/**
	 * 从文件中加载私钥
	 * @param keyFileName 私钥文件名
	 * @return 是否成功
	 * @throws Exception 
	 */
	public void loadPrivateKey(InputStream in) throws Exception{
		try {
			BufferedReader br= new BufferedReader(new InputStreamReader(in));
			String readLine= null;
			StringBuilder sb= new StringBuilder();
			while((readLine= br.readLine())!=null){
				if(readLine.charAt(0)=='-'){
					continue;
				}else{
					sb.append(readLine);
					sb.append('
');
				}
			}
			loadPrivateKey(sb.toString());
		} catch (IOException e) {
			throw new Exception("私钥数据读取错误");
		} catch (NullPointerException e) {
			throw new Exception("私钥输入流为空");
		}
	}

	public void loadPrivateKey(String privateKeyStr) throws Exception{
		try {
			BASE64Decoder base64Decoder= new BASE64Decoder();
			byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);
			PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);
			KeyFactory keyFactory= KeyFactory.getInstance("RSA");
			this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("无此算法");
		} catch (InvalidKeySpecException e) {
			throw new Exception("私钥非法");
		} catch (IOException e) {
			throw new Exception("私钥数据内容读取错误");
		} catch (NullPointerException e) {
			throw new Exception("私钥数据为空");
		}
	}

	/**
	 * 加密过程
	 * @param publicKey 公钥
	 * @param plainTextData 明文数据
	 * @return
	 * @throws Exception 加密过程中的异常信息
	 */
	public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception{
		if(publicKey== null){
			throw new Exception("加密公钥为空, 请设置");
		}
		Cipher cipher= null;
		try {
//			cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
			cipher= Cipher.getInstance("RSA/ECB/NOPADDING");
			cipher.init(Cipher.ENCRYPT_MODE, publicKey);
			byte[] output= cipher.doFinal(plainTextData);
			return output;
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("无此加密算法");
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
			return null;
		}catch (InvalidKeyException e) {
			throw new Exception("加密公钥非法,请检查");
		} catch (IllegalBlockSizeException e) {
			throw new Exception("明文长度非法");
		} catch (BadPaddingException e) {
			throw new Exception("明文数据已损坏");
		}
	}

	/**
	 * 解密过程
	 * @param privateKey 私钥
	 * @param cipherData 密文数据
	 * @return 明文
	 * @throws Exception 解密过程中的异常信息
	 */
	public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception{
		if (privateKey== null){
			throw new Exception("解密私钥为空, 请设置");
		}
		Cipher cipher= null;
		try {
//			cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
			cipher= Cipher.getInstance("RSA/ECB/NOPADDING");
			cipher.init(Cipher.DECRYPT_MODE, privateKey);
			byte[] output = cipher.doFinal(cipherData);
//			byte[] output = cipher.doFinal(enBuff);
			return output;
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("无此解密算法");
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
			return null;
		}catch (InvalidKeyException e) {
			throw new Exception("解密私钥非法,请检查");
		} catch (IllegalBlockSizeException e) {
			throw new Exception("密文长度非法");
		} catch (BadPaddingException e) {
			throw new Exception("密文数据已损坏");
		}		
	}

	
	/**
	 * 字节数据转十六进制字符串
	 * @param data 输入数据
	 * @return 十六进制内容
	 */
	public static String byteArrayToString(byte[] data){
		StringBuilder stringBuilder= new StringBuilder();
		for (int i=0; i<data.length; i++){
			//取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
			stringBuilder.append(HEX_CHAR[(data[i] & 0xf0)>>> 4]);
			//取出字节的低四位 作为索引得到相应的十六进制标识符
			stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
			if (i<data.length-1){
				stringBuilder.append(' ');
			}
		}
		return stringBuilder.toString();
	}

	public static void main(String[] args){
		RSAEncrypt rsaEncrypt= new RSAEncrypt();
		//rsaEncrypt.genKeyPair();

		String defaultCharsetName = Charset.defaultCharset().displayName(); 
		System.out.println("defaultCharsetName:"+defaultCharsetName);		
		
		//加载公钥
		try {
			rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);
			System.out.println("加载公钥成功");
		} catch (Exception e) {
			System.err.println(e.getMessage());
			System.err.println("加载公钥失败");
		}

		//加载私钥
		try {
			rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);
			System.out.println("加载私钥成功");
		} catch (Exception e) {
			System.err.println(e.getMessage());
			System.err.println("加载私钥失败");
		}

		//测试字符串
		String encryptStr= "12345678";
		
		try {
			//加密
			byte[] en_content = new byte[128];
			System.arraycopy(encryptStr.getBytes(),0 , en_content, 0, encryptStr.getBytes().length);
			byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), en_content);
			//解密
			byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);
			System.out.println("密文长度:"+ cipher.length);
			System.out.println(RSAEncrypt.byteArrayToString(cipher));
			System.out.println("明文长度:"+ plainText.length);
			System.out.println(RSAEncrypt.byteArrayToString(plainText));
			System.out.println(new String(plainText));
		} catch (Exception e) {
			System.err.println(e.getMessage());
		}
	}
}

Java代码中默认公钥和私钥，是之前使用linux命令生成的rsa_public_key.pem和pkcs8_rsa_private_key.pem中的字符串。　　

需要注意的地方时，我们要加密的字符串是”12345678“，字符长度为为8为，对该字符串进行RSA加解密时，如果使用NOPADDING方式进行填充，它要求的加密长度为128位的倍数，为此，我们在C/C++和Java代码中生成一个128的缓冲区，然后将要加密的字符串拷贝至该缓冲区，之后将该缓冲区最为参数进行加密。

如果你传入的参数不是128位，而是8为，程序可以正常运行，只是不同平台和语言之间得到的加密字符串不一致，不能在多平台和多语言之间使用openssl。