几种加密算法的测试，包括对称加密和非对称加密

加密与安全1年前 (2023)发布 aixure

42 0 0

导读：对称加密算法 Blowfish 加密解密 Blowfish 加密算法介绍:BlowFish是对称加密算法的其中一种，加密后的数据是可逆的。由于BlowFish加密/解密速度快，更重要的是任何人都可以免费使用不需要缴纳版权费，所以有不少游戏都采用BlowFish加密资源文件数据。BlowFis…

对称加密算法

　　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     }

#p#副标题#e#

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     }

#p#副标题#e#
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     }

#p#副标题#e#
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     }

#p#副标题#e#

非对称加密算法

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     }