精华内容
下载资源
问答
  • 关于明文传输问题

    万次阅读 2018-09-12 00:34:41
    上周拿到一个线上复测的项目,中间有一个明文传输问题,这个问题平时基本不记,客户那测试基本都是内网环境,上线基本都是 https。这个问题之前是这样测试的:抓包,如果内容是明文就记这个问题,这里存在很多的问题...

    引子:

    上周拿到一个线上复测的项目,中间有一个明文传输问题,这个问题平时基本不记,客户那测试基本都是内网环境,上线基本都是 https。这个问题之前是这样测试的:抓包,如果内容是明文就记这个问题,这里存在很多的问题。

    问题 1:线上环境 https 为什么抓到的包是明文

    这个问题很容易搜到答案,原因在于 https 的加密是传输的过程,burp 拦截的数据包没有走到传输那一步,它只相当于拦截的浏览器的数据,相当于就是客户端。
    https 抓包原理第一步,抓包程序将服务器返回的证书拦截,第二步,给客户端返回一个自己的证书,第三步,客户端发送的数据包程序用自己的证书解密,第四步,再用拦截的证书加密发送给服务器。

    请输入图片描述

    这就是为什么 burp 需要抓 https 的网站时,需要给浏览器导入自己证书的原因。这样,很自然的就会想到第二个问题。

    问题 2:那明文传输问题应该怎么测

    内网的测试环境基本不会 https,线上环境基本都是 https,如果有复测线上环境的情况,最简单的就是直接看 url 地址了,最明显不过。如果是 APP,没有 url 地址,那就直接抓包,可以使用 wireshark 抓包查看,如果嫌麻烦,直接到 burp 的 HTTP history 中查看 url 是否有 https 即可。

    请输入图片描述

    之前有一个误区,认为 burp 抓到的 https 包是乱码的,认为那就是 https 加密的结果。首先 https 加密后的内容,是在 burp forward 之后的,其次如果是 https 加密,消息头的内容也都是密文。如果之前有这样的误区,那么就会有第三个问题。

    问题 3:burp 拦截的一堆乱码是什么

    请输入图片描述

    类似于上图,这个是因为编码的问题,其实它和图片上传拦截的数据包很像,那些乱码属于 application/octet-stream 类型,准确点应该是头部会有一个 Content-Type 字段值为 application/octet-stream。这个类型通常指二进制流,或者其他的一些文件内容,这些内容通常需要一些客户端打开,所以感觉 burp 还原几率很小。

    图片中是有这个字段的,很多包是类似于这种乱码,但没有这个字段,是因为对于 tomcat 中间件,如果有未知类型的内容进行传输,则会默认使用 application/octet-stream 这种方式,这时候 burp 拦的就是那种乱码形式。

    问题 4:关于修复问题

    最终的修复方法还是使用 https。

    之前看到的修复建议有写在前端使用 js 对敏感数据进行加密这种修复方式,严格来说,作用不是很大。假设有一个恶意攻击者发起了一个钓鱼 wifi,你连上了这个 wifi,去登录一个程序,这个程序对账号和密码进行了 js 加密,那么通过中间人拦截数据包后就不会显示明文,但作用并不大,其实还是相当于明文传输,把这个数据包发送服务器是没问题的,所以说作用并不大。

    有人提出过类似的思路,js 加密敏感字段,后端接收值后在通过 md5 + 盐的方式进行数据库存储,那么对于后端来说接收的不管是明文还是进过 js 加密的密文,都是一样的,作用在于中间人拦包后获取不到明文,数据库被拖后很难还原密码这些。其实两端加密相当于没有加密。

    但不能说前端 js 加密就没有用处,作用上一段说了,会起到一定的意义,例如支付宝不仅使用了 https,也使用了前端 js 加密,如下图:

    请输入图片描述

    所以,关于修复方法,必须使用 https,其次能结合前端 js 对敏感信息进行加密更好,如果业务要求高,像银行那样,可以同时使用客户端控件进行多重加密。


                                                                            公众号推荐:aFa攻防实验室

                             分享关于信息搜集、Web安全、内网安全、代码审计、红蓝对抗、Java、Python等方面的东西。

                                                                              

    展开全文
  • 漏洞解决方案-明文传输漏洞

    千次阅读 2020-08-11 09:53:50
    漏洞解决方案-明文传输漏洞漏洞解决方案-明文传输漏洞一、漏洞概述二、利用方法和手段三、漏洞防御解决方法 漏洞解决方案-明文传输漏洞 一、漏洞概述 敏感数据明文传输简单点来说就是当我们在网站上面提交敏感数据...

    漏洞解决方案-明文传输漏洞

    一、漏洞概述

    敏感数据明文传输简单点来说就是当我们在网站上面提交敏感数据到服务器的过程中未进行相关加密处理,导致攻击者通过中间人攻击方式(劫持、嗅探等)即可获取到这些未加密的敏感数据。当攻击者获取到这些数据之后,就可以用这些信息以合法用户的身份进入到应用系统中——甚至可能进入到应用系统后台中,一旦进入到应用系统中那么就可以获取更多的敏感数据,以及更有机会发现更多的漏洞。

    二、利用方法和手段

    1. 方法1:通过中间人攻击方式(劫持、嗅探等)获取未加密的敏感数据
    2. 方法2:根据web用户登陆页面,直接进行暴力破解用户信息。

    三、漏洞防御解决方法

    1. 方法1:使用正规的ca机构颁发的https证书
    2. 方法2:采用非对称加密方式(不可逆的加密方式)
      例如:
      使用md5加盐加密方式。就是在做MD5之前给密码原文加上某个字符串后再做MD5运算。要点在于,这个salt,是每次提交之前跟服务器端实时申请的,而且会在很短的时间内自动过期(因为申请和验证之间的时间间隔只是两次连续http请求的时间,所以这个过期时间可以很短),这个salt只用一次,验证之后无论成功与否都会在服务器端强制作废。这样的话,截获任何一次MD5加密串,都无法用于另一次登录验证。
      在这里插入图片描述
      关注公众号,一起分享实用安全技术,关注安全最新事件,记录工作常见问题,吐槽生活真心操蛋。
      在这里插入图片描述
    展开全文
  • 摘要:本篇教程介绍了JavaScript基础教程 用户登录明文传输密码问题如何解决,希望阅读本篇文章以后大家有所收获,帮助大家对JavaScript的理解更加深入。 本篇教程介绍了JavaScript基础教程 用户登录明文传输密码...

    2018-09-17 来自0791

    摘要:本篇教程介绍了JavaScript基础教程 用户登录明文传输密码问题如何解决,希望阅读本篇文章以后大家有所收获,帮助大家对JavaScript的理解更加深入。

    本篇教程介绍了JavaScript基础教程 用户登录明文传输密码问题如何解决,希望阅读本篇文章以后大家有所收获,帮助大家对JavaScript的理解更加深入。

    <

    用户登录页面,获取到用户密码,用MD5加密,然后进行传输,服务器端获取的是一个加密过的密码。然后把从数据库里面获取的密码也用MD5加密,然后比较,验证登录。

    为什么用这种方法呢,当时想了2个方案,一个是换成https服务器,然后购买一个证书(所有需要用钱的都要一层一层审批,我不知道审批下来后,我还有想做不),另一个就是今天要说的,javascript+ Java+md5

    ---------------------------------------------------------------------------------------------------前端------------------------------------------------------------------------------------------------------------

    //MD5加密
       function encryptionPassword(){
      
      var hpassword=document.getElementById("cpassword").value;
      var hash=MD5(hpassword)
      document.getElementById("cpassword").value=hash.substring(22,32);
     }

    MD5方法的md5.js 代码最后给出,有点多

     

    ---------------------------------------------------------------------------------------------------后台------------------------------------------------------------------------------------------------------------

    把从数据库获得的密码用MD5加密

    password.equals(StringUtil.getMD5Str(operator.getPassword()).substring(22,32))

    StringUtil工具类中具体代码如下:

     

    /**
      * MD5加密
      * @修改时间:2015-06-08
      * @修改作者:Wangj
      *
      */

    public synchronized static final String getMD5Str(String str) {
      if (null == str) {
       str = "";
      }
      String MD5Str = "";
      try {

       // JDK 6 支持以下6种消息摘要算法,不区分大小写
         // md5,sha(sha-1),md2,sha-256,sha-384,sha-512

        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
        messageDigest.update(str.getBytes());
        byte b[] = messageDigest.digest();
          int i;
          StringBuilder builder = new StringBuilder(32);
          for (int offset = 0; offset < b.length; offset++) {
              i = b[offset];
            if (i < 0)
             i += 256;
            if (i < 16)
             builder.append("0");
            builder.append(Integer.toHexString(i));
         }
        MD5Str = builder.toString();

        // LogUtil.println("result: " + buf.toString());// 32位的加密

      } catch (NoSuchAlgorithmException e) {   

         e.printStackTrace();

        }

         return MD5Str;

     }

     

    最后是mds.js的代码

    ---------------------------------------------------------------------------------------------------md5.js--------------------------------------------------------------------------------------------------------

    (function UMD(name, context, definition) {
     if (typeof module !== "undefined" && module.exports) {
      module.exports = definition();
     } else if (typeof define === "function" && define.amd) {
      define(definition);
     } else {
      context[name] = definition(name, context);
     }
    })
      ("md5",
        this,
        function DEF(name, context) {
         "use strict";
         var old_public_api = (context || {})[name];
         function md5_func(text) {
          return hex_md5(text);
         }
         ;


         //计算MD5算法

    var hexcase = 0;
        function hex_md5(a) {
         if (a == "")
          return a;
         return rstr2hex(rstr_md5(str2rstr_utf8(a)))
        }
        ;
        function hex_hmac_md5(a, b) {
         return rstr2hex(rstr_hmac_md5(str2rstr_utf8(a),
           str2rstr_utf8(b)))
        }
        ;
        function md5_vm_test() {
         return hex_md5("abc").toLowerCase() == "900150983cd24fb0d6963f7d28e17f72"
        }
        ;
        function rstr_md5(a) {
         return binl2rstr(binl_md5(rstr2binl(a), a.length * 8))
        }
        ;
        function rstr_hmac_md5(c, f) {
         var e = rstr2binl(c);
         if (e.length > 16) {
          e = binl_md5(e, c.length * 8)
         }
         var a = Array(16), d = Array(16);
         for ( var b = 0; b < 16; b++) {
          a[b] = e[b] ^ 909522486;
          d[b] = e[b] ^ 1549556828
         }
         var g = binl_md5(a.concat(rstr2binl(f)), 512 + f.length * 8);
         return binl2rstr(binl_md5(d.concat(g), 512 + 128))
        }
        ;

    function rstr2hex(c) {
         try {
          hexcase
         } catch (g) {
          hexcase = 0
         }
         var f = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
         var b = "";
         var a;
         for ( var d = 0; d < c.length; d++) {
          a = c.charCodeAt(d);
          b += f.charAt((a >>> 4) & 15) + f.charAt(a & 15)
         }
         return b
        }
        ;
        function str2rstr_utf8(c) {
         var b = "";
         var d = -1;
         var a, e;
         while (++d < c.length) {
          a = c.charCodeAt(d);
          e = d + 1 < c.length ? c.charCodeAt(d + 1) : 0;
          if (55296 <= a && a <= 56319 && 56320 <= e
            && e <= 57343) {
           a = 65536 + ((a & 1023) << 10) + (e & 1023);
           d++
          }
          if (a <= 127) {
           b += String.fromCharCode(a)
          } else {
           if (a <= 2047) {
            b += String.fromCharCode(
              192 | ((a >>> 6) & 31), 128 | (a & 63))
           } else {
            if (a <= 65535) {
             b += String.fromCharCode(
               224 | ((a >>> 12) & 15),
               128 | ((a >>> 6) & 63),
               128 | (a & 63))
            } else {
             if (a <= 2097151) {
              b += String.fromCharCode(
                240 | ((a >>> 18) & 7),
                128 | ((a >>> 12) & 63),
                128 | ((a >>> 6) & 63),
                128 | (a & 63))
             }
            }
           }
          }
         }
         return b
        }
        ;

    function rstr2binl(b) {
         var a = Array(b.length >> 2);
         for ( var c = 0; c < a.length; c++) {
          a[c] = 0
         }
         for ( var c = 0; c < b.length * 8; c += 8) {
          a[c >> 5] |= (b.charCodeAt(c / 8) & 255) << (c % 32)
         }
         return a
        }
        ;
        function binl2rstr(b) {
         var a = "";
         for ( var c = 0; c < b.length * 32; c += 8) {
          a += String
            .fromCharCode((b[c >> 5] >>> (c % 32)) & 255)
         }
         return a
        }
        ;

    function binl_md5(p, k) {
         p[k >> 5] |= 128 << ((k) % 32);
         p[(((k + 64) >>> 9) << 4) + 14] = k;
         var o = 1732584193;
         var n = -271733879;
         var m = -1732584194;
         var l = 271733878;
         for ( var g = 0; g < p.length; g += 16) {
          var j = o;
          var h = n;
          var f = m;
          var e = l;
          o = md5_ff(o, n, m, l, p[g + 0], 7, -680876936);
          l = md5_ff(l, o, n, m, p[g + 1], 12, -389564586);
          m = md5_ff(m, l, o, n, p[g + 2], 17, 606105819);
          n = md5_ff(n, m, l, o, p[g + 3], 22, -1044525330);
          o = md5_ff(o, n, m, l, p[g + 4], 7, -176418897);
          l = md5_ff(l, o, n, m, p[g + 5], 12, 1200080426);
          m = md5_ff(m, l, o, n, p[g + 6], 17, -1473231341);
          n = md5_ff(n, m, l, o, p[g + 7], 22, -45705983);
          o = md5_ff(o, n, m, l, p[g + 8], 7, 1770035416);
          l = md5_ff(l, o, n, m, p[g + 9], 12, -1958414417);
          m = md5_ff(m, l, o, n, p[g + 10], 17, -42063);
          n = md5_ff(n, m, l, o, p[g + 11], 22, -1990404162);
          o = md5_ff(o, n, m, l, p[g + 12], 7, 1804603682);
          l = md5_ff(l, o, n, m, p[g + 13], 12, -40341101);
          m = md5_ff(m, l, o, n, p[g + 14], 17, -1502002290);
          n = md5_ff(n, m, l, o, p[g + 15], 22, 1236535329);
          o = md5_gg(o, n, m, l, p[g + 1], 5, -165796510);
          l = md5_gg(l, o, n, m, p[g + 6], 9, -1069501632);
          m = md5_gg(m, l, o, n, p[g + 11], 14, 643717713);
          n = md5_gg(n, m, l, o, p[g + 0], 20, -373897302);
          o = md5_gg(o, n, m, l, p[g + 5], 5, -701558691);
          l = md5_gg(l, o, n, m, p[g + 10], 9, 38016083);
          m = md5_gg(m, l, o, n, p[g + 15], 14, -660478335);
          n = md5_gg(n, m, l, o, p[g + 4], 20, -405537848);
          o = md5_gg(o, n, m, l, p[g + 9], 5, 568446438);
          l = md5_gg(l, o, n, m, p[g + 14], 9, -1019803690);
          m = md5_gg(m, l, o, n, p[g + 3], 14, -187363961);
          n = md5_gg(n, m, l, o, p[g + 8], 20, 1163531501);
          o = md5_gg(o, n, m, l, p[g + 13], 5, -1444681467);
          l = md5_gg(l, o, n, m, p[g + 2], 9, -51403784);
          m = md5_gg(m, l, o, n, p[g + 7], 14, 1735328473);
          n = md5_gg(n, m, l, o, p[g + 12], 20, -1926607734);
          o = md5_hh(o, n, m, l, p[g + 5], 4, -378558);
          l = md5_hh(l, o, n, m, p[g + 8], 11, -2022574463);
          m = md5_hh(m, l, o, n, p[g + 11], 16, 1839030562);
          n = md5_hh(n, m, l, o, p[g + 14], 23, -35309556);
          o = md5_hh(o, n, m, l, p[g + 1], 4, -1530992060);
          l = md5_hh(l, o, n, m, p[g + 4], 11, 1272893353);
          m = md5_hh(m, l, o, n, p[g + 7], 16, -155497632);
          n = md5_hh(n, m, l, o, p[g + 10], 23, -1094730640);
          o = md5_hh(o, n, m, l, p[g + 13], 4, 681279174);
          l = md5_hh(l, o, n, m, p[g + 0], 11, -358537222);
          m = md5_hh(m, l, o, n, p[g + 3], 16, -722521979);
          n = md5_hh(n, m, l, o, p[g + 6], 23, 76029189);
          o = md5_hh(o, n, m, l, p[g + 9], 4, -640364487);
          l = md5_hh(l, o, n, m, p[g + 12], 11, -421815835);
          m = md5_hh(m, l, o, n, p[g + 15], 16, 530742520);
          n = md5_hh(n, m, l, o, p[g + 2], 23, -995338651);
          o = md5_ii(o, n, m, l, p[g + 0], 6, -198630844);
          l = md5_ii(l, o, n, m, p[g + 7], 10, 1126891415);
          m = md5_ii(m, l, o, n, p[g + 14], 15, -1416354905);
          n = md5_ii(n, m, l, o, p[g + 5], 21, -57434055);
          o = md5_ii(o, n, m, l, p[g + 12], 6, 1700485571);
          l = md5_ii(l, o, n, m, p[g + 3], 10, -1894986606);
          m = md5_ii(m, l, o, n, p[g + 10], 15, -1051523);
          n = md5_ii(n, m, l, o, p[g + 1], 21, -2054922799);
          o = md5_ii(o, n, m, l, p[g + 8], 6, 1873313359);
          l = md5_ii(l, o, n, m, p[g + 15], 10, -30611744);
          m = md5_ii(m, l, o, n, p[g + 6], 15, -1560198380);
          n = md5_ii(n, m, l, o, p[g + 13], 21, 1309151649);
          o = md5_ii(o, n, m, l, p[g + 4], 6, -145523070);
          l = md5_ii(l, o, n, m, p[g + 11], 10, -1120210379);
          m = md5_ii(m, l, o, n, p[g + 2], 15, 718787259);
          n = md5_ii(n, m, l, o, p[g + 9], 21, -343485551);
          o = safe_add(o, j);
          n = safe_add(n, h);
          m = safe_add(m, f);
          l = safe_add(l, e)
         }
         return Array(o, n, m, l)
        }
        ;

    function md5_cmn(h, e, d, c, g, f) {
         return safe_add(bit_rol(safe_add(safe_add(e, h), safe_add(
           c, f)), g), d)
        }
        ;
        function md5_ff(g, f, k, j, e, i, h) {
         return md5_cmn((f & k) | ((~f) & j), g, f, e, i, h)
        }
        ;
        function md5_gg(g, f, k, j, e, i, h) {
         return md5_cmn((f & j) | (k & (~j)), g, f, e, i, h)
        }
        ;
        function md5_hh(g, f, k, j, e, i, h) {
         return md5_cmn(f ^ k ^ j, g, f, e, i, h)
        }
        ;
        function md5_ii(g, f, k, j, e, i, h) {
         return md5_cmn(k ^ (f | (~j)), g, f, e, i, h)
        }
        ;
        function safe_add(a, d) {
         var c = (a & 65535) + (d & 65535);
         var b = (a >> 16) + (d >> 16) + (c >> 16);
         return (b << 16) | (c & 65535)
        }
        ;
        function bit_rol(a, b) {
         return (a << b) | (a >>> (32 - b))
        }
        ;
        md5_func.noConflict = function publicAPI$noConflict() {
         if (context) {
          context[name] = old_public_api;
         }
         return md5_func;
        };
        return md5_func;
       })    

    本文由职坐标整理并发布,希望对同学们有所帮助。了解更多详情请关注职坐标WEB前端JavaScript频道!

    展开全文
  • App Transport Security has blocked a cleartext HTTP (http://) resource load since it is insecure. Temporary exceptions can be configured via your app's Info.plist file. 意思就是ATS阻止了HTT

    最近新建项目中,访问网络被阻止:

    App Transport Security has blocked a cleartext HTTP (http://) resource load since it is insecure. Temporary exceptions can be configured via your app's Info.plist file.

    意思就是ATS阻止了HTTP的明文传输,因为它是不安全的,要修改Info.plist文件来临时允许明文传输!


    具体操作:

    1,在Info.plist文件中添加App Transport SecuritySettings,type设置为Dictionary。

    2,在App Transport SecuritySettings 内添加Allow Arbitray Loads,type设置为Boolean,Value设置为Yes。


    直接上图:



    转载请注明出处:http://blog.csdn.net/wjiabin/article/details/59548411 谢谢!

    展开全文
  • 1、UC_SERVER登录页面修改 2、DISCUZ管理中心登录页面修改
  • 从Android P(即Android 9)开始,Android系统会限制了http明文流量的网络请求,若是使用http访问都会抛出java.io.IOException: Cleartext HTTP traffic to ... not permitted异常,使用https就可以正常进行网络请求 ...
  • 经查资料发现发现新的Android明文传输有规定 这个问题的原因是因为安卓新版本默认不允许使用明文网络传输,会强制让应用都使用https。解决办法如下,在AndroidManifest.xml文件的<application标签中,加入一句...
  • 明文传输敏感信息

    千次阅读 2021-03-21 22:17:50
    一. 什么是明文传输 明文传输简单点来说就是当我们在网站上面提交敏感数据到服务器的过程中未进行相关...明文传输只发生在HTTP协议中。 有时候网站使用了https,但是我们抓包后发现用户名和密码字段还是明文传输...
  • 敏感信息明文传输相关问题小结

    千次阅读 2018-12-24 09:41:16
    最近在工作中,由于同事对敏感信息明文传输这个漏洞认识不深,导致工作出了一些问题。经过一番研究后,发现了其中的一些小知识点,在这里跟大家分享下,具体情况是这样的: 1.我们在做安全测试的时候,经常可以通过...
  • 网站密码明文传输解决方案js+java

    千次阅读 2019-03-07 11:40:04
    解决密码明文传输的方案,基本有两种解决方案 1,将项目网站全站升级为https协议(如果要更谨慎,还需要加密)。 2,将密码进行加密后,在后台解密。 因项目升级https时间周期太长。将暂时替代方案改为RSA加密...
  • xcode7禁用了明文http传输解决方法

    千次阅读 2015-07-20 15:33:50
    使用xcode7编译的app,如果使用了http协议,那么会出现如下警告,导致请求失败。 Application Transport Security has blocked a cleartext HTTP (http://) resource load since it is insecure. Temporary ...
  • 用户密码明文传输

    2020-12-21 13:46:40
    1.解决思路 采用RSA非对称加密,页面js公钥加密,后台私钥解密。 2.实现代码 参考:https://www.cnblogs.com/nanyangke-cjz/p/5898361.html
  • 2.密码明文传输漏洞介绍 3.密码明文传输漏洞验证 4.密码明文传输漏洞修复 5.弱口令漏洞介绍 6.弱口令漏洞验证 7.弱口令漏洞修复 1.前言 前几天在对网站进行安全性测试时,在AWVS上扫描出密码明文传输漏洞。...
  • 在Android P(9.0) 系统中,限制了明文流量的网络请求,因为安卓新版本默认是不允许使用明文网络传输的,会强制让应用都使用https,非加密的流量请求都会被系统禁止掉。 Google表示,为保证用户数据和设备的安全,...
  • WEB登录密码明文传输的严重性... 1 JS实现 RSA非对称加密算法... 1 加解密及传输流程... 1 后台产生一对公钥下发给WEB页... 2 WEB页JS调用公钥进行加密提交... 2 后台校验密码不能为空... 3
  • 就拿最新的Andorid 9而言,默认已经禁止明文传输,如果你的app的targetversion值是28以上,使用http开头的url访问就会报出如下错误 Cleartext traffic not permitted:xxxx 这种问题怎么解决呢,谷歌肯定是希望大家...
  • 关键信息明文传输也是一个十分常见的漏洞。在前后端进行交互时,尤其是登录操作,需要注意对密码等关键信息进行加密,因为信息在传输过程中,可能会有被截获的危险。下面就针对扫描工具,给出几种方案。 修复方案 ...
  • 网站安全之密码明文传输漏洞

    万次阅读 2017-03-26 17:33:40
    1. 说明问题  相信关注笔者的读者应该有看过笔者之前写过的一篇文章——《keytool的用法》.这篇博客是介绍了如何生成系统使用的证书。而这个证书是在https中使用的,对于https的地址我们不用担心密码在传输时出现...
  • 攻击者可通过网络嗅探,可截获正常用户的用户名、密码、cookie等信息。 登录账号信息要求不能明文传输,求加密方案。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,786
精华内容 16,314
关键字:

如何解决http明文传输问题