python-sha1和base64加密实际问题的解决

今天笔者分享的是简单的加密**的方法，主要分享怎样更加简单的查找加密的文件一些小技巧和方法。
一：
目标的路径：http://www.zjyypt.net/portal/login.action，需要账号和密码，账号和密码这里就不在提供。
主要需要解决的问题如下图所示：

从圈出的可知，密码和作者编码都进行了加密，那么怎么分析这些加密并将其**出来呢？笔者在这里分享一下个人的小技巧当然并不一定是最好的方法。
同样的F12调试浏览器页面，这个时候我们按照之前的分析方法来查找js可知:

并不能找到自己想要的加密函数，这个时候笔者分享另一种方法，通过Chrom浏览器进行调试。

这个时候我们随意输入账号和密码，打开NetWork进行刷新，我们可以找到所加载的js文件，这个时候我们想想很明显的应该在提交的js中进行加密，当然也可能在其他js中，这只是一个经验分析，我们点进去这个提交的js文件。

从上图可以看出来，我们需要的密码参数一个是通过hex_sha1加密然后取其16进制，当然作者的authCode是对密码进行base64进行加密的，这个时候可以通过第一种方法既然我们知道了加密的方式那么，就直接可以写python的sha1加密，和base64加密获取加密后的密码和作者码，具体代码如下：

# coding=utf-8
import base64
from hashlib import sha1
password_sha1 = sha1('自己账号').hexdigest()
autho_bs64 = base64.b64encode('自己账号')
print password_sha1
print autho_bs64

运行结果就可以得到自己想要的加密过后的密码和账号，当然在前几天笔者分下那个的execjs也可以得出想要的结果，当然其中的js文件需要自己一一来查找出来，这里分享的就是一个断点调试的方法：

首先打断点，然后进入到下一个函数即可找到自己需要的函数。
这里过程笔者在上分享了几个小技巧，具体的查找过程这里就不体现了，直接上代码分析。

login_js = """
function hex_sha1(s)    { return rstr2hex(rstr_sha1(str2rstr_utf8(s))); }


function rstr2hex(input)
{
  try { hexcase } catch(e) { hexcase=0; }
  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
  var output = "";
  var x;
  for(var i = 0; i < input.length; i++)
  {
    x = input.charCodeAt(i);
    output += hex_tab.charAt((x >>> 4) & 0x0F)
           +  hex_tab.charAt( x        & 0x0F);
  }
  return output;
}

function rstr_sha1(s)
{
  return binb2rstr(binb_sha1(rstr2binb(s), s.length * 8));
}

function str2rstr_utf8(input)
{
  var output = "";
  var i = -1;
  var x, y;

  while(++i < input.length)
  {
    /* Decode utf-16 surrogate pairs */
    x = input.charCodeAt(i);
    y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
    if(0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF)
    {
      x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);
      i++;
    }

    /* Encode output as utf-8 */
    if(x <= 0x7F)
      output += String.fromCharCode(x);
    else if(x <= 0x7FF)
      output += String.fromCharCode(0xC0 | ((x >>> 6 ) & 0x1F),
                                    0x80 | ( x         & 0x3F));
    else if(x <= 0xFFFF)
      output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F),
                                    0x80 | ((x >>> 6 ) & 0x3F),
                                    0x80 | ( x         & 0x3F));
    else if(x <= 0x1FFFFF)
      output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07),
                                    0x80 | ((x >>> 12) & 0x3F),
                                    0x80 | ((x >>> 6 ) & 0x3F),
                                    0x80 | ( x         & 0x3F));
  }
  return output;
}

function binb2rstr(input)
{
  var output = "";
  for(var i = 0; i < input.length * 32; i += 8)
    output += String.fromCharCode((input[i>>5] >>> (24 - i % 32)) & 0xFF);
  return output;
}

function binb_sha1(x, len)
{
  /* append padding */
  x[len >> 5] |= 0x80 << (24 - len % 32);
  x[((len + 64 >> 9) << 4) + 15] = len;
  var w = Array(80);
  var a =  1732584193;
  var b = -271733879;
  var c = -1732584194;
  var d =  271733878;
  var e = -1009589776;
  for(var i = 0; i < x.length; i += 16)
  {
    var olda = a;
    var oldb = b;
    var oldc = c;
    var oldd = d;
    var olde = e;

    for(var j = 0; j < 80; j++)
    {
      if(j < 16) w[j] = x[i + j];
      else w[j] = bit_rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
      var t = safe_add(safe_add(bit_rol(a, 5), sha1_ft(j, b, c, d)),
                       safe_add(safe_add(e, w[j]), sha1_kt(j)));
      e = d;
      d = c;
      c = bit_rol(b, 30);
      b = a;
      a = t;
    }

    a = safe_add(a, olda);
    b = safe_add(b, oldb);
    c = safe_add(c, oldc);
    d = safe_add(d, oldd);
    e = safe_add(e, olde);
  }
  return Array(a, b, c, d, e);
}

function rstr2binb(input)
{
  var output = Array(input.length >> 2);
  for(var i = 0; i < output.length; i++)
    output[i] = 0;
  for(var i = 0; i < input.length * 8; i += 8)
    output[i>>5] |= (input.charCodeAt(i / 8) & 0xFF) << (24 - i % 32);
  return output;
}

function bit_rol(num, cnt)
{
  return (num << cnt) | (num >>> (32 - cnt));
}

function sha1_ft(t, b, c, d)
{
  if(t < 20) return (b & c) | ((~b) & d);
  if(t < 40) return b ^ c ^ d;
  if(t < 60) return (b & c) | (b & d) | (c & d);
  return b ^ c ^ d;
}

function safe_add(x, y)
{
  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
  return (msw << 16) | (lsw & 0xFFFF);
}

function sha1_kt(t)
{
  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
         (t < 60) ? -1894007588 : -899497514;
}

那么可通过

if __name__ == "__main__":
   import execjs
   r = execjs.compile(login_js)
   result = r.call('hex_sha1', '密码').lower()
   print result

即可得出我们想要的加密过后的结果，作者加密码，原理同上，这里笔者就不进行分享了。

原创：转载是须注明转载的由来和作者，违者必究。