使用AES，前端加密，后端解密，spring工具类了

学习python的时候，看到很多会对参数进行加密，于是好奇心驱使下，让我去了解了下AES加密如何在java中实现。

首先

npm install crypto-js

然后在你的方法中，给你们前端源码看看，因为我用的ruoyi框架做的实验，请求可能不是axios发送的请求

1. <template>

2. <div id="app">

3. <div>index2222222</div>

4. </div>

5. </template>

7. <script>

8. import * as echarts from "echarts";

9. import {listCar} from "@/api/shopcar/car";

10. import {listSchool, qryName, qryScore} from "@/api/shool/school";

11. export default {

12. data() {

13. return {

14. // 遮罩层

15. loading: true,

16. // 选中数组

17. ids: [],

18. // 非单个禁用

19. single: true,

20. // 非多个禁用

21. multiple: true,

22. // 显示搜索条件

23. showSearch: true,

24. // 总条数

25. total: 0,

26. // 【请填写功能名称】表格数据

27. carList: [],

28. //测试数组

29. demoList:[],

30. // 弹出层标题

31. title: "",

32. // 是否显示弹出层

33. open: false,

34. // 查询参数

35. queryParams: {

36. pageNum: 1,

37. pageSize: 10,

38. spuId: null,

39. spuName: null,

40. skuId: null,

41. skuInfo: null,

42. num: null,

43. tenantId: null,

44. tenantName: null,

45. userId: null,

46. username: null,

47. isSelect: null,

48. addPrice: null,

49. price: null,

50. },

51. // 表单参数

52. form: {},

53. // 表单校验

54. rules: {

55. }

56. }

57. },

58. created() {

60. },

61. //钩子函数

62. mounted() {

63. this.qryScore();

64. this.jiami();

65. },

66. methods: {

67. jiami(){

68. // 引入crypto-js库

69. const CryptoJS = require('crypto-js');

70. // 定义密钥

71. const key = CryptoJS.enc.Utf8.parse('1234567890123456'); // 密钥长度为16字节

72. // 定义待加密的文件内容

73. const fileContent = 'Hello, World!';

74. // 加密文件内容

75. const encrypted = CryptoJS.AES.encrypt(fileContent, key, {

76. mode: CryptoJS.mode.ECB, // 加密模式为ECB

77. padding: CryptoJS.pad.Pkcs7 // 填充方式为Pkcs7

78. });

79. // 打印加密后的内容

80. console.log('加密后的内容：', encrypted.toString());

81. // 解密文件内容

82. const decrypted = CryptoJS.AES.decrypt(encrypted, key, {

83. mode: CryptoJS.mode.ECB, // 加密模式为ECB

84. padding: CryptoJS.pad.Pkcs7 // 填充方式为Pkcs7

85. });

86. // 打印解密后的内容

87. console.log('解密后的内容：', decrypted.toString(CryptoJS.enc.Utf8));

88. },

89. qryScore() {

90. this.loading = true;

91. qryScore().then(response => {

92. console.log(1234)

93. console.log(response)

94. this.draw(response)

95. });

96. },

97. draw(data) {

98. // 初始化echarts实例

99. let myChart = echarts.init(document.getElementById('myChart'))

100. console.log(this.$echarts)

101. myChart.setOption( {

102. title: {

103. text: 'ECharts 入门示例'

104. },

105. tooltip: {},

106. xAxis: {

107. data: data.name

108. },

109. yAxis: {},

110. series: [

111. {

112. name: '销量',

113. type: 'bar',

114. data: data.grade

115. }

116. ]

117. });

118. }

119. }

120. }

121. </script>

123. <style>

124. #app {

125. font-family: Avenir, Helvetica, Arial, sans-serif;

126. -webkit-font-smoothing: antialiased;

127. -moz-osx-font-smoothing: grayscale;

128. text-align: center;

129. color: #2c3e50;

130. margin-top: 60px;

131. }

132. </style>

实现结果

主要代码

1. // 引入crypto-js库

2. const CryptoJS = require('crypto-js');

4. // 定义密钥

5. const key = CryptoJS.enc.Utf8.parse('1234567890123456'); // 密钥长度为16字节

7. // 定义待加密的文件内容

8. const fileContent = 'Hello, World!';

10. // 加密文件内容

11. const encrypted = CryptoJS.AES.encrypt(fileContent, key, {

12. mode: CryptoJS.mode.ECB, // 加密模式为ECB

13. padding: CryptoJS.pad.Pkcs7 // 填充方式为Pkcs7

14. });

16. // 打印加密后的内容

17. console.log('加密后的内容：', encrypted.toString());

19. // 解密文件内容

20. const decrypted = CryptoJS.AES.decrypt(encrypted, key, {

21. mode: CryptoJS.mode.ECB, // 加密模式为ECB

22. padding: CryptoJS.pad.Pkcs7 // 填充方式为Pkcs7

23. });

25. // 打印解密后的内容

26. console.log('解密后的内容：', decrypted.toString(CryptoJS.enc.Utf8));

然后我们对请求加密。

后端我是参照这个文章写的，他是真正的大牛，感觉他的文章都写的好有用，虽然自己看不懂。

AES+自定义密钥实现加密解密（前端+后端）_crypto aes加密 自定义密钥-CSDN博客

先生成我们要的秘钥，然后把我们前端改了就行，我是在spring环境中，记得要在上面文件修改下，因为他好像不是spring环境下的配置。

成功了哈，我根据大佬文件改了改放在spring框架下也能用了，那么大致思路就有了，前端加密，后端解密就行了。

后端解密

大致思路有了，前端根据后端的秘钥进行加密发送，后端解密即可，偷个小懒我就不写了。

我把根据大佬修改后适配于spring环境下的配置文件写在下面了，因为我发现很多文章都只是个类并不适配于spring环境，还要单独修改，所以我改了那么一点点，弄出了工具类，大家粘贴复制即可。

1. package com.ruoyi.web.controller.utils;

3. import org.apache.commons.codec.binary.Hex;

4. import org.apache.commons.codec.digest.DigestUtils;

5. import org.springframework.stereotype.Component;

6. import sun.misc.BASE64Decoder;

7. import sun.misc.BASE64Encoder;

9. import javax.crypto.Cipher;

10. import javax.crypto.KeyGenerator;

11. import javax.crypto.spec.SecretKeySpec;

12. import java.nio.charset.StandardCharsets;

13. import java.security.SecureRandom;

15. /**

16. * AES 加密工具类

17. */

18. @Component

19. public class AesUtil {

20. // 加密算法RSA

21. public static final String KEY_ALGORITHM = "AES";

22. //编码方式

23. public static final String CODE_TYPE = "UTF-8";

24. //填充类型 AES/ECB/PKCS5Padding AES/ECB/ISO10126Padding

25. public static final String AES_TYPE = "AES/ECB/PKCS5Padding";

27. /**

28. * 自定义内容加盐，生成AES秘钥

29. */

30. public String generateAESKey(){

31. return DigestUtils.md5Hex(getSalt(6)).substring(8, 24);

32. }

34. /**

35. * 随机生成加盐类

36. */

37. public String getSalt(int n){

38. char[] chars = ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" +

39. "1234567890!@#$%^&*()_+").toCharArray();

40. StringBuilder stringBuilder = new StringBuilder();

41. SecureRandom random = new SecureRandom();

42. for(int i = 0; i < n; i++){

43. stringBuilder.append(chars[random.nextInt(chars.length)]);

44. }

45. return stringBuilder.toString();

46. }

48. /**

49. * 加密

50. * @param clearText 明文

51. * @param aesKey AES秘钥

52. * @return 加密串

53. */

54. public String encryptAes(String clearText, String aesKey) {

55. try {

56. SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(), KEY_ALGORITHM);

57. Cipher cipher = Cipher.getInstance(AES_TYPE);

58. cipher.init(Cipher.ENCRYPT_MODE, key);

59. byte[] encryptedData = cipher.doFinal(clearText.getBytes(CODE_TYPE));

60. return new BASE64Encoder().encode(encryptedData);

61. } catch (Exception e) {

62. throw new RuntimeException("加密失败", e);

63. }

64. }

66. /**

67. * 解密

68. * @param encryptText 密文

69. * @param aesKey AES秘钥

70. * @return 解密串

71. */

72. public String decryptAes(String encryptText, String aesKey) {

73. try {

74. byte[] byteMi = new BASE64Decoder().decodeBuffer(encryptText);

75. SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(), KEY_ALGORITHM);

76. Cipher cipher = Cipher.getInstance(AES_TYPE);

77. cipher.init(Cipher.DECRYPT_MODE, key);

78. byte[] decryptedData = cipher.doFinal(byteMi);

79. return new String(decryptedData, CODE_TYPE);

80. } catch (Exception e) {

81. throw new RuntimeException("解密失败", e);

82. }

83. }

85. // public static void main(String[] args) {

86. // String aesKey = generateAESKey();

87. // String json = "中文，abc,！@#";

88. // //加密

89. // System.out.println("字符串：" + json);

90. // String encrypt = encryptAes(json, aesKey);

91. // System.out.println(encrypt);

92. // System.out.println("加密后字符串：" + encrypt);

93. // //私钥解密

94. // System.out.println("解密后字符串：" + decryptAes(encrypt, aesKey));

95. // }

97. }