java环境下实现idea算法的加密解密

Posted 2023-05-12

有这样的资料请发到我的邮箱[e-mail]，谢谢

基于Java的IDEA加密算法探讨
随着Internet的迅速发展,电子商务的浪潮势不可挡，日常工作和数据传输都放在Internet网上进行传输,大大提高了效率,降低了成本,创造了良好的效益。但是,由于 Internet网络协议本身存在着重要的安全问题(IP包本身并不继承任何安全特性,很容易伪造出IP包的地址、修改其内容、重播以前的包以及在传输途中拦截并查看包的内容),使网上的信息传输存在巨大的安全风险电子商务的安全问题也越来越突出。加密是电子商务中最主要的安全技术,加密方法的选取直接影响电子商务活动中信息的安全程度，在电子商务系统中,主要的安全问题都可以通过加密来解决。数据的保密性可通过不同的加密算法对数据加密来实现。
对我国来讲，虽然可以引进很多的外国设备，但加密设备不能依靠引进，因为它涉及到网络安全、国家机密信息的安全，所以必须自己研制。当前国际上有许多加密算法，其中DES（Data Encryption Standard）是发明最早的用得最广泛的分组对称加密算法，DES用56位蜜钥加密64位明文，输出64位密文，DES的56位密钥共有256 种可能的密钥，但历史上曾利用穷举攻击破解过DES密钥，1998年电子边境基金会（EFF）用25万美元制造的专用计算机，用56小时破解了DES的密钥，1999年，EFF用22小时完成了破解工作，使DES算法受到了严重打击，使它的安全性受到严重威胁。因为JAVA语言的安全性和网络处理能力较强，本文主要介绍使用IDEA（Internation Data Encryption Algorithm ）数据加密算法在Java环境下实现数据的安全传输。

一、IDEA数据加密算法

IDEA数据加密算法是由中国学者来学嘉博士和著名的密码专家 James L. Massey 于1990年联合提出的。它的明文和密文都是64比特，但密钥长为128比特。IDEA 是作为迭代的分组密码实现的，使用 128 位的密钥和 8 个循环。这比 DES 提供了更多的 安全性，但是在选择用于 IDEA 的密钥时，应该排除那些称为“弱密钥”的密钥。DES 只有四个弱密钥和 12 个次弱密钥，而 IDEA 中的弱密钥数相当可观，有 2 的 51 次方个。但是，如果密钥的总数非常大，达到 2 的 128 次方个，那么仍有 2 的 77 次方个密钥可供选择。IDEA 被认为是极为安全的。使用 128 位的密钥，蛮力攻击中需要进行的测试次数与 DES 相比会明显增大，甚至允许对弱密钥测试。而且，它本身也显示了它尤其能抵抗专业形式的分析性攻击。

二、Java密码体系和Java密码扩展

Java是Sun公司开发的一种面向对象的编程语言,并且由于它的平台无关性被大量应用于Internet的开发。Java密码体系(JCA)和Java密码扩展(JCE)的设计目的是为Java提供与实现无关的加密函数API。它们都用factory方法来创建类的例程,然后把实际的加密函数委托给提供者指定的底层引擎,引擎中为类提供了服务提供者接口在Java中实现数据的加密/解密,是使用其内置的JCE(Java加密扩展)来实现的。Java开发工具集1.1为实现包括数字签名和信息摘要在内的加密功能,推出了一种基于供应商的新型灵活应用编程接口。Java密码体系结构支持供应商的互操作,同时支持硬件和软件实现。Java密码学结构设计遵循两个原则:(1)算法的独立性和可靠性。(2)实现的独立性和相互作用性。算法的独立性是通过定义密码服务类来获得。用户只需了解密码算法的概念,而不用去关心如何实现这些概念。实现的独立性和相互作用性通过密码服务提供器来实现。密码服务提供器是实现一个或多个密码服务的一个或多个程序包。软件开发商根据一定接口,将各种算法实现后,打包成一个提供器,用户可以安装不同的提供器。安装和配置提供器,可将包含提供器的ZIP和JAR文件放在CLASSPATH下,再编辑Java安全属性文件来设置定义一个提供器。Java运行环境Sun版本时,提供一个缺省的提供器Sun。

三、Java环境下的实现

1．加密过程的实现

void idea_enc( int data11[], /*待加密的64位数据首地址*/ int key1[])

int i ;

int tmp,x;

int zz[]=new int[6];

for ( i = 0 ; i < 48 ; i += 6) /*进行8轮循环*/

for(int j=0,box=i; j<6; j++,box++)

zz[j]=key1[box];



x = handle_data(data11,zz);

tmp = data11[1]; /*交换中间两个*/

data11[1] = data11[2];

data11[2] = tmp;



tmp = data11[1]; /*最后一轮不交换*/

data11[1] = data11[2];

data11[2] = tmp;

data11[0] = MUL(data11[0],key1[48]);

data11[1] =(char)((data11[1] + key1[49])%0x10000);

data11[2] =(char)((data11[2] + key1[50])%0x10000);

data11[3] = MUL(data11[3],key1[51]);



2．解密过程的实现

void key_decryExp(int outkey[])/*解密密钥的变逆处理*/

int tmpkey[] = new int[52] ;

int i;

for ( i = 0 ; i < 52 ; i++)

tmpkey[i] = outkey[ wz_spkey[i] ] ; /*换位*/



for ( i = 0 ; i < 52 ; i++)

outkey[i] = tmpkey[i];



for ( i = 0 ; i < 18 ; i++)

outkey[wz_spaddrever[i]] = (char)(65536-outkey[wz_spaddrever[i]]) ; /*替换成加法逆*/



for ( i = 0 ; i < 18 ; i++)

outkey[wz_spmulrevr[i]] =(char)(mulInv(outkey[wz_spmulrevr[i]] )); /*替换成乘法逆*/





四、总结

在实际应用中,我们可以使用Java开发工具包(JDK)中内置的对Socket通信的支持,通过JCE中的Java流和链表,加密基于Socket的网络通信.我们知道,加密/解密是数据传输中保证数据完整性的常用方法,Java语言因其平台无关性,在Internet上的应用非常之广泛.使用Java实现基于IDEA的数据加密传输可以在不同的平台上实现并具有实现简洁、安全性强等优点。

参考资料：http://java.csdn.net/page/78e20993-942e-45fd-9643-4b2d78cb290b

参考技术A /*
* IDEA.java
*
* Created on 2007-9-21, 7:20:07
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package frelationmainten;

/**
*
* @author cloud
*/
public class IDEA
private byte[] bytekey;
public byte[] getKey(String key)
int len1 =key.length();
if (len1>=16)
key=key.substring(0, 16);
else
for (int i=0;i<16-len1;i++)
key=key.concat("0");


bytekey=key.getBytes();
return bytekey;

/**
* 加密String明文输入,String密文输出
* @param strMing
* @return
*/
public String getEncString(String strMing)
byte[] byteMi = null;
byte[] byteMing = null;
String strMi = "";
try
return byte2hex(IdeaEncrypt(bytekey,strMing.getBytes(),true) );

catch(Exception e)
e.printStackTrace();

finally
byteMing = null;
byteMi = null;

return strMi;

/**
* 解密 以String密文输入,String明文输出
* @param strMi
* @return
*/
public String getDesString(String strMi)
byte[] byteMing = null;
byte[] byteMi = null;
String strMing = "";
try
String tmp= new String(IdeaEncrypt(bytekey,hex2byte(strMi.getBytes()),false ));
int len1=tmp.length();
return tmp.substring(0, len1-6);

catch(Exception e)
e.printStackTrace();

finally
byteMing = null;
byteMi = null;

return strMing;

private byte[] Encrypt(byte[] bytekey, byte[] inputBytes, boolean flag)
byte[] encryptCode = new byte[8];
// 分解子密钥
int[] key = get_subkey(flag, bytekey);
// 进行加密操作
encrypt(key, inputBytes, encryptCode);
// 返回加密数据
return encryptCode;


private int bytesToInt(byte[] inBytes, int startPos)
return ((inBytes[startPos] << 8) & 0xff00) +
(inBytes[startPos + 1] & 0xff);


private void intToBytes(int inputInt, byte[] outBytes, int startPos)
outBytes[startPos] = (byte) (inputInt >>> 8);
outBytes[startPos + 1] = (byte) inputInt;


private int x_multiply_y(int x, int y)
if (x == 0)
x = 0x10001 - y;
else if (y == 0)
x = 0x10001 - x;
else
int tmp = x * y;
y = tmp & 0xffff;
x = tmp >>> 16;
x = (y - x) + ((y < x) ? 1 : 0);


return x & 0xffff;


private void encrypt(int[] key, byte[] inbytes, byte[] outbytes)
int k = 0;
int a = bytesToInt(inbytes, 0);
int b = bytesToInt(inbytes, 2);
int c = bytesToInt(inbytes, 4);
int d = bytesToInt(inbytes, 6);

for (int i = 0; i < 8; i++)
a = x_multiply_y(a, key[k++]);
b += key[k++];
b &= 0xffff;
c += key[k++];
c &= 0xffff;
d = x_multiply_y(d, key[k++]);

int tmp1 = b;
int tmp2 = c;
c ^= a;
b ^= d;
c = x_multiply_y(c, key[k++]);
b += c;
b &= 0xffff;
b = x_multiply_y(b, key[k++]);
c += b;
c &= 0xffff;
a ^= b;
d ^= c;
b ^= tmp2;
c ^= tmp1;


intToBytes(x_multiply_y(a, key[k++]), outbytes, 0);
intToBytes(c + key[k++], outbytes, 2);
intToBytes(b + key[k++], outbytes, 4);
intToBytes(x_multiply_y(d, key[k]), outbytes, 6);


private int[] encrypt_subkey(byte[] byteKey)
int[] key = new int[52];

if (byteKey.length < 16)
byte[] tmpkey = new byte[16];
System.arraycopy(byteKey, 0, tmpkey,
tmpkey.length - byteKey.length, byteKey.length);
byteKey = tmpkey;


for (int i = 0; i < 8; i++)
key[i] = bytesToInt(byteKey, i * 2);


for (int j = 8; j < 52; j++)
if ((j & 0x7) < 6)
key[j] = (((key[j - 7] & 0x7f) << 9) | (key[j - 6] >> 7)) &
0xffff;
else if ((j & 0x7) == 6)
key[j] = (((key[j - 7] & 0x7f) << 9) | (key[j - 14] >> 7)) &
0xffff;
else
key[j] = (((key[j - 15] & 0x7f) << 9) | (key[j - 14] >> 7)) &
0xffff;



return key;


private int fun_a(int a)
if (a < 2)
return a;


int b = 1;
int c = 0x10001 / a;

for (int i = 0x10001 % a; i != 1;)
int d = a / i;
a %= i;
b = (b + (c * d)) & 0xffff;

if (a == 1)
return b;

d = i / a;
i %= a;
c = (c + (b * d)) & 0xffff;


return (1 - c) & 0xffff;


private int fun_b(int b)
return (0 - b) & 0xffff;


private int[] uncrypt_subkey(int[] key)
int dec = 52;
int asc = 0;
int[] unkey = new int[52];
int aa = fun_a(key[asc++]);
int bb = fun_b(key[asc++]);
int cc = fun_b(key[asc++]);
int dd = fun_a(key[asc++]);
unkey[--dec] = dd;
unkey[--dec] = cc;
unkey[--dec] = bb;
unkey[--dec] = aa;

for (int k1 = 1; k1 < 8; k1++)
aa = key[asc++];
bb = key[asc++];
unkey[--dec] = bb;
unkey[--dec] = aa;
aa = fun_a(key[asc++]);
bb = fun_b(key[asc++]);
cc = fun_b(key[asc++]);
dd = fun_a(key[asc++]);
unkey[--dec] = dd;
unkey[--dec] = bb;
unkey[--dec] = cc;
unkey[--dec] = aa;


aa = key[asc++];
bb = key[asc++];
unkey[--dec] = bb;
unkey[--dec] = aa;
aa = fun_a(key[asc++]);
bb = fun_b(key[asc++]);
cc = fun_b(key[asc++]);
dd = fun_a(key[asc]);
unkey[--dec] = dd;
unkey[--dec] = cc;
unkey[--dec] = bb;
unkey[--dec] = aa;

return unkey;


private int[] get_subkey(boolean flag, byte[] bytekey)
if (flag)
return encrypt_subkey(bytekey);
else
return uncrypt_subkey(encrypt_subkey(bytekey));



private byte[] ByteDataFormat(byte[] data, int unit)
int len = data.length;
int padlen = unit - (len % unit);
int newlen = len + padlen;
byte[] newdata = new byte[newlen];
System.arraycopy(data, 0, newdata, 0, len);

for (int i = len; i < newlen; i++)
newdata[i] = (byte) padlen;

return newdata;


public byte[] IdeaEncrypt(byte[] idea_key, byte[] idea_data, boolean flag)
byte[] format_key = ByteDataFormat(idea_key, 16);
byte[] format_data = ByteDataFormat(idea_data, 8);

int datalen = format_data.length;
int unitcount = datalen / 8;
byte[] result_data = new byte[datalen];

for (int i = 0; i < unitcount; i++)
byte[] tmpkey = new byte[16];
byte[] tmpdata = new byte[8];
System.arraycopy(format_key, 0, tmpkey, 0, 16);
System.arraycopy(format_data, i * 8, tmpdata, 0, 8);

byte[] tmpresult = Encrypt(tmpkey, tmpdata, flag);
System.arraycopy(tmpresult, 0, result_data, i * 8, 8);


return result_data;


/**
* 二行制转字符串
* @param b
* @return
*/
public static String byte2hex(byte[] b) //一个字节的数，
// 转成16进制字符串
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(); //转成大写


public static byte[] hex2byte(byte[] b)
if((b.length%2)!=0)
throw new IllegalArgumentException("长度不是偶数");
byte[] b2 = new byte[b.length/2];
for (int n = 0; n < b.length; n+=2)
String item = new String(b,n,2);
// 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个进制字节
b2[n/2] = (byte)Integer.parseInt(item,16);


return b2;


public static void main(String[] args)

IDEA idea = new IDEA();

idea.getKey("aadd");//生成密匙

String strEnc = idea.getEncString("1234567890");//加密字符串,返回String的密文
System.out.println(strEnc);

String strDes = idea.getDesString(strEnc);//把String 类型的密文解密
System.out.println(strDes);

// String key = "0000000000000000";
// String data = "11111111冯";
// byte[] bytekey = key.getBytes();
// byte[] bytedata = data.getBytes();
//
// IDEA idea = new IDEA();
// byte[] encryptdata = idea.IdeaEncrypt(bytekey, bytedata, true);
// byte[] decryptdata = idea.IdeaEncrypt(bytekey, encryptdata, false);
//
// System.out.println("--------------------------------");
//
// for (int i = 0; i < bytedata.length; i++)
// System.out.print(" " + bytedata[i] + " ");
//
//
// System.out.println("");
//
// for (int i = 0; i < encryptdata.length; i++)
// System.out.print(" " + encryptdata[i] + " ");
//
//
// System.out.println("");
//
// for (int i = 0; i < decryptdata.length; i++)
// System.out.print(" " + decryptdata[i] + " ");
//

参考资料：http://www.sfcode.cn/soft/019873433.htm

本回答被提问者采纳

Java 对称加密算法DES 的使用教程

前面一篇我写了对称加密算法IDEA的使用教程《Java 对称加密算法IDEA 的使用教程》。今天我们来学习另外一个对称加密算法DES。DES算法使用相对广泛一些，一些老的项目中可能会遇到。

对称密码体制是指如果一个加密系统的加密密钥和解密密钥相同，或者虽然不同，但是由其中的任意一个可以很容易地推导出另一个，即密钥是双方共享的。

对    对称密码算法DES 图解

DES算法具有极高安全性，到目前为止，除了用穷举搜索法对DES算法进行攻击外，还没有发现更有效的办法。而56位长的密钥的穷举空间为256，这意味着如果一台计算机的速度是每一秒种检测一百万个密钥，则它搜索完全部密钥就需要将近2285年的时间，可见，这是难以实现的，当然，随着科学技术的发展，当出现超高速计算机后，我们可考虑把DES密钥的长度再增长一些，以此来达到更高的保密程度。

关于DES算法的原理，大家可以查看这篇文章《DES算法原理》。  

       DES算法 的 java 实例

       3DES算法 的 java 实例

看起来都比较简单，适合大家快速入门，马上上手使用。