• Django用RSA实现Web登录加密传输，预防抓包泄漏密码，解决ModelForm无法实现传输加密问题

    问题：

            在使用Django学习制作网站时候，以为后端钩子处理使用了md5加密，数据库中也同样以md5的方式存储，这样就解决了密码泄漏问题，因为对前端没有足够的了解所以枉下次定论。

            在测试爬取自己的网站时候发现，登录页面控制台能抓包看见密码明文惊到了，后来思考应该是先post传输到后端，我的md5加密在后端处理，前端到后端传输过程中是赤裸裸的袒露出来。所以要用前端处理加密，所以要用到jq来处理，然后思考后感觉用RSA非对称加密更佳。

    （这里仅记录登录jq前端加密）

    工具：

    jsencrypt.min.js

    pip install pycryptodome 

    因为Django的Modelform使用起来很方便所以多数接受我都是直接用此方法，然而要用jq就必须输要有标签，在测试后发现可以直接将Modelform的{{}}语句直接替换成标签照常使用Modelform的同时还能用上jquery。

    前端代码：

    1. <body>
    2. <div class="account">
    3.     <h2>用户登录h2>
    4.     <form id= "form" method="post" novalidate>
    5.         {% csrf_token %}
    6.         <div class="form-group">
    7.             <label>用户名label>
    8.             {{ form.admin_user }}
    9.             <span style="color: red;">{{ form.admin_user.errors.0 }}span>
    10.         div>
    11.         <div class="form-group">
    12.             <label>密码label>
    13.             <input class = "form-control" id="pwd" type="password" name="password" placeholder="请输入密码" required>
    14.             <input type="hidden" value="{{ pub_key }}" id="pubkey">
    15.             <span style="color: red;">{{ form.password.errors.0 }}span>
    16.         div>
    17.         <div class="form-group">
    18.             <label for="id_code">图片验证码label>
    19.             <div class="row">
    20.                 <div class="col-xs-7">
    21.                     {{ form.code }}
    22.                     <span style="color: red;">{{ form.code.errors.0 }}span>
    23.                 div>
    24.                 <div class="col-xs-5">
    25.                     <img id="image_code" src="{% url "image" %}" style="width: 125px;">
    26.                 div>
    27.             div>
    28.         div>
    29.         <input type="submit" value="登 录" class="btn btn-primary" onclick="dologin();return false;">
    30.     form>
    31. div>
    32.  
    33. <script type="text/javascript" src="{% static 'js/jquery-3.3.1.min.js'%}">script>
    34. <script type="text/javascript" src="{% static 'js/jsencrypt.min.js'%}">script>
    35.  
    36. <script>
    37. function dologin() {
    38.         //公钥加密
    39.         var pwd =$('#pwd').val(); //明文密码
    40.         var pubkey = $('#pubkey').val(); //公钥，pkcs#1格式，字符串
    41.         var jsencrypt = new JSEncrypt(); //加密对象
    42.         jsencrypt.setPublicKey(pubkey); // 设置密钥
    43.         var en_pwd = jsencrypt.encrypt(pwd); //加密
    44.         $('#pwd').val(en_pwd); //返回给密码输入input
    45.         $('#form').submit();//post提交
    46.     }
    47. script>
    48. body>

    前端用一个隐藏标签，后端传输公钥来让jq接收（公钥可以展现，密钥只要不泄漏就能）

    后端：

    1. #view
    2. def login(request):
    3.     with open("/Users/PycharmProjects/analyze_lianjia_Django/funtinos/rsa.public.pem", mode="r") as f:
    4.         pub_key = f.read()      #公钥
    5.     if request.method=="GET":   
    6.         form = Login()
    7.         return render(request,"login.html",{"form":form,"pub_key":pub_key}) #get请求进入登录页
    8.     # print(pub_key)
    9.     form = Login(data=request.POST)     #获取post请求中的信息
    10.     if form.is_valid():
    11.         user_input_code = form.cleaned_data.pop("code")
    12.         code = request.session.get("image_code","")#可能因为过时没有了所以获取时候为none这里设置让他为""
    13.         if code.upper() != user_input_code.upper():
    14.             form.add_error("code","验证码输入不正确")
    15.             return render(request, "login.html", {"form": form,"pub_key":pub_key})
    16.         admin_obj = models.Admin.objects.filter(**form.cleaned_data).first()    
    17.         if not admin_obj:
    18.             form.add_error("password","用户名或者密码不正确")
    19.             return render(request, "login.html", {"form": form,"pub_key":pub_key})
    20.         pl = models.Admin.objects.filter(admin_user=admin_obj.admin_user).first().plce
    21.         request.session["info"] = {"id":admin_obj.id,"name":admin_obj.admin_user,"plce":pl}
    22.         #session设置了保留7天
    23.         request.session.set_expiry(60*60*24*7)
    24.         return redirect("/main/home/")
    25.  
    26.     return render(request, "login.html", {"form": form,"pub_key":pub_key})

     钩子form：

    1. class Login(BootStrapModelForm):
    2.     code = forms.CharField(
    3.         label="验证码",
    4.         widget=forms.TextInput,
    5.         required=True,
    6.     )
    7.     class Meta:
    8.         model = models.Admin
    9.         fields = ["admin_user","code","password"]
    10.         widgets={
    11.             "password":forms.PasswordInput
    12.         }
    13.  
    14.     def clean_password(self):
    15.         pwd = self.cleaned_data.get("password")
    16.         print(pwd)
    17.         return RSA_decrypt(pwd)

     加密方法：

    1. from Crypto.PublicKey import RSA
    2. from Crypto.Cipher import PKCS1_v1_5
    3. from Crypto import Random
    4. import base64
    5. # 随机
    6. def RSA_create_key():
    7.     #随机
    8.     gen_random = Random.new().read
    9.     # 生成秘钥
    10.     rsakey = RSA.generate(1024,gen_random)
    11.     with open("rsa.public.pem", mode="wb") as f:
    12.         f.write(rsakey.publickey().exportKey())
    13.  
    14.     with open("rsa.private.pem", mode="wb") as f:
    15.         f.write(rsakey.exportKey())
    16.  
    17.  
    18. def RSA_encrypt(data):
    19.     # 加密
    20.     with open("/Users/PycharmProjects/analyze_lianjia_Django/funtinos/rsa.public.pem", mode="r") as f:
    21.         pk = f.read()
    22.         rsa_pk = RSA.importKey(pk)
    23.         rsa = PKCS1_v1_5.new(rsa_pk)
    24.  
    25.         result = rsa.encrypt(data.encode("utf-8"))
    26.         # 处理成b64方便传输
    27.         b64_result = base64.b64encode(result).decode("utf-8")
    28.         return b64_result
    29.  
    30. def RSA_decrypt(data):
    31.     # data = "e/spTGg3roda+iqLK4e2bckNMSgXSNosOVLtWN+ArgaIDgYONPIU9i0rIeTj0ywwXnTIPU734EIoKRFQsLmPpJK4Htte+QlcgRFbuj/hCW1uWiB3mCbyU3ZHKo/Y9UjYMuMfk+H6m8OWHtr+tWjiinMNURQpxbsTiT/1cfifWo4="
    32.     # 解密
    33.     with open("/Users//PycharmProjects/analyze_lianjia_Django/funtinos/rsa.private.pem", mode="r") as f:
    34.         prikey = f.read()
    35.         rsa_pk = RSA.importKey(prikey)
    36.         rsa = PKCS1_v1_5.new(rsa_pk)
    37.         result = rsa.decrypt(base64.b64decode(data), None)
    38.         return result.decode("utf-8")
    39.  
    40.  
    41. if __name__ == "__main__":
    42.     RSA_create_key()

    对称加密与非对称加密：

    加密（encryption）与解密（decryption）用的是同样的密钥（secret key）,这种方法叫对称加密算法。对称加密有很多种算法，由于它效率高，所以被广泛使用在很多加密协议的核心当中。

    对称加密通常使用的是相对较小的密钥，一般小于256 bit。因为密钥越大，加密越强，但加密与解密的过程越慢。如果你只用1 bit来做这个密钥，那就很简单的被破解；但如果你的密钥有1 MB大，可能永远也无法破解，但加密和解密的过程要花费很长的时间。密钥的大小既要照顾到安全性，也要照顾到效率。

    对称加密的一大缺点是密钥的管理与分配，换句话说，如何把密钥发送到需要解密你的消息的人的手里是一个问题。在发送密钥的过程中，密钥有很大的风险会被黑客们拦截。现实中通常的做法是将对称加密的密钥进行非对称加密，然后传送给需要它的人。
     

  • 相关阅读:
    7.1 实现进程内存块枚举
    一个 Angular 开发人员对腾讯 Cloud Studio 使用后的体验报告
    VSCode修改主题为Eclipse 绿色护眼模式
    冯诺依曼体系结构及操作系统的认识
    webpack快速入门-核心概念
    ArcGIS基础：使用线段分割面数据操作
    No qualifying bean of type ‘...‘ available错误解决
    C++标准库分析总结(九)——＜仿函数＞
    音频如何转换成mp3格式？详细步骤解析
    6 - 字典
  • 原文地址：https://blog.csdn.net/weixin_47481982/article/details/127811046