C EURO rsa 加解密和java rsa加解密的对接

最新推荐文章于 2022-05-20 21:37:24 发布
最新推荐文章于 2022-05-20 21:37:24 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： rsa c 文章标签： rsa c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinyinghao/article/details/20692681
版权
rsa 同时被 2 个专栏收录
1 篇文章 0 订阅
订阅专栏
c
1 篇文章 0 订阅
订阅专栏

实际项目中遇到的情况，需要rsa加解密和签名，但是由于是嵌入式开发，openssl 的库过大，故而采用了EURO的rsa加解密和签名。但是实际情况是他们并不是完全对接的。对方服务器采用了java中的rsa和openssl rsa是对接的。故一字一字的对比后对EURO的加解密做了部分修改，完了成rsa加解密的对接。需要注意的是本例只针对1024长度。其中填充数据由对比的来，不可移植其他长度上去。

/*
 * qyh_rsa.c
 *
 *  Created on: 2012-11-4
 *      Author: qinyinghao
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "rsaeuro.h"
#include "rsa.h"

int rsa_public_encode(char *in, int in_len, char *out, int *out_len,
		const char *key, int key_len) {
	int j = 0;
	char temp[258] = { 0 };
	unsigned char iv[8];
	R_RSA_PUBLIC_KEY *publicKey =NULL;
	R_RANDOM_STRUCT *randomStruct =NULL;
	publicKey = (R_RSA_PUBLIC_KEY *) malloc(
			sizeof(R_RSA_PUBLIC_KEY));
	memset(publicKey,0,sizeof(R_RSA_PUBLIC_KEY));
	for (j = 0; j < 258; j++) {
		//	printf("%d  0x%02X\n", j, *(key + j));
		temp[j] = *(key + j);
	}
	//memcpy(publicKey->bits, temp, 2);
	publicKey->bits = 1024;
	for (j = 0; j < 128; j++) {
		publicKey->modulus[j] = *(temp + 2 + j);
		publicKey->exponent[j] = *(temp + 130 + j);
	}
	randomStruct = (R_RANDOM_STRUCT *) malloc(
			sizeof(R_RANDOM_STRUCT));
	memset(randomStruct,0,sizeof(R_RANDOM_STRUCT));
	R_GenerateBytes(temp, 258, randomStruct);
	R_GenerateBytes(iv, 8, randomStruct);
	int i = RSAPublicEncrypt(out, out_len, in, in_len, publicKey, randomStruct);
	if(publicKey!=NULL){
		free(publicKey);
		publicKey=NULL;
	}
	if(randomStruct!=NULL){
		free(randomStruct);
		randomStruct=NULL;
	}
	return i;
}

int rsa_private_decode(char *in, int in_len, char *out, int *out_len, char *key,
		int key_len) {
	char temp[706] = { 0 };
	int j = 0, i = 0;
	R_RSA_PRIVATE_KEY *privateKey =NULL;
	for (j = 0; j < 706; j++) {
		//	printf("%d  0x%02X\n", j, *(key + j));
		temp[j] = *(key + j);
	}
	privateKey = (R_RSA_PRIVATE_KEY *) malloc(
			sizeof(R_RSA_PRIVATE_KEY));
	memset(privateKey,0,sizeof(R_RSA_PRIVATE_KEY));
	//将key转存到privatekey中
	privateKey->bits = 1024;
	for (j = 0; j < 128; j++) {
		privateKey->modulus[j] = *(temp + 2 + j);
		privateKey->publicExponent[j] = *(temp + 130 + j);
		privateKey->exponent[j] = *(temp + 258 + j);
	}
	for (j = 0; j < 64; j++) {
		privateKey->prime[0][j] = *(temp + 386 + j);
		privateKey->prime[1][j] = *(temp + 450 + j);
		privateKey->primeExponent[0][j] = *(temp + 514 + j);
		privateKey->primeExponent[1][j] = *(temp + 578 + j);
		privateKey->coefficient[j] = *(temp + 642 + j);
	}

	i = RSAPrivateDecrypt(out, out_len, in, in_len, privateKey);
	if(privateKey!=NULL){
		free(privateKey);
		privateKey=NULL;
	}
	return i;
}

/**
 * md5绛惧�
 */
int rsa_sign(char *in, int in_len, char *out, int *out_len, char *key,
		int key_len) {
	int digestAlgorithm, status;
	R_SIGNATURE_CTX context = { 0 };
	digestAlgorithm = 5; //浠ｈ〃md5
	status = 0;
	R_RSA_PRIVATE_KEY *privateKey =NULL;

	char temp[706] = { 0 };
	int j = 0, i = 0;
	for (j = 0; j < 706; j++) {
		temp[j] = *(key + j);
	}

	privateKey = (R_RSA_PRIVATE_KEY *) malloc(
			sizeof(R_RSA_PRIVATE_KEY));
	memset(privateKey,0,sizeof(R_RSA_PRIVATE_KEY));
	//将key转存到privatekey中
	privateKey->bits = 1024;
	for (j = 0; j < 128; j++) {
		privateKey->modulus[j] = *(temp + 2 + j);
		privateKey->publicExponent[j] = *(temp + 130 + j);
		privateKey->exponent[j] = *(temp + 258 + j);
	}
	for (j = 0; j < 64; j++) {
		privateKey->prime[0][j] = *(temp + 386 + j);
		privateKey->prime[1][j] = *(temp + 450 + j);
		privateKey->primeExponent[0][j] = *(temp + 514 + j);
		privateKey->primeExponent[1][j] = *(temp + 578 + j);
		privateKey->coefficient[j] = *(temp + 642 + j);
	}

//md5
	if ((status = R_SignInit(&context, digestAlgorithm)) == 0) {
		R_SignUpdate(&context, in, in_len);
		//绛惧�
		if ((status = R_SignFinal(&context, out, out_len, privateKey)) == 0) {
			//printf("sign successful!\n");
			if(privateKey!=NULL){
				free(privateKey);
				privateKey=NULL;
			}
			return 0;
		} else {
			printf("sign fail 01!\n");
			if(privateKey!=NULL){
				free(privateKey);
				privateKey=NULL;
			}
			return -1;
		}
	} else {
		printf("sign fail 02!\n");
		if(privateKey!=NULL){
			free(privateKey);
			privateKey=NULL;
		}
		return -1;
	}
}

int rsa_varify(char *in, int in_len, char *out, int *out_len, char *key,
		int key_len) {
	R_RSA_PUBLIC_KEY *publicKey=NULL;
	char temp[258] = { 0 };
	R_SIGNATURE_CTX context;
	int digestAlgorithm, status, j;
	status = 0;
	digestAlgorithm = 5;

	publicKey = (R_RSA_PUBLIC_KEY *) malloc(sizeof(R_RSA_PUBLIC_KEY));
	for (j = 0; j < 258; j++) {
		//	printf("%d  0x%02X\n", j, *(key + j));
		temp[j] = *(key + j);
	}
	publicKey->bits = 1024;
	for (j = 0; j < 128; j++) {
		publicKey->modulus[j] = *(temp + 2 + j);
		publicKey->exponent[j] = *(temp + 130 + j);
	}

//md5
	R_VerifyInit(&context, digestAlgorithm);
	if ((status = R_VerifyUpdate(&context, in, in_len)) != 0) {
		printf("varify error 01\n");
		if(publicKey!=NULL){
			free(publicKey);
			publicKey=NULL;
		}
		return -1;
	}
	status = R_VerifyFinal(&context, out, out_len, publicKey);
	if(publicKey!=NULL){
		free(publicKey);
		publicKey=NULL;
	}
	return status == 0 ? 0 : -1;
}


#include <stdio.h>
#include <string.h>
#include "RSAEURO/rsaeuro.h"
#include "RSAEURO/qyh_rsa.h"

static char MYPK[512] = {0};
static char MYSK[1024] = {0};
static char HISPK[512] = {0};

int jiamiPackageInfo(char *in, char *securityInfo, char *packageInfo,
		char *signagureInfo) {
		
	//Ë°ŸÖ¹«Ô¿ÑéրǩÃû
	unsigned char mypk_e[512] = { 0x00 };	//¹«Ô¿ECB
	unsigned char mysk_e[1024] = { 0x00 };	//˜ԿECB
	unsigned char hispk_e[512] = { 0x00 };	//Ë°ŸÖ¹«Ô¿ECB

	int mypublickey_len = 0;
	int myprivatekey_len = 0;
	int hispublickey_len = 0;
	int i = 0;

	unsigned char packageInfo_befor64[1024] = { 0 };
	int packageInfo_before64_len = 0;
	unsigned char signagureInfo_befor64[1024] = { 0 };
	int signagureInfo_befor64_len = 0;

	char securityInfo_before64[256] = { 0 };
	int securityInfo_before64_len = 0;
	unsigned char suijima[] = { 0x24, 0x6d, 0x61, 0x6b, 0x65, 0x6d, 0x6f, 0x6e,
			0x65, 0x79, 0x32, 0x30, 0x31, 0x32, 0x00, 0x00 }; //Ëæ»úÊý

	unsigned char *mypublickey = NULL;
	unsigned char *myprivatekey = NULL;
	unsigned char *hispublickey = NULL;
	mypublickey = (char *) malloc(sizeof(char) * 2048);
	memset(mypublickey, 0, 2048);
	myprivatekey = (unsigned char *) malloc(sizeof(char) * 2048);
	memset(myprivatekey, 0, 2048);
	hispublickey = (char *) malloc(sizeof(char) * 2048);
	memset(hispublickey, 0, 2048);
	
	base64_decode(MYPK, strlen(MYPK), mypublickey, &mypublickey_len);
	
	base64_decode(MYSK, strlen(MYSK), myprivatekey, &myprivatekey_len);
	
	base64_decode(HISPK, strlen(HISPK), hispublickey, &hispublickey_len);
	
	mypk_e[0] = 0x00;
	mypk_e[1] = 0x04;
	//žŽÖÆ128λeÖµ
	for (i = 0; i < 128; i++) {
		mypk_e[i + 2] = mypublickey[i + 29];
	}
	//žŽÖÆÈýλnÖµ
	for (i = 0; i < 3; i++) {
		mypk_e[i + 255] = mypublickey[mypublickey_len - 3 + i];
	}

	//ËûµÄ¹«Ô¿
	
	hispk_e[0] = 0x00;
	hispk_e[1] = 0x04;
	//žŽÖÆ128λeÖµ
	for (i = 0; i < 128; i++) {
		hispk_e[i + 2] = hispublickey[i + 29];
	}
	//žŽÖÆÈýλnÖµ
	for (i = 0; i < 3; i++) {
		hispk_e[i + 255] = hispublickey[hispublickey_len - 3 + i];
	}

	//ÎҵĘԿ
	
	mysk_e[0] = 0x00;
	mysk_e[1] = 0x04;
	for (i = 0; i < 128; i++) {
		mysk_e[i + 2] = myprivatekey[37 + i];
	}
	for (i = 0; i < 3; i++) {
		mysk_e[i + 255] = myprivatekey[167 + i];
	}

	for (i = 0; i < 128; i++) {
		mysk_e[i + 258] = myprivatekey[i + 174];
	}

	for (i = 0; i < 64; i++) {
		mysk_e[i + 386] = myprivatekey[i + 305];
		mysk_e[i + 450] = myprivatekey[i + 372];
		mysk_e[i + 514] = myprivatekey[i + 438];
		mysk_e[i + 578] = myprivatekey[i + 504];
		mysk_e[i + 642] = myprivatekey[i + 570];
	}

    //1.Ë°ŸÖ¹«Ô¿ŒÓÃÜ,²¢base64µÃµœsecurityInfo
	
	rsa_public_encode(suijima, 16, securityInfo_before64,
			&securityInfo_before64_len, hispk_e, 258);
	

	base64_encode(securityInfo_before64, securityInfo_before64_len,
			securityInfo);

	//2.¶ÔpackageInfoÔ­ÎÄdesŒÓÃÜ,base64ºó·ÅÈëPackageInfoÖÐ
	
	des_encode(in, strlen(in), packageInfo_befor64, &packageInfo_before64_len,
			suijima);
	
	base64_encode(packageInfo_befor64, packageInfo_before64_len, packageInfo);

	//3,¶ÔpackageInfoBefor64Ç©Ãû
	
	rsa_sign(packageInfo_befor64, packageInfo_before64_len,
			signagureInfo_befor64, &signagureInfo_befor64_len, mysk_e, 706);
		
	base64_encode(signagureInfo_befor64, signagureInfo_befor64_len,
			signagureInfo);

	if (NULL != myprivatekey)
	{
		free(myprivatekey);
		myprivatekey = NULL;
	}
	if (NULL != mypublickey)
	{
		free(mypublickey);
		mypublickey = NULL;
	}
	if (NULL != hispublickey)
	{
		free(hispublickey);
		hispublickey = NULL;
	}
	
	
	return 0;
}

int getPackageInfo(char *securityInfo, char *packageInfo, char *signagureInfo,
		char *mingwen) {
	unsigned char mypk_e[259] = {0x00};
	unsigned char hispk_e[259] = {0x00};
	unsigned char mysk_e[707] = { 0x00 };
	unsigned char beforeSign[1024*8] = { 0 };
	unsigned char afterSign[1024*8] = { 0 };
	unsigned char suijima[256] = { 0 };
	unsigned char out1[256] = { 0 };
	
	char *mypublickey = (char *) malloc(sizeof(char) * 2048);
	unsigned char *myprivatekey = (unsigned char *) malloc(sizeof(char) * 2048);
	char *hispublickey = (char *) malloc(sizeof(char) * 2048);
	
	memset(mypublickey,0,2048);
	memset(myprivatekey,0,2048);
	memset(hispublickey,0,2048);
	
	int beforeSign_len = 0;
	int afterSign_len = 0;
	int out1_len = 0;
	int suijima_len = 0;
	int mingwen_len = 0,res = 0,varifyResult = 0;
	int hispublickey_len = 0;
	int myprivatekey_len = 0;
	int mypublickey_len = 0;
	int i = 0;

	memset(mypk_e,0,259);
	memset(hispk_e,0,259);
	memset(mysk_e,0,707);
	memset(beforeSign,0,1024*8);
	memset(afterSign,0,1024*8);
	memset(suijima,0,256);
	memset(out1,0,256);
		
	base64_decode(MYPK, strlen(MYPK), mypublickey, &mypublickey_len);
	
	base64_decode(MYSK, strlen(MYSK), myprivatekey, &myprivatekey_len);
	
	base64_decode(HISPK, strlen(HISPK), hispublickey, &hispublickey_len);
	
	mypk_e[0] = 0x00;
	mypk_e[1] = 0x04;
	//žŽÖÆ128λeÖµ
	for (i = 0; i < 128; i++) {
		mypk_e[i + 2] = mypublickey[i + 29];
	}
	//žŽÖÆÈýλnÖµ
	for (i = 0; i < 3; i++) {
		mypk_e[i + 255] = mypublickey[mypublickey_len - 3 + i];
	}

	//¹«Ô¿
	
	hispk_e[0] = 0x00;
	hispk_e[1] = 0x04;
	//žŽÖÆ128λeÖµ
	for (i = 0; i < 128; i++) {
		hispk_e[i + 2] = hispublickey[i + 29];
	}
	//žŽÖÆÈýλnÖµ
	for (i = 0; i < 3; i++) {
		hispk_e[i + 255] = hispublickey[hispublickey_len - 3 + i];
	}

	//ÎҵĘԿ
	
	mysk_e[0] = 0x00;
	mysk_e[1] = 0x04;
	for (i = 0; i < 128; i++) {
		mysk_e[i + 2] = myprivatekey[37 + i];
	}
	for (i = 0; i < 3; i++) {
		mysk_e[i + 255] = myprivatekey[167 + i];
	}

	for (i = 0; i < 128; i++) {
		mysk_e[i + 258] = myprivatekey[i + 174];
	}

	for (i = 0; i < 64; i++) {
		mysk_e[i + 386] = myprivatekey[i + 305];
		mysk_e[i + 450] = myprivatekey[i + 372];
		mysk_e[i + 514] = myprivatekey[i + 438];
		mysk_e[i + 578] = myprivatekey[i + 504];
		mysk_e[i + 642] = myprivatekey[i + 570];
	}
	//Ë°ŸÖ¹«Ô¿ÑéրǩÃû
	
	base64_decode(packageInfo, strlen(packageInfo), beforeSign,
			&beforeSign_len);
	
	base64_decode(signagureInfo, strlen(signagureInfo), afterSign,
			&afterSign_len);
	varifyResult = rsa_varify(beforeSign, beforeSign_len, afterSign,
			afterSign_len, hispk_e, 258);
	if (varifyResult < 0) {
		//Ñéրʧ°Ü
		printf("ÑéրǩÃûʧ°Ü\n");
		return -1;
	} else {
		//ÑéÖ€³É¹Š
		printf("ÑéրǩÃû³É¹Š\n");
	}

	//ω̆packageInfo
	//»ñÈ¡Ëæ»úÂë
	
	base64_decode(securityInfo, strlen(securityInfo), out1, &out1_len);
	//ÎҵĘԿœâÃÜ
	
	rsa_private_decode(out1, out1_len, suijima, &suijima_len, mysk_e, 706);
	
	res = des_decode(beforeSign, beforeSign_len, mingwen, &mingwen_len,
			suijima);
	if (res != 0) {
		printf("des decode fail!\n");
	} else {
		printf("des decode success!\nThe packageInfo we get is:\n%s\n", mingwen);
	}

	if (NULL != myprivatekey)
	{
		free(myprivatekey);
		myprivatekey = NULL;
	}
	if (NULL != mypublickey)
	{
		free(mypublickey);
		mypublickey = NULL;
	}
	if (NULL != hispublickey)
	{
		free(hispublickey);
		hispublickey = NULL;
	}
}
/*
******************************************************
*	¶ÁÈ¡ÃÜÔ¿ÎÄŒþ
*	ÎÄŒþÃû³Æ:mypk,mysk,hispk
*	·µ»ØÖµ:
*	0:Õý³£·µ»Ø
*	-1:¶ÁÈ¡mypkʧ°Ü
*	-2:¶ÁÈ¡myskʧ°Ü
* 	-3:¶ÁÈ¡hispkʧ°Ü
******************************************************
*/
int readRsaKey(void)
{
	char CH;
	int i = 0;
	int returnvalue = 0;
	
	FILE *fp1 = NULL;
	FILE *fp2 = NULL;
	FILE *fp3 = NULL;
	
	memset(MYPK,0,512);
	memset(MYSK,0,1024);
	memset(HISPK,0,512);
	
	i = 0;
	if((fp1=fopen("/f-disk/app/mypk","r"))==NULL){
		returnvalue =  -1;
		goto returnout;
	}
	CH=fgetc(fp1);
    while(CH!=EOF&&CH!=0xFF) { 
		MYPK[i++]=CH;
		CH=fgetc(fp1);
    }
	MYPK[i]='\0';

	i = 0;
	if((fp2=fopen("/f-disk/app/mysk","r"))==NULL){
		returnvalue =  -2;
		goto returnout;
	}
	CH=fgetc(fp2);
    while(CH!=EOF&&CH!=0xFF) { 
		MYSK[i++]=CH;
		CH=fgetc(fp2);
    }
	MYSK[i]='\0';

	i = 0;
	if((fp3=fopen("/f-disk/app/hispk","r"))==NULL){
		returnvalue = -3;
		goto returnout;
	}
	CH=fgetc(fp3);
    while(CH!=EOF&&CH!=0xFF) { 
		HISPK[i++]=CH;
		CH=fgetc(fp3);
    }
	HISPK[i]='\0';
	
returnout:
	if(fp1!=NULL)
		fclose(fp1);
	if(fp2!=NULL)
		fclose(fp2);
	if(fp3!=NULL)
		fclose(fp3);
	return returnvalue;
}



jsqinyinghao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android C、C++与java端RSA互通
小人物大志向的博客
09-26 2190
直接上代码：public class RSAUtils { //加密算法RSA public static final String KEY_ALGORITHM = "RSA"; //获取公钥的key private static final String PUBLIC_KEY = "RSAPublicKey"; //获取私钥的key private s
Java实现的RSA加密解密算法示例
08-28
本文详细介绍了Java实现的RSA加密解密算法，包括密钥对生成、公钥和私钥的使用、加密和解密、密钥文件的生成等知识点。这些知识点对于Java开发者来说非常重要，可以帮助他们更好地理解和实现RSA加密解密算法。
rsaeuro-1.04.tar.gz
01-14
rsaeuro-1.04.tar.gz C语言实现的RSA算法
javaRSA加密C++RSA解密
11-28
Java OpenSSL生成的RSA公私钥进行数据加解密详细介绍 项目： JAVA生成的RSA的密文，通过C++来解密。 RSA这里就不多介绍了大家自己去看。 JAVA也是通过包来实现加密和解密的，那么我的C++是通过OPENSSL的库来实现的。 重点来到了：RSA使用过程 1、C++随机生成一对公钥和私钥 2、JAVA用公钥给明文打包形成密文 3、C++用私钥解密密文
RSA加解密实现，修改自RSAEuro
09-06
此代码有如下特点： 1 知道解密结果是否正确 省去了在数据里加校验和 2 知道解密后的数据大小 省去了在数据里标明大小 3 在用公钥加密数据时用到了随机数 即每次加密相同的数据结果都不一样 省去了在数据里随机数 4 公钥加密私钥解密 私钥加密公钥解密 一对密钥即可相互传输数据 5 支持512 1024 2048三种级别的加密 更多信息请移步 http: blog csdn net sidyhe article details 39102329">此代码有如下特点： 1 知道解密结果是否正确 省去了在数据里加校验和 2 知道解密后的数据大小 省去了在数据里标明大小 3 在用公钥加密数据时用到了随机数 即每次加密相同的数据结果都不一样 省去了在数据里随机数 4 [更多]
公钥私解和私钥公解的应用RSA的加密
topMan'blog
08-15 198
/** * RSA 工具类。提供加密，解密，生成密钥对等方法。 * 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。 * RSA加密原理概述   * RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。   * 据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积   * ==========...
RSA.rar_RSA加密解密和
09-21
RSA算法是最著名的公开密码体制。...其公开密钥和私人密钥是一对大素数的函数，从一个公开密钥和密文中恢复出明文的难度等价于分解两个大素数之积。算法过程：首先是设计密钥，然后是对消息加密，最后是对密文解密。
RSA 加密 解密 C# Java 转化.zip
09-15
可以实现C# Rsa加密（私钥加密、公钥解密、密钥格式转换、支持超大长度分段加密）.net 转 java，java 转 .net 比如有一个开放平台：和目平台 亲测可用。他们就是只提供java的密钥，我已成功调用！如果有疑问需要...
rsa.zip_RSA 加密解密_rsa java
09-14
在Java中实现RSA加密解密，你需要导入java.security.*和javax.crypto.*这两个包，其中KeyPairGenerator类用于生成公钥和私钥对，Cipher类用于执行加密和解密操作。以下是一个简单的步骤概述： 1. 导入必要的库： `...
java_RSA加解密+RSA分段加解密.zip
06-13
使用RSA非对称加密完成Java后端RSA加密和分段加解密,最近研究了RSA非对称加密，关于什么是RSA，网上各种文章一搜一大把，由于RSA的特性，一个1024位的密钥只能加密117位...下面就给出如何完成后端RSA加解密和分段加解密
RSA密钥生成原理以及工具rsaeuro的移植和编译
tugouxp的专栏
05-20 1651
rsaeuro是一款小巧的开源rsa算法库，它支持生成RSA Key，签名，校验，对称加密，哈希算法等多种功能，可以说是一款应对非对称加解密应用的利器，被广泛应用在多种嵌入式应用场合，比如前东家的高安机顶盒，下面简述一下它的开发步骤。
Java RSA私钥的格式pkcs1和pkcs8、PrivateKey转换
茅坤宝骏氹的博客
10-17 9147
（）一、私钥格式 （1）pkcs1 格式： -----BEGIN RSA PRIVATE KEY----- ... -----END RSA PRIVATE KEY----- （2）pkcs8 格式： -----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY----- pkcs1私钥生成openssl genrsa -out pkcs1.pem 1024 pkcs1转pkcs8私钥 ：openssl pkcs8 -in pkcs8....
OpenSSL库的RSA使用
zzhongcy的专栏
05-15 1575
转自：http://blog.csdn.net/fenghaibo00/article/details/17249493 本文上接：OpenSSL库的RSA使用(上)-EVP方式，URL：http://blog.csdn.net/fenghaibo00/article/details/17248381 3      RSA函数方式 3.1 步骤
openssl 加密
崔建忠的专栏
08-16 1344
PS：昨天有童鞋问我在linux用tar打包文件是否可以加密码。其实是可以的，不过要跟openssl结合使用。用法如下： 在当前目录下有一个pma目录的文件夹: 1、使用tar对文件压缩加密： # tar -zcvf - pma|openssl des3 -salt -k password | dd of=pma.des3 完成将得到一个pma.des3的打包文件，用你设置的密码替换pas
基于Crypto++/Cryptopp的rsa密钥生成，rsa加密、解密，rsa签名、验签
晴天的专栏
01-29 5075
转载于http://www.xdty.org/1678 在项目中需要增加一个注册的功能，想到了用rsa非对称加密的方法。对比了openssl等第三方库，最后采用了Cryptopp。 1.源文件整理 可以在http://www.cryptopp.com/获取库的源文件，解压后将文件重新归档。头文件放置到include文件夹，cpp放到src目录。同时去除所有的test相关的cp
使用RSA算法加密数据
SomeTimes
09-06 6697
近期做程序，需要用到
rsa加解密 java
最新发布
05-31
RSA（Rivest–Shamir–Adleman）是一种非对称加密算法，可以用于加密和解密数据。在Java中，可以使用Java加密扩展（Java Cryptography Extension，JCE）提供的RSA类来实现RSA加解密。 以下是一个简单的RSA加解密示例： ```java import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Security; import javax.crypto.Cipher; public class RSADemo { public static void main(String[] args) throws Exception { Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); // 生成RSA密钥对 KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", "BC"); generator.initialize(2048); KeyPair keyPair = generator.generateKeyPair(); PrivateKey privateKey = keyPair.getPrivate(); PublicKey publicKey = keyPair.getPublic(); // 使用公钥加密数据 Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC"); cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] input = "Hello, world!".getBytes(); byte[] cipherText = cipher.doFinal(input); System.out.println("Cipher text: " + new String(cipherText)); // 使用私钥解密数据 cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] plainText = cipher.doFinal(cipherText); System.out.println("Plain text: " + new String(plainText)); } } ``` 需要注意的是，上面的示例中使用的是Bouncy Castle作为Java加密扩展提供者，需要将Bouncy Castle库添加到项目中才能正常运行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值