AES算法，DES算法，RSA算法JAVA实现

Posted 2020-09-29

1     AES算法

1.1    算法描述

1.1.1      设计思想

Rijndael密码的设计力求满足以下3条标准：

① 抵抗所有已知的攻击。

② 在多个平台上速度快，编码紧凑。

③ 设计简单。

当前的大多数分组密码，其轮函数是Feistel结构。

Rijndael没有这种结构。

Rijndael轮函数是由3个不同的可逆均匀变换

1.1.2      密码说明

严格地说，AES和Rijndael加密法并不完全一样（虽然在实际应用中二者可以互换），因为Rijndael加密法可以支持更大范围的区块和密钥长度：AES的区块长度固定为128 比特，密钥长度则可以是128，192或256比特；而Rijndael使用的密钥和区块长度可以是32位的整数倍，以128位为下限，256比特为上限。加密过程中使用的密钥是由Rijndael密钥生成方案产生。

大多数AES计算是在一个特别的有限域完成的。

AES加密过程是在一个4×4的字节矩阵上运作，这个矩阵又称为“状态（state）”，其初值就是一个明文区块（矩阵中一个元素大小就是明文区块中的一个Byte）。（Rijndael加密法因支持更大的区块，其矩阵行数可视情况增加）加密时，各轮AES加密循环（除最后一轮外）均包含4个步骤：

1. AddRoundKey — 矩阵中的每一个字节都与该次轮秘钥（round key）做XOR运算；每个子密钥由密钥生成方案产生。

2. SubBytes — 通过非线性的替换函数，用查找表的方式把每个字节替换成对应的字节。

3. ShiftRows — 将矩阵中的每个横列进行循环式移位。

4. MixColumns — 为了充分混合矩阵中各个直行的操作。这个步骤使用线性转换来混合每列的四个字节。

5. 最后一个加密循环中省略MixColumns步骤，而以另一个AddRoundKey取代。

1.1.3      加密标准

对称密码体制的发展趋势将以分组密码为重点。分组密码算法通常由密钥扩展算法和加密（解密）算法两部分组成。密钥扩展算法将b字节用户主密钥扩展成r个子密钥。加密算法由一个密码学上的弱函数f与r个子密钥迭代r次组成。混乱和密钥扩散是分组密码算法设计的基本原则。抵御已知明文的差分和线性攻击，可变长密钥和分组是该体制的设计要点。

AES是美国国家标准技术研究所NIST旨在取代DES的21世纪的加密标准。

AES的基本要求是，采用对称分组密码体制，密钥的长度最少支持为128、192、256，分组长度128位，算法应易于各种硬件和软件实现。1998年NIST开始AES第一轮分析、测试和征集，共产生了15个候选算法。1999年3月完成了第二轮AES2的分析、测试。2000年10月2日美国政府正式宣布选中比利时密码学家Joan Daemen 和 Vincent Rijmen 提出的一种密码算法RIJNDAEL 作为 AES.

在应用方面，尽管DES在安全上是脆弱的，但由于快速DES芯片的大量生产，使得DES仍能暂时继续使用，为提高安全强度，通常使用独立密钥的三级DES。但是DES迟早要被AES代替。流密码体制较之分组密码在理论上成熟且安全，但未被列入下一代加密标准。

AES加密数据块分组长度必须为128比特，密钥长度可以是128比特、192比特、256比特中的任意一个（如果数据块及密钥长度不足时，会补齐）。AES加密有很多轮的重复和变换。大致步骤如下：1、密钥扩展（KeyExpansion），2、初始轮（Initial Round），3、重复轮（Rounds），每一轮又包括：SubBytes、ShiftRows、MixColumns、AddRoundKey，4、最终轮（Final Round），最终轮没有MixColumns。

1.2    算法实现

1.2.1      算法实现代码（java）

import java.io.*;

import java.security.*;

import java.util.Scanner;

import javax.crypto.*;

import javax.crypto.spec.SecretKeySpec;

 

public class aes {

         //加密

         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; // 加密 

        } catch (NoSuchAlgorithmException e) { 

                e.printStackTrace(); 

        } catch (NoSuchPaddingException e) { 

                e.printStackTrace(); 

        } catch (InvalidKeyException e) { 

                e.printStackTrace(); 

        } catch (UnsupportedEncodingException e) { 

                e.printStackTrace(); 

        } catch (IllegalBlockSizeException e) { 

                e.printStackTrace(); 

        } catch (BadPaddingException e) { 

                e.printStackTrace(); 

        } 

        return null; 

} 

         //解密

         public static byte[] decrypt(byte[] 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");// 创建密码器 

                cipher.init(Cipher.DECRYPT_MODE, key);// 初始化 

                byte[] result = cipher.doFinal(content); 

                return result; // 加密 

        } catch (NoSuchAlgorithmException e) { 

                e.printStackTrace(); 

        } catch (NoSuchPaddingException e) { 

                e.printStackTrace(); 

        } catch (InvalidKeyException e) { 

                e.printStackTrace(); 

        } catch (IllegalBlockSizeException e) { 

                e.printStackTrace(); 

        } catch (BadPaddingException e) { 

                e.printStackTrace(); 

        } 

        return null; 

} 

//主函数

         public static void main(String[] args) {

                   Scanner scan = new Scanner(System.in); 

        System.out.println("请输入一个字符串:"); 

        String s=scan.next();

        System.out.println("你输入的是:"+s);

                   String password = "12345678"; 

                   //加密 

                   System.out.println("加密前：" + s); 

                   byte[] encryptResult = encrypt(s, password); 

                   //解密 

                   byte[] decryptResult = decrypt(encryptResult,password); 

                   System.out.println("解密后：" + new String(decryptResult));

 

         }

 

}

2     DES算法

2.1    算法描述

2.1.1      基本原则

DES设计中使用了分组密码设计的两个原则：混淆（confusion）和扩散(diffusion)，其目的是抗击敌手对密码系统的统计分析。混淆是使密文的统计特性与密钥的取值之间的关系尽可能复杂化，以使密钥和明文以及密文之间的依赖性对密码分析者来说是无法利用的。扩散的作用就是将每一位明文的影响尽可能迅速地作用到较多的输出密文位中，以便在大量的密文中消除明文的统计结构，并且使每一位密钥的影响尽可能迅速地扩展到较多的密文位中，以防对密钥进行逐段破译。

2.1.2      算法步骤

DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位（实际用到了56位，第8、

DES算法流程

16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1），其算法主要分为两步：

1）初始置换

其功能是把输入的64位数据块按位重新组合，并把输出分为L0、R0两部分，每部分各长32位，其置换规则为将输入的第58位换到第一位,第50位换到第2位……依此类推,最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位，R0是右32位,例:设置换前的输入值为D1D2D3……D64,则经过初始置换后的结果为:L0=D58D50……D8;R0=D57D49……D7。

其置换规则见下表：

58,50,42,34,26,18,10,2,

60,52,44,36,28,20,12,4,

62,54,46,38,30,22,14,6,

64,56,48,40,32,24,16,8,

57,49,41,33,25,17,9,1,

59,51,43,35,27,19,11,3,

61,53,45,37,29,21,13,5,

63,55,47,39,31,23,15,7,

2）逆置换

经过16次迭代运算后,得到L16、R16,将此作为输入，进行逆置换，逆置换正好是初始置换的逆运算，由此即得到密文输出。

此算法是对称加密算法体系中的代表,在计算机网络系统中广泛使用。

2.2    算法实现

2.2.1      算法实现代码（java）

import java.security.*;

import java.util.Scanner;

import javax.crypto.*;

import javax.crypto.spec.DESKeySpec;

 

public class des {

         public des() {

         }

         //测试主函数

         public static void main(String args[]) {

    Scanner scan = new Scanner(System.in); 

    System.out.println("请输入一个字符串:"); 

    String s=scan.next();

    System.out.println("你输入的是:"+s);

         String password = "9588028820109132";

 

         byte[] result = des.encrypt(s.getBytes(),password);

         System.out.println("加密后："+new String(result));

         try {

         byte[] decryResult = des.decrypt(result, password);

         System.out.println("解密后："+new String(decryResult));

         } catch (Exception e1) {

         e1.printStackTrace();

         }

 

         }

         //加密

         public static byte[] encrypt(byte[] datasource, String password) {

         try{

         SecureRandom random = new SecureRandom();

         DESKeySpec desKey = new DESKeySpec(password.getBytes());

         //创建一个密匙工厂，然后用它把DESKeySpec转换成

         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");

         SecretKey securekey = keyFactory.generateSecret(desKey);

         //Cipher对象实际完成加密操作

         Cipher cipher = Cipher.getInstance("DES");

         //用密匙初始化Cipher对象

         cipher.init(Cipher.ENCRYPT_MODE, securekey, random);

         //现在，获取数据并加密

         //正式执行加密操作

         return cipher.doFinal(datasource);

         }catch(Throwable e){

         e.printStackTrace();

         }

         return null;

         }

 

  //解密

   public static byte[] decrypt(byte[] src, String password) throws Exception {

         // DES算法要求有一个可信任的随机数源

         SecureRandom random = new SecureRandom();

         // 创建一个DESKeySpec对象

         DESKeySpec desKey = new DESKeySpec(password.getBytes());

         // 创建一个密匙工厂

         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");

         // 将DESKeySpec对象转换成SecretKey对象

         SecretKey securekey = keyFactory.generateSecret(desKey);

         // Cipher对象实际完成解密操作

         Cipher cipher = Cipher.getInstance("DES");

         // 用密匙初始化Cipher对象

         cipher.init(Cipher.DECRYPT_MODE, securekey, random);

         // 真正开始解密操作

         return cipher.doFinal(src);

         }

}

 

3   RSA算法

3.1    算法描述

3.1.1      实现细节

密钥生成

首先要使用概率算法来验证随机产生的大的整数是否质数，这样的算法比较快而且可以消除掉大多数非质数。假如有一个数通过了这个测试的话，那么要使用一个精确的测试来保证它的确是一个质数。

除此之外这样找到的p和q还要满足一定的要求，首先它们不能太靠近，此外p-1或q-1的因子不能太小，否则的话N也可以被很快地分解。

此外寻找质数的算法不能给攻击者任何信息，这些质数是怎样找到的，尤其产生随机数的软件必须非常好。要求是随机和不可预测。这两个要求并不相同。一个随机过程可能可以产生一个不相关的数的系列，但假如有人能够预测出（或部分地预测出）这个系列的话，那么它就已经不可靠了。比如有一些非常好的随机数算法，但它们都已经被发表，因此它们不能被使用，因为假如一个攻击者可以猜出p和q一半的位的话，那么他们就已经可以轻而易举地推算出另一半。

此外密钥d必须足够大，1990年有人证明假如p大于q而小于2q（这是一个很经常的情况）而，那么从N和e可以很有效地推算出d。此外e = 2永远不应该被使用。

运算速度

由于进行的都是大数计算，使得RSA最快的情况也比DES慢上好几倍，无论是软件还是硬件实现。速度一直是RSA的缺陷。一般来说只用于少量数据加密。RSA的速度比对应同样安全级别的对称密码算法要慢1000倍左右。

比起DES和其它对称算法来说，RSA要慢得多。实际上Bob一般使用一种对称算法来加密他的信息，然后用RSA来加密他的比较短的对称密码，然后将用RSA加密的对称密码和用对称算法加密的消息送给Alice。

这样一来对随机数的要求就更高了，尤其对产生对称密码的要求非常高，因为否则的话可以越过RSA来直接攻击对称密码。

密钥分配

和其它加密过程一样，对RSA来说分配公钥的过程是非常重要的。分配公钥的过程必须能够抵挡一个从中取代的攻击。假设Eve交给Bob一个公钥，并使Bob相信这是Alice的公钥，并且她可以截下Alice和Bob之间的信息传递，那么她可以将她自己的公钥传给Bob，Bob以为这是Alice的公钥。Eve可以将所有Bob传递给Alice的消息截下来，将这个消息用她自己的密钥解密，读这个消息，然后将这个消息再用Alice的公钥加密后传给Alice。理论上Alice和Bob都不会发现Eve在偷听他们的消息。今天人们一般用数字认证来防止这样的攻击。

时间攻击

1995年有人提出了一种非常意想不到的攻击方式：假如Eve对Alice的硬件有充分的了解，而且知道它对一些特定的消息加密时所需要的时间的话，那么她可以很快地推导出d。这种攻击方式之所以会成立，主要是因为在进行加密时所进行的模指数运算是一个位元一个位元进行的而位元为1所花的运算比位元为0的运算要多很多，因此若能得到多组讯息与其加密时间，就会有机会可以反推出私钥的内容。

3.1.2      安全性

RSA的安全性依赖于大数分解，但是否等同于大数分解一直未能得到理论上的证明，因为没有证明破解RSA就一定需要作大数分解。假设存在一种无须分解大数的算法，那它肯定可以修改成为大数分解算法。 RSA 的一些变种算法已被证明等价于大数分解。不管怎样，分解n是最显然的攻击方法。人们已能分解多个十进制位的大素数。因此，模数n必须选大一些，因具体适用情况而定。

3.2    算法实现

3.2.1      算法实现代码（java）

import java.security.*; 

import java.security.interfaces.*; 

import java.io.*; 

import java.math.*;

import java.util.Scanner;

public class rsa { 

        public rsa() { 

        } 

        public static void generateKey() { 

            try { 

                KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); 

                kpg.initialize(1024); 

                KeyPair kp = kpg.genKeyPair(); 

                PublicKey pbkey = kp.getPublic(); 

                PrivateKey prkey = kp.getPrivate(); 

                // 保存公钥 

                FileOutputStream f1 = new FileOutputStream("pubkey.dat"); 

                ObjectOutputStream b1 = new ObjectOutputStream(f1); 

                b1.writeObject(pbkey); 

                // 保存私钥 

                FileOutputStream f2 = new FileOutputStream("privatekey.dat"); 

                ObjectOutputStream b2 = new ObjectOutputStream(f2); 

                b2.writeObject(prkey); 

            } catch (Exception e) { 

            } 

        } 

        public static void encrypt() throws Exception { 

           

            Scanner scan = new Scanner(System.in); 

            System.out.println("请输入一个字符串:"); 

            //System.out.println("您输入的字符串是:" + scan.next());

            String s=scan.next();

            System.out.println("你输入的是:"+s);

            // 获取公钥及参数e,n 

            FileInputStream f = new FileInputStream("pubkey.dat"); 

            ObjectInputStream b = new ObjectInputStream(f); 

            RSAPublicKey pbk = (RSAPublicKey) b.readObject(); 

            BigInteger e = pbk.getPublicExponent(); 

            BigInteger n = pbk.getModulus(); 

            System.out.println("e= " + e); 

            System.out.println("n= " + n); 

            // 获取明文m 

            byte ptext[] = s.getBytes("UTF-8"); 

            BigInteger m = new BigInteger(ptext); 

            // 计算密文c 

            BigInteger c = m.modPow(e, n); 

            System.out.println("c= " + c); 

            // 保存密文 

            String cs = c.toString(); 

            BufferedWriter out = 

                new BufferedWriter( 

                    new OutputStreamWriter(new FileOutputStream("encrypt.dat"))); 

            out.write(cs, 0, cs.length()); 

            out.close(); 

        } 

        public static void decrypt() throws Exception { 

            // 读取密文 

            BufferedReader in = 

                new BufferedReader( 

                    new InputStreamReader(new FileInputStream("encrypt.dat"))); 

            String ctext = in.readLine(); 

            BigInteger c = new BigInteger(ctext); 

            // 读取私钥 

            FileInputStream f = new FileInputStream("privatekey.dat"); 

            ObjectInputStream b = new ObjectInputStream(f); 

            RSAPrivateKey prk = (RSAPrivateKey) b.readObject(); 

            BigInteger d = prk.getPrivateExponent(); 

            // 获取私钥参数及解密 

            BigInteger n = prk.getModulus(); 

            System.out.println("d= " + d); 

            System.out.println("n= " + n); 

            BigInteger m = c.modPow(d, n); 

            // 显示解密结果 

            System.out.println("m= " + m); 

            byte[] mt = m.toByteArray(); 

            System.out.println("解密出来的文本是："); 

            for (int i = 0; i < mt.length; i++) { 

                System.out.print((char) mt[i]); 

            } 

        } 

        public static void main(String args[]) { 

            try { 

                generateKey(); 

                encrypt(); 

                decrypt(); 

            } catch (Exception e) { 

                System.out.println(e.toString()); 

            } 

        } 

    }