对称加密和非对称加密

Posted 2020-06-14

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了对称加密和非对称加密相关的知识，希望对你有一定的参考价值。

对称加密算法

　　Blowfish 加密解密

Blowfish 加密算法介绍:BlowFish是对称加密算法的其中一种，加密后的数据是可逆的。由于BlowFish加密/解密速度快，更重要的是任何人都可以免费使用不需要缴纳版权费，所以有不少游戏都采用BlowFish加密资源文件数据。BlowFish 每次只能加密和解密8字节数据，加密和解密的过程基本上由ADD和XOR指令运算组成，所以速度非常快。

Blowfish 加密算法实现

 1 /**
 2      * Blowfish加密
 3      * 
 4      * @param text 需要加密的数据
 5      * @param privateKey 加密密钥
 6      * @return
 7      */
 8     public static String f_EnBlowfish(String text, String privateKey)
 9     {
10         byte[] cifrado1 = null;
11         byte[] cifrado2 = null;
12         byte[] mensaje = text.getBytes();
13         try
14         {
15             Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
16             byte[] keys = privateKey.getBytes();
17             SecretKeySpec sk = new SecretKeySpec(keys, "Blowfish");
18             Date inic = new Date();
19             // 加密
20             Cipher c1 = Cipher.getInstance("Blowfish", "BC");
21             c1.init(Cipher.ENCRYPT_MODE, sk);
22             cifrado1 = c1.doFinal(mensaje, 0, mensaje.length);
23         }
24         catch (Exception e)
25         {
26             e.printStackTrace();
27         }
28         return Usual.f_toBase64String(cifrado1);
29     }
30     /**
31      * Blowfish解密
32      * 
33      * @param text 需要解密的数据
34      * @param privateKey 加密密钥
35      * @return
36      */
37     public static String f_DeBlowfish(String enText, String privateKey)
38     {
39         byte[] cifrado1 = null;
40         byte[] cifrado2 = null;
41         try
42         {
43             Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
44             byte[] keys = privateKey.getBytes();
45             SecretKeySpec sk = new SecretKeySpec(keys, "Blowfish");
46             // 解密
47             // 将加密后的数据转为byte
48             cifrado1 = Usual.f_fromBase64String(enText);
49             Cipher c2 = Cipher.getInstance("Blowfish", "BC");
50             c2.init(Cipher.DECRYPT_MODE, sk);
51             cifrado2 = c2.doFinal(cifrado1, 0, cifrado1.length);
52         }
53         catch (Exception e)
54         {
55             e.printStackTrace();
56         }
57         return new String(cifrado2, Charset.forName("gb2312"));
58     }

Rijndael 加密解密

Rijndael 是带有可变块长和可变密钥长度的迭代块密码。块长和密钥长度可以分别指定成 128、192 或 256 位。

Rijndael 加密算法实现

 1 /**
 2      * Rijndael加密
 3      * 
 4      * @param text 需要加密的数据
 5      * @param privateKey 加密密钥
 6      * @return
 7      */
 8     public static String f_EnRijndael(String text, String privateKey)
 9     {
10         byte[] cifrado1 = null;
11         byte[] cifrado2 = null;
12         byte[] mensaje = text.getBytes();
13         byte[] keys = privateKey.getBytes();
14         // 位数限制问题
15         // http://search.oracle.com/search/search?start=1&search_p_main_operator=all&q=Java+Cryptography+Extension+&group=Technology+Network
16         SecretKeySpec sk = new SecretKeySpec(keys, "Rijndael");
17         Date inic = new Date();
18         try
19         {
20             Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
21             Cipher c1 = Cipher.getInstance("Rijndael", "BC"); // 有可能出现 java.security.NoSuchAlgorithmException异常，使用下面一句试试
22             // Cipher c1 = Cipher.getInstance("Rijndael/ECB/PKCS7Padding", "BC");
23             c1.init(Cipher.ENCRYPT_MODE, sk);
24             // 加密
25             cifrado1 = c1.doFinal(mensaje, 0, mensaje.length);
26         }
27         catch (Exception e)
28         {
29             e.printStackTrace();
30         }
31         return Usual.f_toBase64String(cifrado1);
32     }
33     /**
34      * Rijndael解密
35      * @param enText 需要解密的数据
36      * @param privateKey 加密密钥
37      * @return
38      */
39     public static String f_DeRijndael(String enText, String privateKey)
40     {
41         byte[] cifrado1 = null;
42         byte[] cifrado2 = null;
43         byte[] keys = privateKey.getBytes();
44         // 位数限制问题
45         // http://search.oracle.com/search/search?start=1&search_p_main_operator=all&q=Java+Cryptography+Extension+&group=Technology+Network
46         SecretKeySpec sk = new SecretKeySpec(keys, "Rijndael");
47         try
48         {
49             Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
50             Cipher c2 = Cipher.getInstance("Rijndael", "BC");
51             // Cipher c2 = Cipher.getInstance("Rijndael/ECB/", "BC");
52             // Cipher c2 = Cipher.getInstance("Rijndael/ECB/PKCS7Padding", "BC");
53             c2.init(Cipher.DECRYPT_MODE, sk);
54             // 将加密后的数据转为byte
55             cifrado1 = Usual.f_fromBase64String(enText);
56             // 解密
57             cifrado2 = c2.doFinal(cifrado1, 0, cifrado1.length);
58         }
59         catch (Exception e)
60         {
61             e.printStackTrace();
62         }
63         return new String(cifrado2, 0, cifrado2.length);
64     }

AES 加密解密

AES AES加密算法即密码学中的高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。

AES 加密算法实现

 1 /**
 2      * AES加密
 3      * 
 4      * @param mText 需要加密的数据
 5      * @param privateKey 加密密钥
 6      * @return
 7      */
 8     public static String f_EnAES(String mText, String privateKey)
 9     {
10         // 注册BouncyCastleProvider,扩展RSA "BC"
11         if (Security.getProvider(new BouncyCastleProvider().getName()) == null)
12         {
13             Security.addProvider(new BouncyCastleProvider());
14         }
15         String enDataStr = Usual.mEmpty;
16         try
17         {
18             byte[] mKeys = privateKey.getBytes();
19             byte[] enData = BCVFactory
20                     .enCrpytoSin(Usual.f_toBytes(mText), mKeys, "AES", "AES", "BC", Usual.mEmptyBytes);
21             enDataStr = Usual.f_toBase64String(enData);
22             System.out.println(enDataStr);
23         }
24         catch (Exception e)
25         {
26             System.out.println(e.getMessage());
27         }
28         return enDataStr;
29     }
30     /**
31      * AES解密
32      * 
33      * @param mEnText 需要解密的数据
34      * @param privateKey 加密密钥
35      * @return
36      */
37     public static String f_DeAES(String mEnText, String privateKey)
38     {
39         // 注册BouncyCastleProvider,扩展RSA "BC"
40         if (Security.getProvider(new BouncyCastleProvider().getName()) == null)
41         {
42             Security.addProvider(new BouncyCastleProvider());
43         }
44         String deDataStr = Usual.mEmpty;
45         try
46         {
47             byte[] mKeys = privateKey.getBytes();
48             byte[] enData = Usual.f_fromBase64String(mEnText);
49             byte[] deData = BCVFactory.deCrpytoSin(enData, mKeys, "AES", "AES", "BC", Usual.mEmptyBytes);
50             deDataStr = Usual.f_fromBytes(deData);
51         }
52         catch (Exception e)
53         {
54             e.printStackTrace();
55             // TODO: handle exception
56         }
57         return deDataStr;
58     }

DESede 加密解密

DESede DESede即三重DES加密算法，也被称为3DES或者Triple DES。使用三(或两)个不同的密钥对数据块进行三次(或两次)DES加密(加密一次要比进行普通加密的三次要快)。三重DES的强度大约和112- bit的密钥强度相当。通过迭代次数的提高了安全性，但同时也造成了加密效率低的问题。

DESede 加密算法实现

 1 /**
 2      * DESede加密
 3      * @param text 需要加密的数据
 4      * @param privateKey 加密密钥
 5      * @param args
 6      */
 7     public static String f_EnDESede(String text, String privateKey)
 8     {
 9         // 注册BouncyCastleProvider,扩展RSA "BC"
10         if (Security.getProvider(new BouncyCastleProvider().getName()) == null)
11         {
12             Security.addProvider(new BouncyCastleProvider());
13         }
14         try
15         {
16             byte[] mKeys = privateKey.getBytes();
17             byte[] enData = BCVFactory.enCrpytoSin(Usual.f_toBytes(text), mKeys, "CBC", "DESede/ECB/PKCS5Padding",
18                     "BC", Usual.mEmptyBytes);
19             System.out.println(Usual.f_toBase64String(enData));
20             return Usual.f_toBase64String(enData);
21         }
22         catch (Exception e)
23         {
24         }
25         return null;
26     }
27     /**
28      * DESede解密
29      * @param mEntext 需要解密的数据
30      * @param privateKey 加密密钥
31      * 
32      * @param args
33      */
34     public static String f_DeDESede(String mEntext, String privateKey)
35     {
36         // 注册BouncyCastleProvider,扩展RSA "BC"
37         if (Security.getProvider(new BouncyCastleProvider().getName()) == null)
38         {
39             Security.addProvider(new BouncyCastleProvider());
40         }
41         try
42         {
43             byte[] mKeys = privateKey.getBytes();
44             byte[] enData = Usual.f_fromBase64String(mEntext);
45             byte[] deData = BCVFactory.deCrpytoSin(enData, mKeys, "CBC", "DESede/ECB/PKCS5Padding", "BC",
46                     Usual.mEmptyBytes);
47             return Usual.f_fromBytes(deData);
48         }
49         catch (Exception e)
50         {
51         }
52         return null;
53     }

非对称加密算法

RSA 非对称加密算法

RSA 加密算法是一种非对称加密算法。在公钥加密标准和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。
对极大整数做因数分解的难度决定了RSA算法的可靠性。换言之，对一极大整数做因数分解愈困难，RSA算法愈可靠。尽管如此，只有一些RSA算法的变种被证明为其安全性依赖于因数分解。假如有人找到一种快速因数分解的算法的话，那么用RSA加密的信息的可靠性就肯定会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的 RSA钥匙才可能被强力方式解破。到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被解破的。但在分布式计算和量子计算机理论日趋成熟的今天，RSA加密安全性受到了挑战。

RSA 加密算法实现

 1         String Str = "我爱中国"; // 加密数据
 2         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
 3         keyPairGen.initialize(512); // 密钥位数
 4         KeyPair keyPair = keyPairGen.generateKeyPair(); // 密钥对
 5         
 6         PublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 公钥对象
 7         PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 私钥对象
 8         
 9         String publicKeyString = RsaCrypto.f_getKeyString(publicKey); //公钥值
10         String privateKeyString = RsaCrypto.f_getKeyString(privateKey);//私钥值
11         String enString = RsaCrypto.enCryptoRSA(publicKeyString, Str); // 公钥加密,私钥解密
12         String dnString = RsaCrypto.deCryptoRSA(privateKeyString, enString);
13         System.out.println("原来的:" + Str + "解密后的 :" + dnString);
14         System.out.println("加密后的token" + enString);

 1 /**
 2      * 将密钥转换成Base64
 3      * @param key 公钥、私钥对象
 4      * @return  密钥转换成Base64String
 5      * @throws UnsupportedEncodingException 编码错误
 6      */
 7     public static String f_getKeyString(Key key) throws UnsupportedEncodingException  
 8     {
 9         byte[] keyBytes = key.getEncoded();
10         String s = Usual.mEmpty;
11         // s = (new BASE64Encoder()).encode(keyBytes);
12         // s = new String(Base64.encodeBase64(keyBytes), Usual.mUTF8Name);
13         s = new String(Base64.encode(keyBytes), Usual.mUTF8Name);
14         return s;
15     }

 1     /**
 2      * RSA 加密
 3      * 
 4      * @param publicKeyString 公钥的Base64string
 5      * @param provider 算法实现类库。为"",使用JDK的实现算法。"BC"使用的是bouncycastle
 6      * @return 加密后的密文 Base64string
 7      * @throws NoSuchAlgorithmException
 8      * @throws NoSuchProviderException
 9      * @throws NoSuchPaddingException
10      * @throws InvalidKeyException
11      * @throws IllegalBlockSizeException
12      * @throws BadPaddingException
13      * @throws UnsupportedEncodingException 
14      * @throws InvalidKeySpecException 
15      */
16     public static String enCryptoRSA(String publicKeyString, String text, String provider)
17             throws NoSuchAlgorithmException, NoSuchProviderException, NoSuchPaddingException, InvalidKeyException,
18             IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException, InvalidKeySpecException
19     {
20             // 私钥解密
21             PublicKey publicKey = f_getPublicKey(publicKeyString);
22             //加密
23             return enCryptoRSA(provider, text, publicKey);
24         
25     }

 1     /**
 2      * RSA解密,扩展支持BC
 3      * 
 4      * @param privateKeyString 私钥的Base64String
 5      * @param enString 加密后的密文，并转成Base64String
 6      * @return
 7      * @throws BadPaddingException 
 8      * @throws IllegalBlockSizeException 
 9      * @throws NoSuchPaddingException 
10      * @throws NoSuchProviderException 
11      * @throws InvalidKeySpecException 
12      * @throws NoSuchAlgorithmException 
13      * @throws UnsupportedEncodingException 
14      * @throws InvalidKeyException 
15      */
16     public static String deCryptoRSA(String privateKeyString, String enString) throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchProviderException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException
17     {
18         if (Security.getProvider(new BouncyCastleProvider().getName()) == null)
19         {
20             Security.addProvider(new BouncyCastleProvider());
21         }
22         return deCryptoRSA(privateKeyString, enString, "BC");
23     }

以上是关于对称加密和非对称加密的主要内容，如果未能解决你的问题，请参考以下文章

密码学中的对称加密和非对称加密

对称加密和非对称加密

对称加密和非对称加密的区别

Python学习————对称加密和非对称加密

对称加密和非对称加密