AES加密解密算法(Java版本)
实现功能：
已知明文为0123456789ABCDEF的ASCII码表示的128比特
* 密钥是0101101100001110的12次重复构成的192比特密钥
* 编写AES的加解密程序，对明文进行加密，并进行解密验证
1.程序结构
2.运行结果
3.源代码
<1>.AESclass类：
public class AESclass {
private byte[][] sbox={
{99,124,119,123,-14,107,111,-59,48,1,103,43,-2,-41,-85,118},
{-54,-126,-55,125,-6,89,71,-16,-83,-44,-94,-81,-100,-92,114,-64},
{-73,-3,-109,38,54,63,-9,-52,52,-91,-27,-15,113,-40,49,21},
{4,-57,35,-61,24,-106,5,-102,7,18,-128,-30,-21,39,-78,117},
{9,-125,44,26,27,110,90,-96,82,59,-42,-77,41,-29,47,-124},
{83,-47,0,-19,32,-4,-79,91,106,-53,-66,57,74,76,88,-49},
{-48,-17,-86,-5,67,77,51,-123,69,-7,2,127,80,60,-97,-88},
{81,-93,64,-113,-110,-99,56,-11,-68,-74,-38,33,16,-1,-13,-46},
{-51,12,19,-20,95,-105,68,23,-60,-89,126,61,100,93,25,115},
{96,-127,79,-36,34,42,-112,-120,70,-18,-72,20,-34,94,11,-37},
{-32,50,58,10,73,6,36,92,-62,-45,-84,98,-111,-107,-28,121},
{-25,-56,55,109,-115,-43,78,-87,108,86,-12,-22,101,122,-82,8},
{-70,120,37,46,28,-90,-76,-58,-24,-35,116,31,75,-67,-117,-118},
{112,62,-75,102,72,3,-10,14,97,53,87,-71,-122,-63,29,-98},
{-31,-8,-104,17,105,-39,-114,-108,-101,30,-121,-23,-50,85,40,-33},
{-116,-95,-119,13,-65,-26,66,104,65,-103,45,15,-80,84,-69,22}, };
private byte[][] rsbox={
{82,9,106,-43,48,54,-91,56,-65,64,-93,-98,-127,-13,-41,-5},
{124,-29,57,-126,-101,47,-1,-121,52,-114,67,68,-60,-34,-23,-53},
{84,123,-108,50,-90,-62,35,61,-18,76,-107,11,66,-6,-61,78},
{8,46,-95,102,40,-39,36,-78,118,91,-94,73,109,-117,-47,37},
{114,-8,-10,100,-122,104,-104,22,-44,-92,92,-52,93,101,-74,-110},
{108,112,72,80,-3,-19,-71,-38,94,21,70,87,-89,-115,-99,-124},
{-112,-40,-85,0,-116,-68,-45,10,-9,-28,88,5,-72,-77,69,6},
{-48,44,30,-113,-54,63,15,2,-63,-81,-67,3,1,19,-118,107},
{58,-111,17,65,79,103,-36,-22,-105,-14,-49,-50,-16,-76,-26,115},
{-106,-84,116,34,-25,-83,53,-123,-30,-7,55,-24,28,117,-33,110},
{71,-15,26,113,29,41,-59,-119,111,-73,98,14,-86,24,-66,27},
{-4,86,62,75,-58,-46,121,32,-102,-37,-64,-2,120,-51,90,-12},
{31,-35,-88,51,-120,7,-57,49,-79,18,16,89,39,-128,-20,95},
{96,81,127,-87,25,-75,74,13,45,-27,122,-97,-109,-55,-100,-17},
{-96,-32,59,77,-82,42,-11,-80,-56,-21,-69,60,-125,83,-103,97},
{23,43,4,126,-70,119,-42,38,-31,105,20,99,85,33,12,125}
};
private byte[][] mut={
{2,3,1,1},
{1,2,3,1},
{1,1,2,3},
{3,1,1,2}
};
private byte[][] rmut={
{14,11,13,9},
{9,14,11,13},
{13,9,14,11},
{11,13,9,14}
};
private byte[] by={1,2,4,8,16,
32,64,-128,27,54,
108,-40,-85,77,-102,};
private int[] r={0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36,0x17,0x15};
byte[][][] allkey=new byte[13][4][4];
byte[] enbyte=new byte[16];
byte[] debyte=new byte[16];
//字节替代，
public byte[][] subbyte(byte[][] sub){
byte row,col;
byte[][] temp=new byte[4][4];
for(int i=0;i<4;i++)
for(int j=0;j<4;j++){
col=(byte)(sub[i][j]&0xf);
row=(byte)((sub[i][j]>>4)&0xf);
temp[i][j]=sbox[row][col];
}
return temp;
}
public byte[][] subbyte(byte[][] sub,int r){
byte row,col;
byte[][] temp=new byte[4][4];
for(int i=0;i<4;i++)
for(int j=0;j<4;j++){
col=(byte)(sub[i][j]&0xf);
row=(byte)((sub[i][j]>>4)&0xf);
temp[i][j]=rsbox[row][col];
}
return temp;
}
//行移位
public byte[][] shift(byte[][] sub){
byte temp;
temp=sub[1][0];
sub[1][0]=sub[1][1];sub[1][1]=sub[1][2];sub[1][2]=sub[1][3];sub[1][3]=temp;
temp=sub[2][0];
sub[2][0]=sub[2][2];sub[2][2]=temp;
temp=sub[2][1];
sub[2][1]=sub[2][3];sub[2][3]=temp;
temp=sub[3][0];
sub[3][0]=sub[3][3];sub[3][3]=sub[3][2];sub[3][2]=sub[3][1];sub[3][1]=temp;
return sub;
}
public byte[][] shift(byte[][] sub,int mode){
byte temp;
temp=sub[3][0];
sub[3][0]=sub[3][1];sub[3][1]=sub[3][2];sub[3][2]=sub[3][3];sub[3][3]=temp;
temp=sub[2][0];
sub[2][0]=sub[2][2];sub[2][2]=temp;
temp=sub[2][1];
sub[2][1]=sub[2][3];sub[2][3]=temp;
temp=sub[1][0];
sub[1][0]=sub[1][3];sub[1][3]=sub[1][2];sub[1][2]=sub[1][1];sub[1][1]=temp;
return sub;
}
//列混合
public byte[][] mix(byte[][] sub){
byte count=0;
byte[][] temp=new byte[4][4];
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
while(count<4){
temp[i][j]=(byte)(temp[i][j]^mu(mut[i][count],sub[count][j]));
count++;
}
count=0;
}
}
return temp;
}
public byte[][] mix(byte[][] sub,int mode){
byte count=0;
byte[][] temp=new byte[4][4];
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
while(count<4){
temp[i][j]=(byte)(temp[i][j]^mu(rmut[i][count],sub[count][j]));
count++;
}
count=0;
}
}
return temp;
}
//轮密钥加
public byte[][] add(byte sub[][],byte[][] roundkey){
for(int i=0;i<4;i++)
for(int j=0;j<4;j++){
sub[i][j]=(byte)(sub[i][j]^roundkey[i][j]);
}
return sub;
}
//列混合中所用函数
public byte mu(byte b,byte c){
byte ret=0 ,count1=0,count2=0;
byte[] barray=new byte[8];
byte[] carray=new byte[8];
byte[] pro=new byte[15];
if(b==1|c==0)return c;
if(c==1)return b;
for(int i=0;i<8&&b!=0;i++){
barray[i]=(byte)(b&1);
b=(byte)(b>>1);
count1++;
}
for(int i=0;i<8&&c!=0;i++){
carray[i]=(byte)(c&1);
c=(byte)(c>>1);
count2++;
}
for(int i=0;i for(int j=0;j if(barray[i]>0&carray[j]>0) pro[i+j]=(byte)((pro[i+j]+1)%2); } for(int m=0;m if(pro[m]>0) ret=(byte)((by[m])^(ret)); } return ret; } //密钥扩展 public byte[][][] key(byte[][] okey){ byte[][][] retarray=new byte[13][4][4]; for(int i=0;i<4;i++) for(int j=0;j<4;j++){ retarray[0][j][i]=okey[i][j]; } for(int i=1;i<13;i++){ retarray[i]=tkey(retarray[i-1],r[i]); } return retarray; } //密钥扩展中所用函数 public byte[][] tkey(byte[][] okey,int ri){ byte[][] temp=new byte[4][4]; byte col,row; col=(byte)(okey[1][3]&0xf); row=(byte)((okey[1][3]>>4)&0xf); temp[0][0]=(byte)(ri^sbox[row][col]^okey[0][0]); col=(byte)(okey[2][3]&0xf); row=(byte)((okey[2][3]>>4)&0xf); temp[1][0]=(byte)(sbox[row][col]^okey[1][0]); col=(byte)(okey[3][3]&0xf); row=(byte)((okey[3][3]>>4)&0xf); temp[2][0]=(byte)(sbox[row][col]^okey[2][0]); col=(byte)(okey[0][3]&0xf); row=(byte)((okey[0][3]>>4)&0xf); temp[3][0]=(byte)(sbox[row][col]^okey[3][0]); for(int i=1;i<4;i++){ temp[0][i]=(byte)(temp[0][i-1]^okey[0][i]); temp[1][i]=(byte)(temp[1][i-1]^okey[1][i]); temp[2][i]=(byte)(temp[2][i-1]^okey[2][i]); temp[3][i]=(byte)(temp[3][i-1]^okey[3][i]); } return temp; } } <2>.EnDecrypt类： public class EnDecrypt extends AESclass { /** * AES加密算法 * 加密 * @param content 需要加密的内容 * @param keyWord 加密密钥 * @return byte[] 加密后的字节数组 */ public String strEncrypt (String content,byte[][] key) { allkey=key(key); enbyte = content.getBytes(); en(); String ciphertext = parseByte2HexStr(debyte); return ciphertext; } public void en(){ byte[][] temp=new byte[4][4]; for(int i=0;i<4;i++) for(int j=0;j<4;j++) temp[i][j]=enbyte[j*4+i]; temp=add(temp, allkey[0]); for(int i=1;i<12;i++) temp=this.add(mix(shift(subbyte(temp))),allkey[i]); temp=this.add(this.shift(this.subbyte(temp)), allkey[12]); for(int i=0;i<4;i++) for(int j=0;j<4;j++) debyte[i*4+j]=temp[j][i]; } /**解密 * @param content 待解密内容 * @param keyWord 解密密钥 * @return byte[] */ public String strDecrypt (String content,byte[][] key) { allkey = key(key); debyte = parseHexStr2Byte(content); de(); String text =new String(enbyte); return text; } public void de(){ byte[][] temp=new byte[4][4]; for(int i=0;i<4;i++) for(int j=0;j<4;j++) temp[i][j]=debyte[j*4+i]; temp=add(temp,allkey[12]); for(int i=1;i<12;i++) temp=mix(add(subbyte(shift(temp,-1),-1),allkey[12-i]),-1); temp=add(subbyte(shift(temp, -1), -1), allkey[0]); for(int i=0;i<4;i++) for(int j=0;j<4;j++) enbyte[i*4+j]=temp[j][i]; } /**将byte转换成16进制 * @param buf * @return String */ public static String parseByte2HexStr(byte buf[]) { StringBuffer sb = new StringBuffer(); for (int i = 0; i < buf.length; i++) { String hex = Integer.toHexString(buf[i] & 0xFF); if (hex.length() == 1) { hex = '0' + hex; } sb.append(hex.toUpperCase()); } return sb.toString(); } /**将16进制转换为byte * @param hexStr * @return byte[] */ public static byte[] parseHexStr2Byte(String hexStr) { int index=hexStr.length()/2; //文本十六进制转换为文件流 byte[] b=new byte[index]; for(int i=0;i b[i]=(byte)Integer.parseInt(hexStr.substring(i*2,i*2+2),16); } return b; } } <3>.MyAESProgram类： /** * @ author yan * 已知明文为0123456789ABCDEF的ASCII码表示的128比特 * 密钥是0101101100001110的12次重复构成的192比特密钥 * 编写AES的加解密程序，对明文进行加密，并进行解密验证 */ public class MyAESProgram /* * 主类 */ { public static void main(String[] args) {//生成192bit密钥 byte[][] key = new byte[4][6]; byte[] bt = new byte[24]; for(int i=0;i<12;i++) { bt[2*i] = 91; bt[2*i+1] = 14; } int k = 0; for(int i=0;i<4;i++) { for(int j=0;j<6;j++) { key[i][j] = bt[k]; k++; } } String originalText = "0123456789ABCDEF"; EnDecrypt crypt = new EnDecrypt(); String cipherText=crypt.strEncrypt(originalText,key); String decryptText = crypt.strDecrypt(cipherText,key); System.out.println("originalText: "+originalText); System.out.println("cipherText: "+cipherText); System.out.println("decryptText: "+decryptText); } } JAVA课程设计题目：文件的加密与解密 姓名： 学号： 班级: 日期： 目录 一、设计思路 (3) 二、具体实现 (3) 三、运行调试与分析讨论 (8) 四、设计体会与小结 (11) 五、参考文献 (12) 六、附录 (12) 一、设计思路 自从Java技术出现以业，有关Java平台的安全性用由Java技术发展所引发的安全性问题，引起了越来越多的关注。目前，Java已经大量应用于各个领域，研究Java的安全性对于更好地利用Java具有深远的意义。使用Java的安全机制设计和实现安全系统更具有重要的应用价值。 本课程设计，主要实践Java安全中的JCE模块，包括密钥生成，Cipher对象初始化、加密模式、填充模式、底层算法参数传递，也涉及文件读写与对象输入输出流。 二、具体实现 本系统通过用户界面接收三个参数：明文文件、密文文件、口令。采用DES加密算法，密码分组链（Cipher Block Chaining，CBC）加密模式，PKCS#5-Padding的分组填充算法。因为CBC涉及到底层算法参数的解密密钥的传递，所以将明文文件中的字节块以密封对象（Sealed Object）的方式加密后，用对象流输出到密文文件，这样就将密文、算法参数、解密密钥三都密封到一个对象中了。口令的hash值作为产生密钥的参数。设计流程图如下所示： 文件加密与解密设计流程图 本系统中，包含Default,Shares,SecretKey,EncAndDec四个包共6个类组成。定义的几个参数：MAX_BUF_SIZE为每次从文件中读取的字节数，也是内存缓冲区的大小；加密算法为DES；加密模式是密码分组链（CBC）模式；分组填充方式是PKCS#5Padding。包和类结构图如下所示： 本课程设计，包和类结构图： 以下为包中的类的方法实现说明 Package Shares类结构图 如何运用加密技术保护Java源代码 Java程序的源代码很容易被别人偷看，只要有一个反编译器，任何人都可以分析别人的代码。本文讨论如何在不修改原有程序的情况下，通过加密技术保护源代码。 一、为什么要加密？ 对于传统的C或C++之类的语言来说，要在Web上保护源代码是很容易的，只要不发布它就可以。遗憾的是，Java程序的源代码很容易被别人偷看。只要有一个反编译器，任何人都可以分析别人的代码。Java的灵活性使得源代码很容易被窃取，但与此同时，它也使通过加密保护代码变得相对容易，我们唯一需要了解的就是Java的ClassLoader对象。当然，在加密过程中，有关Java Cryptography Extension（JCE）的知识也是必不可少的。 有几种技术可以“模糊”Java类文件，使得反编译器处理类文件的效果大打折扣。然而，修改反编译器使之能够处理这些经过模糊处理的类文件并不是什么难事，所以不能简单地依赖模糊技术来保证源代码的安全。 我们可以用流行的加密工具加密应用，比如PGP（Pretty Good Privacy）或GPG（GNU Privacy Guard）。这时，最终用户在运行应用之前必须先进行解密。但解密之后，最终用户就有了一份不加密的类文件，这和事先不进行加密没有什么差别。 Java运行时装入字节码的机制隐含地意味着可以对字节码进行修改。JVM每次装入类文件时都需要一个称为ClassLoader的对象，这个对象负责把新的类装入正在运行的JVM。JVM给ClassLoader一个包含了待装入类（比如https://www.360docs.net/doc/875088876.html,ng.Object）名字的字符串，然后由ClassLoader负责找到类文件，装入原始数据，并把它转换成一个Class对象。 我们可以通过定制ClassLoader，在类文件执行之前修改它。这种技术的应用非常广泛??在这里，它的用途是在类文件装入之时进行解密，因此可以看成是一种即时解密器。由于解密后的字节码文件永远不会保存到文件系统，所以窃密者很难得到解密后的代码。 由于把原始字节码转换成Class对象的过程完全由系统负责，所以创建定制ClassLoader对象其实并不困难，只需先获得原始数据，接着就可以进行包含解密在内的任何转换。 Java 2在一定程度上简化了定制ClassLoader的构建。在Java 2中，loadClass的缺省实现仍旧负责处理所有必需的步骤，但为了顾及各种定制的类装入过程，它还调用一个新的findClass方法。 这为我们编写定制的ClassLoader提供了一条捷径，减少了麻烦：只需覆盖findClass，而不是覆盖loadClass。这种方法避免了重复所有装入器必需执行的公共步骤，因为这一切由loadClass负责。 不过，本文的定制ClassLoader并不使用这种方法。原因很简单。如果由默认的ClassLoader先寻找经过加密的类文件，它可以找到；但由于类文件已经加密，所以它不会 package mima; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Scanner; public class Mainer { StringBuffer MStr = new StringBuffer(""); // 加密字符串 StringBuffer CStr = new StringBuffer(""); // 解密字符串 public static void main(String[] args) { System.out.print("请输入密钥："); Scanner s = new Scanner(System.in); int key = s.nextInt() % 26; // %26的意义是获取密钥的偏移值 Mainer ks = new Mainer(); ks.E(key); // 加密 ks.D(key); // 解密 } /** * 加密公式 */ void E(int k) { try { System.out.println("请输入一段明文："); char b[]; BufferedReader br2 = new BufferedReader(new InputStreamReader(System.in)); String str2 = br2.readLine(); b = str2.toCharArray(); char ch = ' '; for (int i = 0; i < str2.length(); i++) { if (b[i] >= 'a' && b[i] <= 'z') { ch = (char) ((b[i] - 'a' + k) % 26 + 'a'); } if(b[i] >= 'A' && b[i] <= 'Z'){ ch = (char) ((b[i] - 'A' + k) % 26 + 'A'); } if(b[i]>='0'&&b[i]<='9') Java 加密解密之对称加密算法DES 本文转自网络 数据加密算法（Data Encryption Algorithm，DEA）是一种对称加密算法，很可能是使用最广泛的密钥系统，特别是在保护金融数据的安全中，最初开发的DEA 是嵌入硬件中的。通常，自动取款机（Automated Teller Machine，ATM）都使用DEA。它出自IBM的研究工作，IBM也曾对它拥有几年的专利权，但是在1983年已到期后，处于公有范围中，允许在特定条件下可以免除专利使用费而使用。1977年被美国政府正式采纳。 1998年后实用化DES破译机的出现彻底宣告DES算法已不具备安全性，1999年NIST颁布新标准，规定DES算法只能用于遗留加密系统，但不限制使用DESede算法。当今DES算法正是推出历史舞台，AES算法称为他的替代者。(详见：Java 加密解密之对称加密算法AES) 加密原理 DES 使用一个56 位的密钥以及附加的8 位奇偶校验位，产生最大64 位的分组大小。这是一个迭代的分组密码，使用称为Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行“异或”运算；接着交换这两半，这一过程会继续下去，但最后一个循环不交换。DES 使用16 个循环，使用异或，置换，代换，移位操作四种基本运算。 JDK对DES算法的支持 密钥长度：56位 工作模式：ECB/CBC/PCBC/CTR/CTS/CFB/CFB8 to CFB128/OFB/OBF8 to OFB128 填充方式：Nopadding/PKCS5Padding/ISO10126Padding/ 工作模式和填充方式请参考：JAVA加密解密基础 十六进制工具类Hex.java，见：java byte数组与十六进制字符串互转 DES加密解密的java实现： DESCoder.java Java代码 import java.security.Key; JA V A实现AES加密算法代码 近些年DES使用越来越少，原因就在于其使用56位密钥，比较容易被破解，近些年来逐渐被AES替代，AES已经变成目前对称加密中最流行算法之一；AES可以使用128、192、和256位密钥，并且用128位分组加密和解密数据。本文就简单介绍如何通过JA VA实现AES加密。 1. JA V A 实现闲话少许，掠过AES加密原理及算法，关于这些直接搜索专业网站吧，我们直接看JA V A的具体实现。 1.1 加密代码有详细解释，不多废话。/*** 加密 ** @param content 需要加密的内容* @param password 加密密码* @return*/public static byte[] encrypt(String content, String password) {try {KeyGenerator kgen = KeyGenerator.getInstance("AES"); kgen.init(128, new SecureRandom(password.getBytes())); SecretKey secretKey = kgen.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器byte[] byteContent = content.getBytes("utf-8"); cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(byteContent);return result; // 加 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Arrays; public class zhihuan { public static void main(String args[]) throws IOException{ System.out.println("请您输入需要的服务，1为加密，2为解密"); BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); int Choice=Integer.parseInt(br.readLine()); if(Choice==1) { System.out.println("您进入了加密程序"); System.out.print("请输入您需要加密的明文："); String MingWen=br.readLine(); System.out.print("请输入加密秘钥："); String key=br.readLine(); jiami(MingWen,key); Choice=2; } if(Choice==2) { System.out.println("您进入了解密程序"); System.out.print("请输入您需要解密的密文："); String MiWen=br.readLine(); System.out.print("请输入解密秘钥："); String key2=br.readLine(); jiemi(MiWen,key2); System.exit(0); } else { System.out.println("输入错误，请重新输入，1为加密，2为解密:\n"); System.exit(0); } } static void jiami(String mingwen,String key) { int hang=(int)Math.ceil((double)mingwen.length()/(double)key.length());//行数 int lie=key.length();//列数 java 加密解密简单实现 加密算法有很多种：这里只大约列举几例： 1:消息摘要：（数字指纹）：既对一个任意长度的一个数据块进行计算，产生一个唯一指纹。MD5/SHA1 发送给其他人你的信息和摘要,其他人用相同的加密方法得到摘要，最后进行比较摘要是否相同。 2:单匙密码体制:DES:比较简便高效,密钥简短，加解密速度快，破译极其困难,但其安全性依赖于密匙的安全性。 DES（Data Encryption Standard）是发明最早的最广泛使用的分组对称加密算法。DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密 3:数字签名:就是信息发送者用其私钥对从所传报文中提取出的特征数据（或称数字指纹）进行RSA算法操作，以保证发信人无法抵赖曾发过该信息（即不可抵赖性），同时也确保信息报文在经签名后末被篡改（即完整性）。当信息接收者收到报文后，就可以用发送者的公钥对数字签名进行验证。 代表：DSA 4:非对称密匙密码体制（公匙体系）：加密密匙不同于解密密匙，加密密匙公之于众，谁都可以使用，解密密匙只有解密人自己知道。代表：RSA 下面是对上面几个例子进行的简单实现： Java代码 1.package test; 2.import java.io.FileInputStream; 3.import java.io.FileOutputStream; 4.import java.io.IOException; 5.import java.io.ObjectInputStream; 6.import java.io.ObjectOutputStream; 7.import java.security.*; 8.import javax.crypto.Cipher; 9.import javax.crypto.KeyGenerator; 10.import javax.crypto.SecretKey; 11./** 12. * 加密解密 13. * 14. * @author shy.qiu 15. * @since https://www.360docs.net/doc/875088876.html,/qiushyfm 一、RSA加密算法的原理 (1)、RSA算法描述 RSA公钥密码体制的基本原理：根据数论，寻求两个大素数比较简单，而将他们的乘积分解开则极为困难。 (2)、RSA算法密钥计算过程： 1.用户秘密选取两个大素数p 和q，计算n=pq，n称为 RSA算法的模数，公开。 2.计算出n的欧拉函数Φ(n) = (p-1)×(q-1)，保密。 3.从(1, Φ(n))中随机地选择一个与Φ(n)互素的数e作为加 密密钥，公开。 4.计算出满足下式的d 作为解密密钥，保密。 ed=1 mod Φ(n) (3)、RSA算法密钥： 加密密钥PK = |e, n| 公开 解密密钥SK = |d, n| 保密 (4)、RSA算法加密解密过程： RSA算法属于分组密码，明文在加密前要进行分组，分组 的值m 要满足：0 < m < n 加密算法：C = E(m) ≡me mod n 解密算法：m = D(c) ≡cd mod n (5)、RSA算法的几点说明： 1．对于RSA算法，相同的明文映射出相同的密文。 2.RSA算法的密钥长度：是指模数n的长度，即n的二进 制位数，而不是e或d的长度。 3.RSA的保密性基于大数进行因式分解很花时间，因此， 进行RSA加密时，应选足够长的密钥。512bit已被证明 不安全，1024bit也不保险。 4.RSA最快情况也比DES慢100倍，仅适合少量数据的加 密。公钥e取较小值的方案不安全。 二．RSA公钥加密算法的编程实现 以下程序是java编写的实现RSA加密及解密的算法 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 javax.crypto.Cipher; //RSATest类即为测试类 public class RSATest { //主函数 public static void main(String[] args) { try { RSATest encrypt = new RSATest(); String encryptText = "encryptText";//输入的明文 KeyPair keyPair = encrypt.generateKey();//调用函数生成密钥对，函数见下 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); byte[] e = encrypt.encrypt(publicKey, encryptText.getBytes()); //调用自己编写的encrypt函数实现加密， byte[] de = encrypt.decrypt(privateKey, e); //调用自己编写的decrypt函数实现解密， System.out.println(toHexString(e)); //输出结果，采用ASSIC码形式 在java中调用sun公司提供的3DES加密解密算法时，需要使用到$JAVA_HOME/jre/lib/目录下如下的4个jar包： jce.jar security/US_export_policy.jar security/local_policy.jar ext/sunjce_provider.jar Java运行时会自动加载这些包，因此对于带main函数的应用程序不需要设置到CLASSPATH环境变量中。对于WEB应用，不需要把这些包加到WEB-INF/lib目录下。 以下是java中调用sun公司提供的3DES加密解密算法的样本代码： 加密解密代码 import java.security.Security; import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; /*字符串 DESede(3DES) 加密*/ public class ThreeDes { /** * @param args在java中调用sun公司提供的3DES加密解密算法时，需要使 * 用到$JAVA_HOME/jre/lib/目录下如下的4个jar包： *jce.jar *security/US_export_policy.jar *security/local_policy.jar *ext/sunjce_provider.jar */ private static final String Algorithm = "DESede"; //定义加密算法,可用 DES,DESede,Blowfish 课程设计(论文)任务书 软件学院软件工程专业班 一、课程设计(论文)题目加密与解密 二、课程设计(论文)工作自年月日起至年月日止。 三、课程设计(论文) 地点: 四、课程设计(论文)内容要求： 1．本课程设计的目的 （1）使学生巩固和提高Java编程技术 （2）培养学生掌握程序设计的基本思路和方法； （3）加强学生研发、调试程序的能力； （4）培养学生分析、解决问题的能力； （5）提高学生的科技论文写作能力。 2．课程设计的任务及要求 1）任务： （1）设计GUI界面的Hannoi塔，用户可以通过拖动鼠标移动各个塔上的盘子，程序 也可以自动演示盘子的移动过程。； （2）有三个表示塔的对象，分别命名为A、B和C。A塔上有若干个盘子，盘子的大小 不等，并按着大小顺序依次摆放在A塔上，大盘在下，小盘在上。用户可以用鼠标拖 动盘子，把A 塔上的盘子全部移动到另外两个塔中的任何一个塔上。要求每次只能移 动一个盘子，在任何时候不允许大盘压在小盘的上面。 （3）用户也可以选择让程序自动演示。选择自动演示后，程序将以动画形式演示把A 塔上的盘子全部移到C塔的过程，并将移动过程以文本形式显示在一个文本区中。 2）创新要求： 在基本要求达到后，可进行创新设计，增加功能和游戏趣味性。 3）课程设计论文编写要求 （1）课程设计任务及要求 （2）需求分析 （3）设计思路--工作原理、功能规划 （4）详细设计---数据分析、算法思路、类设计、功能实现（含程序流程图、主要代码及注释）、界面等。 （4）运行调试与分析讨论---给出运行屏幕截图，分析运行结果，有何改进想法等。（5）设计体会与小结---设计遇到的问题及解决办法，通过设计学到了哪些新知识，巩固了哪些知识，有哪些提高。 （6）参考文献（必须按标准格式列出，可参考教材后面的参考文献格式） (7) 报告按规定排版打印，要求装订平整，否则要求返工； (8) 课设报告的装订顺序如下：封面---任务书---中文摘要---目录----正文---附录(代码 第17卷 第5期2002年10月 内蒙古民族大学学报(自然科学版) Journal of I nner M ongolia U niv ersity for N ationalities Vol.17 No.5 Oct.2002利用Java程序实现加密解密问题y 王国忱1,赵 芳1,李亚娟2 (1 内蒙古民族大学理工学院,内蒙古通辽 028043;2 内蒙古通辽市通顺铝厂,内蒙古通辽 028000) 摘 要:主要介绍了一种用Java语言设计加密解密的方法. 关键词:Java;加密;解密 中图分类号:JP312JA 文献标识码:A 文章编号:1671 0185(2002)05-0410-03 Realize Encryption and Unencryption in Use of Java Program WANG Guo-chen1,ZH AO Fang1,LI Ya-juan2 (1 College o f Science and Eng ineering,Inner M ong olia U niversity for N ationalities,T ongliao028043,China; 2 T ong liao T ong shun A luminium F actory o f Inner M ongo lia,T ongliao028000,China) Abstract:Mainly describe a solution of encryption and unencry ption in use of Java. Key words:Jave;Encryption;U nencryption Java程序是建立在一系列的类之上,这些类刻画了程序所要处理的基本数据类型的行为.通过向这些类的对象发送信息,从而使这些对象进行相应的操作,这样就构成了Jav a程序. 已知一个文本加密解密问题,它遵循如下规则: (1)把明文中的所有字符倒过来,比如Glag to meet you!!变成!uoy teem ot galG!. (2)要求用户提供一个密钥(为一个正整数),设为key.设明文中字符的A SCII码值为x,把x和key相加,再通过一个可逆变换,映射成一个可打印的密文字符,设该字符的ASCII码值为y. 因为ASCI I编码表中,0x00~0x1F(0~31)的字符为设备控制字符,所以在变换过程中必须加以避免. 映射方法分析如下: 设n=(32+key)%128,则可以分成如下规程情况: 第一种情况: n<32,则if(x+key)%128<32 y=96+(x+key)%128; else y=(x+key)%128; 第二种情况: n>32,则if((x+key)%128 public class IDEA { 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);//将64位明文分为四个子块 int b = bytesToInt(inbytes, 2); int c = bytesToInt(inbytes, 4); 课程设计报告书 课程名称面向对象程序设计 设计题目文本文档的加密与解密 2013年 1 月 1 设计时间 2013年1月14日-2013年1月18日 2 设计目的 面向对象程序设计是一门实践性很强的计算机专业基础课程。通过实践加深学生对面向对象程序设计的理论、方法和基础知识的理解，掌握使用Java语言进行面向对象设计的基本方法，提高运用面向对象知识分析实际问题、解决实际问题的能力，提高学生的应用能力。 3 设计任务 对文件进行加密解密 4 设计内容 4.1 需求分析 (1)给定任意一个文本文件，进行加密，生成另一个文件。 (2)对加密后的文件还原。 4.2 总体设计 4.2.1 包的描述 导入了java.awt; java.awt.event; java.io; javax.swing等包。 4.2.2 类的描述 Myframe类；E1类。其中Myframe类继承Frame类；可以扩展Frame的功能并且可以实例化的多种功能，这个类也实现了ActionListener这个接口，它是Java中关于事件处理的一个接口，ActionListener用于接收操作事件的侦听器接口。对处理操作事件感兴趣的类可以实现此接口，而使用该类创建的对象可使用组件的addActionListener 方法向该组件注册。在发生操作事件时，调用该对象的actionPerformed 方法。 4.3 页面设计 图4.3-1 显示页面 代码实现： addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); JAVA加密解密的基本知识 我现在知道比学习还要难得事情是讲课，讲的不足之处请多多包涵！ (一) 我们身边的信息安全问题 ?存储问题 ?通信问题 ?B2B,B2C交易安全问题 ?服务交互问题 ?移动应用服务问题 ?内部人为问题 (二) 计算机信息安全 国际标准化委员会的定义：为数据处理系统和采取的技术的和管理的安全保护，保护计算机硬件、软件、数据不因偶然的或恶意的原因而遭到破坏、更改、显露。 我国公安部计算机管理监察司的定义：计算机安全是指计算机资产安全，即计算机信息系统资源和信息资源不受自然和人为有害因素的威胁和危害。 安全技术目标： (三)TCP/IP安全体系结构 【1】OSI七层和TCP/IP四层 【2】TCP/IP安全体系结构 (四)JavaEE安全控制和密码学 1.密码学与JavaEE ?JavaAPI支持 ?JSP容器支持 ?Java工具支持 2.安全控制策略 ?访问控制 ?数据加密 ?数字证书 3.密码学分类（根据密码体制密码学可以分为密码体制密码学和非对称体制密码学） 【1】对称密码体制 对称密码体制是一种传统密码体制，也称为私钥密码体制。在对称加密系统中，加密和解密采用相同的密钥。因为加解密密钥相同，需要通信的双方必须选择和保存他们共同的密钥，各方必须信任对方不会将密钥泄密出去，这样就可以实现数据的机密性和完整性。比较典型的算法有DES(Data Encryption Standard数据加密标准)算法及其变形Triple DES(三重DES)，GDES(广义DES)；欧洲的IDEA；日本的FEAL N、RC5等。DES标准由美国国家标准局提出,主要应用于银行业的电子资金转帐(EFT)领域。DES的密钥长度为56bit。Triple DES使用两个独立的56bit密钥对交换的信息进行3次加密，从而使其有效长度达到112bit。RC2和RC4方法是RSA数据安全公司的对称加密专利算法，它们采用可变密钥长度的算法。通过规定不同的密钥长度,，C2和RC4能够提高或降低安全的程度。 对称密码算法的优点是计算开销小，算法简单，加密速度快，是目前用于信息加密的主要算法。尽管对称密码术有一些很好的特性，但它也存在着明显的缺陷，包括：l）进行安全通信前需要以安全方式进行密钥交换。这一步骤，在某种情况下是可行的，但在某些情况下会非常困难，甚至无法实现。例如，某一贸易方有几个贸易关系，他就要维护几个专用密钥。它也没法鉴别贸易发起方或贸易最终方，因为贸易的双方的密钥相同。另外，由于对称加密系统仅能用于对数据进行加解密处理，提供数据的机密性，不能用于数字签名。因而人们迫切需要寻找新的密码体制。2)规模复杂。 【2】非对称密码体制 非对称密码体制也叫公钥加密技术，该技术就是针对私钥密码体制的缺陷被提出来的。在公钥加密系统中，加密和解密是相对独立的，加密和解密会使用两把不同的密钥，加密密钥(公开密钥)向公众公开，谁都可以使用，解密密钥(秘密密钥)只有解密人自己知道，非法使用者根据公开的加密密钥无法推算出解密密钥，顾其可称为公钥密码体制。公钥密码体制的算法中最著名的代表是 1.AES加密解密软件界面效果： 2.工程目录： 3.源代码： import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.KeyGenerator; import javax.crypto.NoSuchPaddingException; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import javax.swing.JOptionPane; /** * @author【轰隆隆】 * */ publicclass AES { /** * AES加密算法 */ public AES() { } /** * 加密 * @param content 需要加密的内容 * @param keyWord加密密钥 * @return byte[] 加密后的字节数组 */ publicstaticbyte[] encrypt(byte[] content, String keyWord) { try { KeyGeneratorkgen = KeyGenerator.getInstance("AES"); SecureRandomsecureRandom = SecureRandom.getInstance("SHA1PRNG" ); secureRandom.setSeed(keyWord.getBytes()); kgen.init(128,secureRandom); SecretKeysecretKey = kgen.generateKey(); byte[] enCodeFormat = secretKey.getEncoded(); SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES"); Cipher cipher = Cipher.getInstance("AES");// 创建密码器byte[] byteContent = content; cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化 byte[] result = cipher.doFinal(byteContent); return result; // 加密 } catch (NoSuchPaddingException e) { JOptionPane.showConfirmDialog(null, "密码有误！", "警告！", 1); } catch (InvalidKeyException e) { JOptionPane.showConfirmDialog(null, "密码有误！", "警告！", 1); } catch (IllegalBlockSizeException e) { JOptionPane.showConfirmDialog(null, "密码有误！", "警告！", 1); } catch (BadPaddingException e) { JOptionPane.showConfirmDialog(null, "密码有误！", "警告！", 1); } catch(Exception e) { JOptionPane.showConfirmDialog(null, "密码有误！", "警告！", 1); } returnnull; } /** * @param content 需要加密的内容 * @param password 加密密钥 * @return String 加密后的字符串 */ publicstatic String encrypttoStr(byte[] content, String password){ return parseByte2HexStr(encrypt(content,password)); } /**解密 * @param content 待解密内容 * @param keyWord解密密钥 * @return byte[] */ publicstaticbyte[] decrypt(byte[] content, String keyWord) { try { KeyGeneratorkgen = KeyGenerator.getInstance("AES"); SecureRandomsecureRandom = SecureRandom.getInstance("SHA1PRNG" ); JAVA实现AES加密算法代码 近些年DES使用越来越少，原因就在于其使用56位密钥，比较容易被破解，近些年来逐渐被AES替代，AES已经变成目前对称加密中最流行算法之一；AES可以使用128、192、和256位密钥，并且用128位分组加密和解密数据。本文就简单介绍如何通过JAVA实现AES加密。 1. JAVA 实现闲话少许，掠过AES加密原理及算法，关于这些直接搜索专业吧，我们直接看JAVA的具体实现。 1.1 加密代码有详细解释，不多废话。/** * 加密 * * param content 需要加密的容* param password 加密密码* return */ public static byte[] encrypt(String content, String password) { try { KeyGenerator kgen = KeyGenerator.getInstance("AES"); kgen.init(128, new SecureRandom(password.getBytes())); SecretKey secretKey = kgen.generateKey(); byte[] enCodeFormat = secretKey.getEncoded(); SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES"); Cipher cipher = Cipher.getInstance("AES");// 创建密码器byte[] byteContent = content.getBytes("utf-8"); JAVA加密解密算法DESedeDES，Diffie-Hellman的使用 DESede/DES对称算法 首先生成密钥,并保存(这里并没的保存的代码,可参考DSA 中的方法) KeyGenerator keygen = KeyGenerator.getInstance(Algorithm); SecretKey deskey = keygen.generateKey(); 用密钥加密明文(myinfo),生成密文(cipherByte) Cipher c1 = Cipher.getInstance(Algorithm); c1.init(Cipher.ENCRYPT_MODE,deskey); byte[] cipherByte=c1.doFinal(myinfo.getBytes()); 传送密文和密钥,本文没有相应代码可参考DSA ............. 用密钥解密密文 c1 = Cipher.getInstance(Algorithm); c1.init(Cipher.DECRYPT_MODE,deskey); byte[] clearByte=c1.doFinal(cipherByte); 相对来说对称密钥的使用是很简单的,对于JCE来讲支技DES,DESede,Blowfish三种加密术 对于密钥的保存各传送可使用对象流或者用二进制编码,相关参考代码如下SecretKey deskey = keygen.generateKey(); byte[] desEncode=deskey.getEncoded(); javax.crypto.spec.SecretKeySpec destmp=new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm); SecretKey mydeskey=destmp; 相关API KeyGenerator 在DSA中已经说明,在添加JCE后在instance进可以如下参数 DES,DESede,Blowfish,HmacMD5,HmacSHA1 javax.crypto.Cipher 加/解密器public static final Cipher getInstance(https://www.360docs.net/doc/875088876.html,ng.String transformation) throws java.security.NoSuchAlgorithmException, NoSuchPaddingException 返回一个指定方法的Cipher对象 参数:transformation 方法名(可用DES,DESede,Blowfish) public final void init(int opmode, java.security.Key key) throws java.security.InvalidKeyException 用指定的密钥和模式初始化Cipher对象 参数:opmode 方式(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)文件加密与解密—Java课程设计报告
如何运用加密技术保护Java源代码
网络安全常见的四种加密解密算法
Java 加密解密之对称加密算法DES
JAVA实现AES加密算法代码
JAVA实现古典置换密码的加密解密
java 加密解密简单实现
RSA加密算法java编程实现
Java中3DES加密解密示例
Java课程设计之加密和解密
利用Java程序实现加密解密问题
IDEA加密算法源码(java版)
java文件加密解密课程设计
JAVA加密解密的基本知识
AES加密解密软件 Java编写
JAVA实现AES加密算法代码
java加密解密算法desededesdiffie-hellman的使用