Java加密技术（二）——对称加密算法DES&AES

Posted on

Java加密技术（二）——对称加密算法DES&AES

接下来我们介绍对称加密算法，最常用的莫过于DES数据加密算法。

DES DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。 DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。 通过java代码实现如下：Coder类见 Java加密技术（一） Java代码 复制代码 收藏代码

  1. import java.security.Key;
  2. import java.security.SecureRandom;
  4. import javax.crypto.Cipher;
  5. import javax.crypto.KeyGenerator;
  6. import javax.crypto.SecretKey;
  7. import javax.crypto.SecretKeyFactory;
  8. import javax.crypto.spec.DESKeySpec;
  11. ///
  12. /* DES安全编码组件
  13. /*
  14. /*
  15. /* 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR)
  16. /* DES key size must be equal to 56
  17. /* DESede(TripleDES) key size must be equal to 112 or 168
  18. /* AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
  19. /* Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
  20. /* RC2 key size must be between 40 and 1024 bits
  21. /* RC4(ARCFOUR) key size must be between 40 and 1024 bits
  22. /* 具体内容 需要关注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html
  23. /*
  24. /*
  25. /* @author 梁栋
  26. /* @version 1.0
  27. /* @since 1.0
  28. /*/
  29. public abstract class DESCoder extends Coder {
  30. ///
  31. /* ALGORITHM 算法
  32. /* 可替换为以下任意一种算法，同时key值的size相应改变。
  33. /*
  34. /*
  35. /* DES key size must be equal to 56
  36. /* DESede(TripleDES) key size must be equal to 112 or 168
  37. /* AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
  38. /* Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
  39. /* RC2 key size must be between 40 and 1024 bits
  40. /* RC4(ARCFOUR) key size must be between 40 and 1024 bits
  41. /*
  42. /*
  43. /* 在Key toKey(byte[] key)方法中使用下述代码
  44. /* SecretKey secretKey = new SecretKeySpec(key, ALGORITHM); 替换
  46. /*
  47. /* DESKeySpec dks = new DESKeySpec(key);
  48. /* SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
  49. /* SecretKey secretKey = keyFactory.generateSecret(dks);
  50. /*
  51. /*/
  52. public static final String ALGORITHM = "DES";
  54. ///
  55. /* 转换密钥
  56. /*
  57. /* @param key
  58. /* @return
  59. /* @throws Exception
  60. /*/
  61. private static Key toKey(byte[] key) throws Exception {
  62. DESKeySpec dks = new DESKeySpec(key);
  63. SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
  64. SecretKey secretKey = keyFactory.generateSecret(dks);
  66. // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码
  67. // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);
  69. return secretKey;
  70. }
  72. ///
  73. /* 解密
  74. /*
  75. /* @param data
  76. /* @param key
  77. /* @return
  78. /* @throws Exception
  79. /*/
  80. public static byte[] decrypt(byte[] data, String key) throws Exception {
  81. Key k = toKey(decryptBASE64(key));
  83. Cipher cipher = Cipher.getInstance(ALGORITHM);
  84. cipher.init(Cipher.DECRYPT_MODE, k);
  86. return cipher.doFinal(data);
  87. }
  89. ///
  90. /* 加密
  91. /*
  92. /* @param data
  93. /* @param key
  94. /* @return
  95. /* @throws Exception
  96. /*/
  97. public static byte[] encrypt(byte[] data, String key) throws Exception {
  98. Key k = toKey(decryptBASE64(key));
  99. Cipher cipher = Cipher.getInstance(ALGORITHM);
  100. cipher.init(Cipher.ENCRYPT_MODE, k);
  102. return cipher.doFinal(data);
  103. }
  105. ///
  106. /* 生成密钥
  107. /*
  108. /* @return
  109. /* @throws Exception
  110. /*/
  111. public static String initKey() throws Exception {
  112. return initKey(null);
  113. }
  115. ///
  116. /* 生成密钥
  117. /*
  118. /* @param seed
  119. /* @return
  120. /* @throws Exception
  121. /*/
  122. public static String initKey(String seed) throws Exception {
  123. SecureRandom secureRandom = null;
  125. if (seed != null) {
  126. secureRandom = new SecureRandom(decryptBASE64(seed));
  127. } else {
  128. secureRandom = new SecureRandom();
  129. }
  131. KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);
  132. kg.init(secureRandom);
  134. SecretKey secretKey = kg.generateKey();
  136. return encryptBASE64(secretKey.getEncoded());
  137. }
  138. }

import java.security.Key;

import java.security.SecureRandom;

import javax.crypto.Cipher; import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

///

/ DES安全编码组件 /

/ 

/ 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR)


 / DES                  key size must be equal to 56
 / DESede(TripleDES)     key size must be equal to 112 or 168


 / AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
 / Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive)


 / RC2                  key size must be between 40 and 1024 bits
 / RC4(ARCFOUR)         key size must be between 40 and 1024 bits


/ 具体内容 需要关注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html
/

/ / @author 梁栋

/ @version 1.0 / @since 1.0

/*/ public abstract class DESCoder extends Coder {

//*/*
 /* ALGORITHM 算法 <br>

 /* 可替换为以下任意一种算法，同时key值的size相应改变。
 /*

 /* <pre>
 /* DES                  key size must be equal to 56

 /* DESede(TripleDES)     key size must be equal to 112 or 168
 /* AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available

 /* Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
 /* RC2                  key size must be between 40 and 1024 bits

 /* RC4(ARCFOUR)         key size must be between 40 and 1024 bits
 /* </pre>

 /*
 /* 在Key toKey(byte[] key)方法中使用下述代码

 /* <code>SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);</code> 替换


 /* <code>
 /* DESKeySpec dks = new DESKeySpec(key);

 /* SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
 /* SecretKey secretKey = keyFactory.generateSecret(dks);

 /* </code>
 /*/

public static final String ALGORITHM = "DES";


//*/*
 /* 转换密钥<br>

 /*
 /* @param key

 /* @return
 /* @throws Exception

 /*/
private static Key toKey(byte[] key) throws Exception {

    DESKeySpec dks = new DESKeySpec(key);
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);

    SecretKey secretKey = keyFactory.generateSecret(dks);


    // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码
    // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);


    return secretKey;

}


//*/*
 /* 解密

 /*
 /* @param data

 /* @param key
 /* @return

 /* @throws Exception
 /*/

public static byte[] decrypt(byte[] data, String key) throws Exception {
    Key k = toKey(decryptBASE64(key));


    Cipher cipher = Cipher.getInstance(ALGORITHM);

    cipher.init(Cipher.DECRYPT_MODE, k);


    return cipher.doFinal(data);
}


//*/*

 /* 加密
 /*

 /* @param data
 /* @param key

 /* @return
 /* @throws Exception

 /*/
public static byte[] encrypt(byte[] data, String key) throws Exception {

    Key k = toKey(decryptBASE64(key));
    Cipher cipher = Cipher.getInstance(ALGORITHM);

    cipher.init(Cipher.ENCRYPT_MODE, k);


    return cipher.doFinal(data);
}


//*/*

 /* 生成密钥
 /*

 /* @return
 /* @throws Exception

 /*/
public static String initKey() throws Exception {

    return initKey(null);
}


//*/*

 /* 生成密钥
 /*

 /* @param seed
 /* @return

 /* @throws Exception
 /*/

public static String initKey(String seed) throws Exception {
    SecureRandom secureRandom = null;


    if (seed != null) {

        secureRandom = new SecureRandom(decryptBASE64(seed));
    } else {

        secureRandom = new SecureRandom();
    }


    KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);

    kg.init(secureRandom);


    SecretKey secretKey = kg.generateKey();


    return encryptBASE64(secretKey.getEncoded());
}

} 延续上一个类的实现，我们通过MD5以及SHA对字符串加密生成密钥，这是比较常见的密钥生成方式。 再给出一个测试类： Java代码 复制代码 收藏代码

  1. import static org.junit.Assert./*;
  4. import org.junit.Test;
  6. ///
  7. /*
  8. /* @author 梁栋
  9. /* @version 1.0
  10. /* @since 1.0
  11. /*/
  12. public class DESCoderTest {
  14. @Test
  15. public void test() throws Exception {
  16. String inputStr = "DES";
  17. String key = DESCoder.initKey();
  18. System.err.println("原文:\t" + inputStr);
  20. System.err.println("密钥:\t" + key);
  22. byte[] inputData = inputStr.getBytes();
  23. inputData = DESCoder.encrypt(inputData, key);
  25. System.err.println("加密后:\t" + DESCoder.encryptBASE64(inputData));
  27. byte[] outputData = DESCoder.decrypt(inputData, key);
  28. String outputStr = new String(outputData);
  30. System.err.println("解密后:\t" + outputStr);
  32. assertEquals(inputStr, outputStr);
  33. }
  34. }

import static org.junit.Assert./*;

import org.junit.Test;

/// /*

/ @author 梁栋 / @version 1.0

/ @since 1.0 //

public class DESCoderTest {

@Test
public void test() throws Exception {

    String inputStr = "DES";
    String key = DESCoder.initKey();

    System.err.println("原文:\t" + inputStr);


    System.err.println("密钥:\t" + key);


    byte[] inputData = inputStr.getBytes();
    inputData = DESCoder.encrypt(inputData, key);


    System.err.println("加密后:\t" + DESCoder.encryptBASE64(inputData));


    byte[] outputData = DESCoder.decrypt(inputData, key);

    String outputStr = new String(outputData);


    System.err.println("解密后:\t" + outputStr);


    assertEquals(inputStr, outputStr);
}

} 得到的输出内容如下： Console代码 复制代码 收藏代码

  1. 原文: DES
  2. 密钥: f3wEtRrV6q0=
  4. 加密后: C6qe9oNIzRY=
  6. 解密后: DES

原文: DES

密钥: f3wEtRrV6q0=

加密后: C6qe9oNIzRY=

解密后: DES 由控制台得到的输出，我们能够比对加密、解密后结果一致。这是一种简单的加密解密方式，只有一个密钥。 其实DES有很多同胞兄弟，如DESede(TripleDES)、AES、Blowfish、RC2、RC4(ARCFOUR)。这里就不过多阐述了，大同小异，只要换掉ALGORITHM换成对应的值，同时做一个代码替换SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);就可以了，此外就是密钥长度不同了。 Java代码 复制代码 收藏代码

  1. ///
  2. /* DES key size must be equal to 56
  3. /* DESede(TripleDES) key size must be equal to 112 or 168
  4. /* AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
  5. /* Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
  6. /* RC2 key size must be between 40 and 1024 bits
  7. /* RC4(ARCFOUR) key size must be between 40 and 1024 bits
  8. ///

///

/ DES key size must be equal to 56 / DESede(TripleDES) key size must be equal to 112 or 168

/ AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available / Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)

/ RC2 key size must be between 40 and 1024 bits / RC4(ARCFOUR) key size must be between 40 and 1024 bits

/// 相关链接： Java加密技术（一）——BASE64与单向加密算法MD5&SHA&MAC Java加密技术（二）——对称加密算法DES&AES Java加密技术（三）——PBE算法 Java加密技术（四）——非对称加密算法RSA Java加密技术（五）——非对称加密算法的由来 Java加密技术（六）——数字签名算法DSA Java加密技术（七）——非对称加密算法最高ECC Java加密技术（八）——数字证书 Java加密技术（九）——初探SSL Java加密技术（十）——单向认证 Java加密技术（十一）——双向认证 Java加密技术（十二）——/.PFX(/.p12)&个人信息交换文件

希望本站内容对您有点用处,有什么疑问或建议请在后面留言评论
转载请注明作者(RobinChia)和出处 It so life ，请勿用于任何商业用途
本文链接: Java加密技术（二）——对称加密算法DES&AES