devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

一个简单的加密Web（vue 3 + Flask）（SM4、RSA、DES等五种加密算法）_vue sm4加密

作者：小桥流水78 | 2024-08-12 11:02:00

赞

踩

vue sm4加密

前言

        学校开了一门密码学的课程，唯一比较感兴趣的是老师关于比特币的一些介绍，旷工、矿池、攻击，以及挖矿的原理，听起来真是不亦乐乎。快要结课了来了一个作业，让我们用Python是实现五种常用的加密方式，有对称加密如DES、SM4，也有非对称加密如RSA。要求就是简单实现，供用户使用的web前端是扩展，但是想着这个作业占20分的期末总分，还是卷一卷吧。于是想到之前用uni-app与flask搭建的智能监控，前端提供用户可以交互的界面，后端通过FLask设置的路由执行相应的操作，这个项目当然也可以按这个思路来。

技术栈

        前端：Vue 3

        组件：Element Plus

        后端：Flask

        语言：Python、Typescript、H5

        功能库：Axios（http请求）、CORS（跨域）、Gmmsl（SM4加密库）、pyDes（DES加密库）

效果展示

前端

主页

文件上传                                                        加密算法选择

操作按钮

后端

实现函数以及两个路由

原文：

DES加密：

移位加密：

一次一密：

RSA：

SM4：

代码

前端
主页
  1. <template>
  2.   <div class="container">
  3.     <div class="container header">
  4.       <span>文件加密软件</span>
  5.     </div>
  6.     <div class="container main">
  7.       <el-upload
  8.         class="upload-demo"
  9.         drag
  10.         action="https://run.mocky.io/v3/9d059bf9-4660-45f2-925d-ce80ad6c4d15"
  11.         multiple
  12.         :headers="headers"
  13.         :file-list="fileList"
  14.         :on-change="handleChange"
  15.         :auto-upload="false"
  16.       >
  17.         <el-icon class="el-icon--upload"><upload-filled /></el-icon>
  18.         <div class="el-upload__text">推动文件到这里或者<em>点击我</em></div>
  19.         <template #tip>
  20.           <div class="el-upload__tip">
  21.             jpg/png files with a size less than 500kb
  22.           </div>
  23.         </template>
  24.       </el-upload>
  25.       <div class="slect">
  26.         <span>选择加密的算法</span>
  27.         <el-select v-model="optionValue" placeholder="Select">
  28.           <el-option
  29.             v-for="item in options"
  30.             :key="item.value"
  31.             :label="item.label"
  32.             :value="item.value"
  33.             :disabled="item.disabled"
  34.           />
  35.         </el-select>
  36.       </div>
  37.       <div class="button">
  38.         <el-button type="danger" @click="dialogOfUpload = false"
  39.           >取 消</el-button
  40.         >
  41.         <el-button type="primary" @click="confirmUpload()">确 认</el-button>
  42.  
  43.         <el-button @click="downloadFile()">下 载</el-button>
  44.       </div>
  45.     </div>
  46.   </div>
  47. </template>
  48. <script setup lang="ts">
  49. import { VueElement, reactive, ref, resolveComponent } from "vue";
  50. import { UploadFilled } from "@element-plus/icons-vue";
  51. // import getItem from "@/api";
  52. import axios from "axios";
  53. import { ElMessage } from "element-plus";
  54. // 设置axios的基准地址
  55. axios.defaults.baseURL = "http://127.0.0.1:5000";
  56. const fileList = reactive([]);
  57. const headers = reactive({
  58.   "Content-Type": "multipart/form-data",
  59. });
  60.  
  61. // 接受上传文件的列表
  62. const handleChange = (file, newFileList) => {
  63.   fileList.value = newFileList;
  64. };
  65. const dialogOfUpload = ref(false);
  66. const optionValue = ref("");
  67. const options = [
  68.   {
  69.     value: "ONCECryption",
  70.     label: "ONCECryption",
  71.   },
  72.   {
  73.     value: "MOVECryption",
  74.     label: "MOVECryption",
  75.   },
  76.   {
  77.     value: "DESCryption",
  78.     label: "DESCryption",
  79.   },
  80.   {
  81.     value: "SM4Cryption",
  82.     label: "SM4Cryption",
  83.   },
  84.   {
  85.     value: "RSACryption",
  86.     label: "RSACryption",
  87.   },
  88. ];
  89.  
  90. // 处理文件下载操作 
  91. const downloadFile = () => {
  92.   return new Promise((resolve, reject) => {
  93.     // 配置axios参数 
  94.     axios({
  95.       url: "/api/download",
  96.       method: "get",
  97.       params: { operation: optionValue.value },
  98.       responseType: "blob",
  99.     })
  100.     // 请求成功
  101.       .then((res) => {
  102.         try {
  103.           // 使用 blob 接受后端数据
  104.           const blob = new Blob([res.data], {
  105.             type: res.headers["Content-Type"],
  106.           });
  107.           console.log("blob", blob);
  108.           // 创建一个链接并设置内容
  109.           const url = window.URL.createObjectURL(blob);
  110.           // 创建一个链接元素以创建下载
  111.           const a = document.createElement("a");
  112.  
  113.           a.style.display = "none";
  114.           a.href = url;
  115.           a.download = "sample.txt";
  116.  
  117.           document.body.append(a);
  118.           // 触发下载
  119.           a.click();
  120.           // 清理
  121.           window.URL.revokeObjectURL(url);
  122.         } catch (e) {
  123.           console.log("下载错误", e);
  124.         }
  125.       })
  126.       .catch((err) => {
  127.         console.error(err);
  128.       });
  129.   });
  130. };
  131. // 请求后端对上传的文件进行加密
  132. const confirmUpload = () => {
  133.   // 文件 需要使用FormData对象来存储
  134.   var param = new FormData();
  135.   fileList.value.forEach((val, index) => {
  136.     param.append("file", val.raw);
  137.     param.append("optionValue", optionValue.value);
  138.   });
  139.   axios
  140.     .post("/api/encryption", param)
  141.     .then((res) => {
  142.       console.log("response", res);
  143.       ElMessage({
  144.         message: "加密成功，请点击下载",
  145.         duration: 5000,
  146.         type: "success",
  147.       });
  148.     })
  149.     .catch((err) => {
  150.       ElMessage({
  151.         message: "加密失败，请查看路径是否正确",
  152.         duration: 1000,
  153.         type: "error",
  154.       });
  155.       console.log("err", err);
  156.     });
  157. };
  158. </script>
  159. <style lang="scss" scoped>
  160. @import "./index.scss";
  161. </style>
样式
  1. .container {
  2.   width: 100%;
  3.   height: 95vh;
  4.   // background: url("./images/bgNew.jpg") no-repeat;
  5.   background-color: rgb(241, 242, 244);
  6.   display: flex;
  7.   align-items: center;
  8. //   justify-content: center;
  9.   flex-direction: column;
  10.   padding: 10px;
  11.   .header {
  12.     font-family: YouSheBiaoTiHei;
  13.     font-size: 48px;
  14.     line-height: 78px;
  15.     width: 95%;
  16.     height: 15%;
  17.     border: 1px solid rgb(233, 231, 231);
  18.     border-radius: 6px;
  19.     background-color: #ffffff;
  20.     margin-top: 10px;
  21.     box-shadow: 0 0 12px rgba(0, 0, 0, 0.5); 
  22.   }
  23.   .main {
  24.     width: 95%;
  25.     height: 80%;
  26.     border: 1px solid rgb(233, 231, 231);
  27.     border-radius: 6px;
  28.     background-color: #ffffff;
  29.     margin-top: 10px;
  30.     box-shadow: 0 0 12px rgba(0, 0, 0, 0.5); 
  31.     align-items: center;
  32.     justify-content: center;
  33.     .slect {
  34.       display: flex;
  35.       flex-direction: column;
  36.       margin-top: 10px;
  37.       margin-bottom: 10px;
  38.       // width: 100%;
  39.       height: 100px;
  40.     }
  41.   }
  42. }
后端
  1. # 编写程序实现加密算法
  2. import binascii
  3. import io
  4. import os
  5. import random
  6. from gmssl.sm4 import CryptSM4, SM4_ENCRYPT, SM4_DECRYPT
  7. from pyDes import des, PAD_PKCS5, ECB
  8. from flask import Flask, request, send_file
  9. from flask_cors import CORS
  10. app = Flask(__name__)
  11. CORS(app, resources=r'/*')
  12.  
  13. raw_binary_list = []
  14. content = ""
  15. # 查看是否会将‘\n’ 也计算进去
  16. # binary_dic = dict()
  17. # for binary in binary_content.split(" "):
  18. #     raw_str = chr(int(binary, 2))
  19. #     if raw_str not in binary_dic.keys():
  20. #         binary_dic[raw_str] = 1
  21. #     else:
  22. #         binary_dic[raw_str] += 1
  23. # print(binary_dic.items())
  24. # 一次一密
  25. def generate_binary(length):
  26.     return ''.join(random.choice('01') for _ in range(length))
  27. def once_oneCryption():
  28.     # print("原始文本为：", " ".join(raw_binary_list))
  29.     # 获取每个字符编码后的长度，并生成相同长度的随机文件作为密钥
  30.     random_binary_list = [generate_binary(len(cha)) for cha in raw_binary_list]
  31.  
  32.     # print("密钥为：", " ".join(random_binary_list))
  33.     with open("ONCE_key.txt", "w", encoding="utf-8") as file_write:
  34.         file_write.write(" ".join(random_binary_list))
  35.     print('ONCE 密钥存储成功')
  36.     # 与原始文件按位异或，实现加密
  37.     ciphertext = " ".join([str(bin(int(raw_binary_list[index], 2) ^ int(random_binary_list[index], 2))).replace('0b', '') for index in range(len(random_binary_list))])
  38.     # 打印密文
  39.  
  40.     with open("ONCE_encryption.txt", "w", encoding="utf-8") as file_write:
  41.         file_write.write(ciphertext)
  42.     print("ONCE 加密成功")
  43.     # 将密文与密钥按位异或，实现解密
  44.     cryption_list = ciphertext.split(" ")
  45.     # 得到原文二进制文件
  46.     progress_list = [int(cryption_list[index], 2) ^ int(random_binary_list[index], 2)for index in range(len(cryption_list))]
  47.     # print("progress_list", progress_list)
  48.     # 恢复二进制为字符
  49.     raw_text = "".join([str(chr(binary)) for binary in progress_list])
  50.     # 打印文件内容
  51.     with open("ONCE_decryption.txt", "w", encoding="utf-8") as file_write:
  52.         file_write.write(raw_text)
  53.     print("ONCE 解密成功")
  54. # 移位加密
  55. def move_cryption():
  56.     # 生成随机密钥1~255
  57.     key = random.randint(1, 255)
  58.     # key = 200
  59.     with open('MOVE_key.txt', mode='w', encoding='utf-8') as writer:
  60.         writer.write(str(key))
  61.     print('MOVE 密钥存储成功')
  62.     # 原始文本
  63.     raw_value_list = [int(binary, 2) for binary in raw_binary_list]
  64.  
  65.     # print("原始文本", raw_value_list)
  66.     # 加密
  67.     cryption_list = []
  68.     for binary in raw_binary_list:
  69.         if int(binary, 2) + key > 255:
  70.             cryption_list.append(str(int(binary, 2) + key - 255))
  71.         else:
  72.             cryption_list.append(str(int(binary, 2) + key))
  73.     with open('MOVE_encryption.txt', mode='w', encoding='utf-8') as writer:
  74.         writer.write(''.join(cryption_list))
  75.     print('MOVE 加密成功')
  76.     # print("密文为：", cryption_list)
  77.  
  78.     # 解密
  79.     raw_text_list = "".join([str(chr(int(value) - key + 255)) if (int(value) - key) < 255 else str(chr(int(value) - key)) for value in cryption_list])
  80.     with open('MOVE_decryption.txt', mode='w', encoding='utf-8') as writer:
  81.         writer.write(raw_text_list)
  82.     print('MOVE 解密成功')
  83. def DES():
  84.     # 随机字符串作为密钥 长度未为8
  85.     key_length = 8
  86.  
  87.     key = "".join([random.choice('01') for index in range(key_length)])
  88.     with open('DES_key.txt', mode='w', encoding='utf-8') as writer:
  89.         writer.write(key)
  90.     print('DES 密钥存储成功')
  91.     # 使用pyDes 产生密钥 对原文进行加密
  92.     # 创建加密器
  93.     k = des(key, ECB, padmode=PAD_PKCS5)
  94.     # print("原文：", content)
  95.     # 将文本内容编码为 utf-8
  96.     encoded_content = content.encode('utf-8')
  97.  
  98.     encryption = k.encrypt(encoded_content)
  99.     with open('DES_encryption.txt', mode='w', encoding='utf-8') as writer:
  100.         writer.write(str(encryption))
  101.     print('DES 加密成功')
  102.  
  103.     # 使用pyDes 密钥 对原文进行解密
  104.     raw_text_encoded = k.decrypt(encryption)
  105.     raw_text = raw_text_encoded.decode('utf-8')
  106.     with open('DES_decryption.txt', mode='w', encoding='utf-8') as writer:
  107.         writer.write(raw_text)
  108.     print('DES 解密成功')
  109. def SM4_encrypt(crypt_sm4, key, value):
  110.     """
  111.     加密
  112.     :param crypt: 加密器
  113.     :param key: 密钥
  114.     :param value: 原文
  115.     :return:密文
  116.     """
  117.     crypt_sm4.set_key(key, SM4_ENCRYPT)
  118.     encrypt_value = crypt_sm4.crypt_ecb(value)
  119.     return encrypt_value.hex()
  120. def str_to_hexStr(hex_str):
  121.     """
  122.     字符串转hex
  123.     :param hex_str:
  124.     :return:
  125.     """
  126.     hex_data = hex_str.encode('utf-8')
  127.     str_bin = binascii.unhexlify(hex_data)
  128.     return str_bin.decode('utf-8')
  129. def SM4_decrypt(crypt_sm4, key, value):
  130.     """
  131.     解密
  132.     :param crypt_sm4: 解密器
  133.     :param key: 密钥
  134.     :param value: 密文
  135.     :return: 原文
  136.     """
  137.     crypt_sm4.set_key(key, SM4_DECRYPT)
  138.     # 将十六进制系列转换成字节序列
  139.     decrypt_value = crypt_sm4.crypt_ecb(bytes.fromhex(value))
  140.     return str_to_hexStr(decrypt_value.hex())
  141. def SM4():
  142.     # 每次读取4个字节 32位 文本
  143.     # 将文本进行encode
  144.     encoded_content = content.encode('utf-8')
  145.     # print(encoded_content)
  146.     # 每次读入4个字
  147.     chunk_size = 128
  148.     start = 0
  149.     end = start + chunk_size
  150.     # 创建加密器
  151.     crypt_sm4 = CryptSM4()
  152.     # 随机生成一个密钥
  153.     key = os.urandom(16)
  154.     with open('SM4_key.txt', mode='w', encoding='utf-8') as writer:
  155.         writer.write(f'{key}')
  156.     print('SM4 密钥存储成功')
  157.  
  158.     encrypt_list = []
  159.     decrypt_list = []
  160.     # 加密
  161.     while True:
  162.         input = encoded_content[start: end - 1]
  163.         start = end + chunk_size
  164.         end = start + chunk_size
  165.         if end > len(encoded_content):
  166.             break
  167.         # 加密
  168.         encrypt_value = SM4_encrypt(crypt_sm4, key, input)
  169.         encrypt_list.append(encrypt_value)
  170.     with open('SM4_encryption.txt', mode='w', encoding='utf-8') as writer:
  171.         writer.write(''.join(encrypt_list))
  172.     print('SM4 加密成功')
  173.  
  174.  
  175.     # 解密
  176.     for item in encrypt_list:
  177.         decrypt_value = SM4_decrypt(crypt_sm4, key, item)
  178.         decrypt_list.append(decrypt_value)
  179.     with open('SM4_decryption.txt', mode='w', encoding='utf-8') as writer:
  180.         writer.write(''.join(decrypt_list))
  181.     print('SM4 解密成功')
  182. def gcd(a, b):
  183.     if b == 0:
  184.         return a
  185.     else:
  186.         return gcd(b, a % b)
  187. def ext_gcd(a, b):
  188.     if b == 0:
  189.         x1 = 1
  190.         y1 = 0
  191.         x = x1
  192.         y = y1
  193.         r = a
  194.         return r, x, y
  195.     else:
  196.         r, x1, y1 = ext_gcd(b, a % b)
  197.         x = y1
  198.         y = x1 - a // b * y1
  199.         return r, x, y
  200. def get_key():
  201.     # 输入两个素数
  202.     p = 11
  203.     q = 13
  204.     # 计算n = P X Q \ Z = ( P -1 ) X ( Q - 1)
  205.     n = p * q
  206.     z = (p - 1) * (q - 1)
  207.     # 计算公私密钥 e X d = 1 (mod n) 通过欧几里得与扩展的欧几里得算法得到
  208.     e = z  # 让e与z互素 且 d > 0
  209.     while e > 1:
  210.         e -= 1
  211.         r, x, y = ext_gcd(e, z)
  212.         if (gcd(e, z) == 1) & (x > 0):
  213.             break
  214.     d = x
  215.     return (n, e), (n, d)
  216. def RSA_encrypt(x, key):
  217.     n = key[0]
  218.     e = key[1]
  219.     y = x ** e % n
  220.     return y
  221. def RSA_decrypt(y, key):
  222.     n = key[0]
  223.     d = key[1]
  224.     x = y ** d % n
  225.     return x
  226. def RSA():
  227.     # 生成公私钥
  228.     pub_k, pri_k = get_key()
  229.     with open('RSA_key.txt', mode='w', encoding='utf-8') as writer:
  230.         writer.write(f'{pub_k}, {pri_k}')
  231.     print('RSA 密钥存储成功')
  232.     # 每次读取4个字节 32位 文本
  233.     # 将文本进行encode
  234.     encoded_content = content.encode('utf-8')
  235.     # print(encoded_content)
  236.     # 每次读入4个字
  237.     start = 0
  238.  
  239.     encrypt_list = []
  240.     decrypt_list = []
  241.     # 加密
  242.     while True:
  243.         input = content[start]
  244.         start += 1
  245.         if start >= len(content):
  246.             break
  247.         # print(input)
  248.         # 加密
  249.         y = RSA_encrypt(ord(input), pub_k)
  250.  
  251.         encrypt_list.append(f'{y}')
  252.  
  253.     # print('加密后', encrypt_list)
  254.     with open('RSA_encryption.txt', mode='w', encoding='utf-8') as writer:
  255.         writer.write(''.join(encrypt_list))
  256.     print("RSA 加密成功")
  257.     # 解密
  258.     for item in encrypt_list:
  259.         # 解密
  260.         x = RSA_decrypt(int(item), pri_k)
  261.         decrypt_list.append(chr(x))
  262.     with open('RSA_decryption.txt', mode='w', encoding='utf') as writer:
  263.         writer.write(''.join(decrypt_list))
  264.     print('RSA 解密成功')
  265. def read_file(file_name):
  266.     # 文件路径
  267.     # file_name = "practice_record.txt"
  268.     global content
  269.     # 读取文件
  270.     with open(file_name, mode="r", encoding="utf-8") as file_reader:
  271.         content = file_reader.read()
  272.     # 将文件字符串进行编码 返回字符串的unicode编码 A -> 65
  273.     global raw_binary_list
  274.     raw_binary_list = [bin(ord(item)).replace('0b', '') for item in content]
  275. @app.route('/api/download', methods=['GET'])
  276. def down_file():
  277.     operation = request.args.get('operation')
  278.     print(operation)
  279.     content = ''
  280.     # 一次一密
  281.     if operation == "ONCECryption":
  282.         # 以二进制模式打开文本
  283.         with open('ONCE_encryption.txt', 'rb') as reader:
  284.             content = reader.read()
  285.         # 将文本内容转化为字节流
  286.         stream = io.BytesIO(content)
  287.         return send_file(stream, as_attachment=True, attachment_filename="ONCE_encryption.txt", mimetype='application/octet-stream')
  288.     elif operation == "MOVECryption":
  289.         # 以二进制模式打开文本
  290.         with open('MOVE_encryption.txt', 'rb') as reader:
  291.             content = reader.read()
  292.         # 将文本内容转化为字节流
  293.         stream = io.BytesIO(content)
  294.         return send_file(stream, as_attachment=True, attachment_filename="MOVE_encryption.txt",
  295.                          mimetype='application/octet-stream')
  296.     elif operation == "DESCryption":
  297.         # 以二进制模式打开文本
  298.         with open('DES_encryption.txt', 'rb') as reader:
  299.             content = reader.read()
  300.         # 将文本内容转化为字节流
  301.         stream = io.BytesIO(content)
  302.         return send_file(stream, as_attachment=True, attachment_filename="DES_encryption.txt",
  303.                          mimetype='application/octet-stream')
  304.     elif operation == "SM4Cryption":
  305.         # 以二进制模式打开文本
  306.         with open('SM4_encryption.txt', 'rb') as reader:
  307.             content = reader.read()
  308.         # 将文本内容转化为字节流
  309.         stream = io.BytesIO(content)
  310.         return send_file(stream, as_attachment=True, attachment_filename="SM4_encryption.txt",
  311.                          mimetype='application/octet-stream')
  312.     elif operation == "RSACryption":
  313.         # 以二进制模式打开文本
  314.         with open('RSA_encryption.txt', 'rb') as reader:
  315.             content = reader.read()
  316.         # 将文本内容转化为字节流
  317.         stream = io.BytesIO(content)
  318.         return send_file(stream, as_attachment=True, attachment_filename="RSA_encryption.txt",
  319.                          mimetype='application/octet-stream')
  320.     else:
  321.         return "error"
  322. @app.route('/api/encryption', methods=['POST', 'GET'])
  323. def handle_cryption():
  324.     # 接受上传的文件
  325.     fileList = request.files.getlist("file")
  326.     # 接受需要执行的加密算法
  327.     cryption_type = request.form.get("optionValue")
  328.     file_name = ""
  329.     for file in fileList:
  330.         # 读取数据
  331.         file_stream = file.stream.read()
  332.         with open(file.filename, 'wb') as writer:
  333.             writer.write(file_stream)
  334.         file_name = file.filename
  335.     print(fileList[0], cryption_type)
  336.     # 读取文件 得到原始文本和二进制的列表
  337.     read_file(file_name)
  338.     if cryption_type == "ONCECryption":
  339.         once_oneCryption()
  340.     elif cryption_type == "MOVECryption":
  341.         move_cryption()
  342.     elif cryption_type == "DESCryption":
  343.         DES()
  344.     elif cryption_type == "SM4Cryption":
  345.         SM4()
  346.     elif cryption_type == "RSACryption":
  347.         RSA()
  348.     else:
  349.         return "error"
  350.     return "data received"
  351. if __name__ == '__main__':
  352.     # once_oneCryption()
  353.     # move_cryption()
  354.     # DES()
  355.     # SM4()
  356.     # RSA()
  357.     # print(raw_binary_list)
  358.     app.run(debug=True)

技术实现

        界面设计

        该项目对界面美观要求不高，功能也相对简单。采用一个上下占比2：8的布局，整体背景使用浅灰色，上下两个部分单独使用div包裹，对边框进行圆润以及添加的阴影使其与背景分离，简单地形成一定的层次感。

        文件上传使用element plus中提供的组件，支持拖拽等功能，将其放置在最上面，紧接着下方放置一个多选框，用户可以选择自己需要使用的加密算法，最后提供三个按钮，取消、确定、下载。

        功能分析

        文件上传：elemeng plus在原生upload上进行开发，提供了可拖拽功能。为了能够获取到上传的文件，先初始化一个变量fileList，在el-upload中使用:file-list动态获取上传的文件，当上传多个文件时，文件会以列表的形式存储，而后使用axios讲文件封装成formdata格式的数据进行传输。

        算法选择：使用el-elect组件，配置选项参数。初始化一个optionValue变量，将该变量放置在el-elect组件中使用:optionValue动态接受选项的值。

        传输文件与选择的算法：文件使用变量filelist存储、算法使用变量optionValue存储。在后端已经启动了一个flask服务，地址为http://localhost，并且配置了加密路由与下载路由。配置axios目标地址、请求方法、传输数据，向后端发送。后端接受请求的参数，执行不同的加密算法。

        下载文件：前端使用axios向后端下载路由发送需要下载的加密后的文件，后端以字节流的形式发送到前端，前端使用blob存放数据，创建一个链接并放置blob数据，再创建一个<a>标签用于触发下载事件。

        接受文件并加密：后端使用flask启动一个web服务，将接受文件与执行加密操作放置在函数中，并为该函数配置一个路由地址，使得前端能够通过后端ip以及路由地址请求该函数。后端使用request函数接收前端传来的参数，根据参数调用不同的函数执行不同的加密算法。密钥与密文都会存储在本地的项目的根目录下。

        返回密文文件：接收到前端发来的下载密文文件的请求，根据参数读取相应算法加密后的密文，读取文件时要配置open函数中mode参数为‘rb’，因为需要将文件以二进制读取，而后再通过send_file将二进制以字节流的方式发往前端。

问题与解决

        1. 前后发送request请求，报了bad request的错误，大概率是因为前后发送与接收数据的方式不一致，比如前端使用下面的方式发送params，后端需要使用request.args.get（）的方式接收

  1.  axios({
  2.       url: "/api/download",
  3.       method: "get",
  4.       params: { operation: optionValue.value },
  5.       responseType: "blob",
  6.     })

        2. 针对跨域问题，在后端使用flask框架时，可以直接在后端使用CORS库解决这个问题，不需要在前端进行配置。

        3. 针对前端下载文件这种任务，后端不能直接传文件，需要将文件以二进制的形式读取，再通过字节流的形式发送。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/969409
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号