Java课设之数据加密

最新推荐文章于 2024-04-17 15:50:56 发布

zpy2223

最新推荐文章于 2024-04-17 15:50:56 发布

阅读量794

点赞数

文章标签： java 安全开发语言

本文链接：https://blog.csdn.net/m0_60759017/article/details/128208474

版权

1.加密

加密，是以某种特殊的算法改变原有的信息数据，使得未授权的用户即使获得了已加密的信息，但因不知解密的方法，仍然无法了解信息的内容。大体上分为 双向加密 和 单向加密 ，而双向加密又分为 对称加密 和 非对称加密。

双向加密类型

从大的方向来讲，加密类型主要有两种：

对称加密

对称加密使用单个加密密钥来加密和解密数据。在此过程中，授权方共享一个密钥，这种加密方式速度、低资源消耗低，能保证一定的数据安全性。对称加密是一项古老的技术，它在单个密钥上工作，因此黑客很难捕获传输中的数据，但是，如果密钥被泄露，黑客就可以加密和解密信息。

非对称加密

非对称加密也称为公钥密码术，适用于公钥和私钥，私钥应保密以解码信息，公钥用于对信息进行编码。非对称加密的特性就是隐私性、合法性、不可否认性。与对称加密相比，这种加密技术资源使用率高。加密小部分数据，非对称加密非常有用。

以课设为例，用户密码的存储应该使用单向加密，而敏感信息应使用双向加密。经过对比与分析，我决定采用AES加密。

AES 密码学中的高级加密标准（Advanced Encryption Standard，AES），是一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。

那么为什么原来的DES会被取代呢，，原因就在于其使用56位密钥，比较容易被破解。而AES可以使用128、192、和256位密钥，并且用128位分组加密和解密数据，相对来说安全很多。完善的加密算法在理论上是无法破解的，除非使用穷尽法。使用穷尽法破解密钥长度在128位以上的加密数据是不现实的，仅存在理论上的可能性。统计显示，即使使用目前世界上运算速度最快的计算机，穷尽128位密钥也要花上几十亿年的时间，更不用说去破解采用256位密钥长度的AES算法了。

2.AES加密方式简析

AES加密是对称加密 128 192 256 分别表示密钥的长度

AES的加密方式会将明文拆分成不同的块进行加密，例如一个256 位的数据用128的密钥加密，则分成

明文1（128位）明文2（128位）

加密

密文1（128位）密文2（128位）

填充：

如果明文不是128位（16字节）的则需要填充，即在明文某个地方补充到16个字节整数倍的长度，加解密时需要采用同样的填充方式，否则无法解密成功，以下是几种填充方式

NoPadding不进行填充，但是这里要求明文必须要是16个字节的整数倍，这个可以使用者本身自己去实现填充，除了该种模式以外的其他填充模式，如果已经是16个字节的数据的话，会再填充一个16字节的数据

PKCS5Padding（默认）在明文的末尾进行填充，填充的数据是当前和16个字节相差的数量，例如：

未填充明文

1，2，3，4，5，6，7，8，9，10，11

填充明文（缺少五个满足16个字节）

1，2，3，4，5，6，7，8，9，10，11，5，5，5，5，5

由于使用PKCS7Padding/PKCS5Padding填充时，最后一个字节肯定为填充数据的长度，所以在解密后可以准确删除填充的数据

ISO10126Padding在明文的末尾进行填充，当前和16个字节相差的数量填写在最后，其余字节填充随机数，例如：

未填充明文

1，2，3，4，5，6，7，8，9，10，11

填充明文（缺少五个满足16个字节）

1，2，3，4，5，6，7，8，9，10，11，c，b，4，1，5

模式

模式是需要制定AES对明文进行加密时使用的模式（这里并不涉及具体的加密方法，只是加密步骤上的不同模式，在加解密时同样需要相同的模式，否则无法成功），一共提供了五种模式，模式的基本原理是近似的，但是细节上会有一些变化，如下：

ECB模式（默认）电码本模式 Electronic Codebook Book

这个模式是默认的，就只是根据密钥的位数，将数据分成不同的块进行加密，加密完成后，再将加密后的数据拼接起来，过程如下：

明文（64字节）密钥（16字节）

明文1（16字节）明文2（16字节）明文3（16字节）明文4（16字节）

密文1（16字节）密文2（16字节）密文3（16字节）密文4（16字节）

密文（64字节）

优点：简单、速度快、可并行缺点：如果明文块相同，则生成的密文块也相同，这样会导致安全性降低

3.工具类（util)

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESUtil {
   //密钥
   public static final String KEY = "ASDFGHJKLZXCVBNM";
   //算法
   private static final String ALGORITHMSTR = "AES/CBC/PKCS5Padding";
   //密钥
   public static final String IV_KEY = "QWERTYUIOPZXCVBN";
   //算法(恢复有ECB加解密方式)
   private static final String ALGORITHMSTRCSS = "AES/ECB/PKCS5Padding";

   /**
    * base 64 encode
    * @param bytes 待编码的byte[]
    * @return 编码后的base 64 code
    */
   public static String base64Encode(byte[] bytes){
       return Base64.getMimeEncoder().encodeToString(bytes);
  }

   /**
    * base 64 decode
    * @param base64Code 待解码的base 64 code
    * @return 解码后的byte[]
    * @throws Exception
    */
   public static byte[] base64Decode(String base64Code) throws Exception{
       return base64Code == null || base64Code.trim().length() <= 0 ? null : Base64.getMimeDecoder().decode(base64Code);
  }


   /**
    * AES加密
    * @param content 待加密的内容
    * @param encryptKey 加密密钥
    * @return 加密后的byte[]
    * @throws Exception
    */
   public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
       KeyGenerator kgen = KeyGenerator.getInstance("AES");
       kgen.init(128);
       Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
       //对字符串的编码转换，添加指定编码方式"UTF-8"
       IvParameterSpec iv = new IvParameterSpec(IV_KEY.getBytes("UTF-8"));
       cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(encryptKey.getBytes("UTF-8"), "AES"),iv);
       return cipher.doFinal(content.getBytes("utf-8"));
       //对字符串的编码转换，添加指定编码方式"UTF-8"
  }

   /**
    * AES加密为base 64 code
    * @param content 待加密的内容
    * @param encryptKey 加密密钥
    * @return 加密后的base 64 code
    * @throws Exception
    */
   public static String aesEncrypt(String content, String encryptKey) throws Exception {
       return base64Encode(aesEncryptToBytes(content, encryptKey));
  }

   /**
    * AES解密
    * @param encryptBytes 待解密的byte[]
    * @param decryptKey 解密密钥
    * @return 解密后的String
    * @throws Exception
    */
   public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
       KeyGenerator kgen = KeyGenerator.getInstance("AES");
       kgen.init(128);
       Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
       //对字符串的编码转换，添加指定编码方式"UTF-8"
       IvParameterSpec iv = new IvParameterSpec(IV_KEY.getBytes("UTF-8"));
       cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(decryptKey.getBytes("UTF-8"), "AES"),iv);
       byte[] decryptBytes = cipher.doFinal(encryptBytes);
       return new String(decryptBytes,"UTF-8");
       //对字符串的编码转换，添加指定编码方式"UTF-8"
  }

   /**
    * 将base 64 code AES解密
    * @param encryptStr 待解密的base 64 code
    * @param decryptKey 解密密钥
    * @return 解密后的string
    * @throws Exception
    */
   public static String aesDecrypt(String encryptStr, String decryptKey) throws Exception {
       return encryptStr == null || encryptStr.trim().length() <= 0  ? null : aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
  }

   /**
    * AES加密
    * @param content 待加密的内容
    * @param encryptKey 加密密钥
    * @return 加密后的byte[]
    * @throws Exception
    */
   public static byte[] cssAesEncryptToBytes(String content, String encryptKey) throws Exception {
       KeyGenerator kgen = KeyGenerator.getInstance("AES");
       kgen.init(128);
       Cipher cipher = Cipher.getInstance(ALGORITHMSTRCSS);
       cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(encryptKey.getBytes("UTF-8"), "AES"));
       return cipher.doFinal(content.getBytes("utf-8"));
  }

   /**
    * AES解密
    * @param encryptBytes 待解密的byte[]
    * @param decryptKey 解密密钥
    * @return 解密后的String
    * @throws Exception
    */
   public static String cssAesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
       KeyGenerator kgen = KeyGenerator.getInstance("AES");
       kgen.init(128);

       Cipher cipher = Cipher.getInstance(ALGORITHMSTRCSS);
       cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(decryptKey.getBytes("UTF-8"), "AES"));
       byte[] decryptBytes = cipher.doFinal(encryptBytes);
       return new String(decryptBytes,"UTF-8");
  }

   /**
    * AES加密为base 64 code
    * @param content 待加密的内容
    * @param encryptKey 加密密钥
    * @return 加密后的base 64 code
    * @throws Exception
    */
   public static String cssAesEncrypt(String content, String encryptKey) throws Exception {
       return base64Encode(cssAesEncryptToBytes(content, encryptKey));
  }

   /**
    * base 64 decode
    * @param base64Code 待解码的base 64 code
    * @return 解码后的byte[]
    * @throws Exception
    */
   public static byte[] cssBase64Decode(String base64Code) throws Exception{
       return base64Code == null || base64Code.trim().length() <= 0  ? null : Base64.getDecoder().decode(base64Code);
  }

   /**
    * 将base 64 code AES解密
    * @param encryptStr 待解密的base 64 code
    * @param decryptKey 解密密钥
    * @return 解密后的string
    * @throws Exception
    */
   public static String cssAesDecrypt(String encryptStr, String decryptKey) throws Exception {
       return encryptStr == null || encryptStr.trim().length() <= 0 ? null : cssAesDecryptByBytes(cssBase64Decode(encryptStr), decryptKey);
  }

}

特别致谢：

https://blog.csdn.net/weixin_44954939/article/details/116457562

https://blog.csdn.net/m0_57556230/article/details/121972938