Search
 
 

Display results as :
 


Rechercher Advanced Search

Latest topics
» NewBlueFx TotalFX Windows-FL | 1.11 GB
Tue Dec 17, 2013 12:42 pm by titquarra

» NewBlueFx TotalFX Windows-FL | 1.11 GB
Tue Dec 17, 2013 12:42 pm by titquarra

» Celebrity.Sex.Tape.UNCUT.&.UNRATED.2012.720p.BRrip.x264.YIFY.mp4
Tue Dec 17, 2013 8:32 am by titquarra

» Maya Autodesk Personal Learning Edition 8.5
Tue Dec 17, 2013 7:47 am by titquarra

» Tuyệt Kỹ Đong Giai Chân Kinh (tuyệt Kỹ cua trai)
Thu Aug 23, 2012 5:38 am by Admin

» Tuyệt kỹ cua giai
Thu Aug 23, 2012 5:36 am by Admin

» NETCAT.........
Mon Aug 13, 2012 6:35 am by Admin

» Bảo mật CSDL bằng phương pháp mã hóa.
Tue Apr 17, 2012 10:04 pm by Admin

» Hàm mã hóa MD5 bằng JavaScript
Tue Apr 17, 2012 10:03 pm by Admin

Shopmotion


Affiliates
free forum


Hàm mã hóa MD5 bằng JavaScript

View previous topic View next topic Go down

Hàm mã hóa MD5 bằng JavaScript

Post  Admin on Tue Apr 17, 2012 10:03 pm

Trông các php server-script , chúng ta có thể gọi hàm MD5() để mã hóa một chuỗi , tuy nhiên cũng có thể mã hóa một chuỗi ngay trên trang web mà không cần server support PHP cũng được

Code:
/*
 *  md5.jvs 1.0b 27/06/96
 *
 * Javascript implementation of the RSA Data Security, Inc. MD5
 * Message-Digest Algorithm.
 *
 * Copyright (c) 1996 Henri Torgemane. All Rights Reserved.
 *
 * Permission to use, copy, modify, and distribute this software
 * and its documentation for any purposes and without
 * fee is hereby granted provided that this copyright notice
 * appears in all copies.
 *
 * Of course, this soft is provided "as is" without express or implied
 * warranty of any kind.
 */



function array(n) {
  for(i=0;i<n;i++) this***91;i***93;=0;
  this.length=n;
}

/* Some basic logical functions had to be rewritten because of a bug in
 * Javascript.. Just try to compute 0xffffffff >> 4 with it..
 * Of course, these functions are slower than the original would be, but
 * at least, they work!
 */

function integer(n) { return n%(0x7fffffff+0x7fffffff+2); }

function shr(a,b) {
  a=integer(a);
  b=integer(b);
  if (a-(0x7fffffff+1)>=0) {
    a=a%(0x7fffffff+1);
    a=a >> b;
    a+=0x40000000>>(b-1);
  } else
    a=a >> b;
  return a;
}

function shl1(a) {
  a=a%(0x7fffffff+1);
  if (a&0x40000000==0x40000000)
  {
    a-=0x40000000; 
    a*=2;
    a+=(0x7fffffff+1);
  } else
    a*=2;
  return a;
}

function shl(a,b) {
  a=integer(a);
  b=integer(b);
  for (var i=0;i<b;i++) a=shl1(a);
  return a;
}

function and(a,b) {
  a=integer(a);
  b=integer(b);
  var t1=(a-0x7fffffff-1);
  var t2=(b-0x7fffffff-1);
  if (t1>=0)
    if (t2>=0)
      return ((t1&t2)+(0x7fffffff+1));
    else
      return (t1&b);
  else
    if (t2>=0)
      return (a&t2);
    else
      return (a&b); 
}

function or(a,b) {
  a=integer(a);
  b=integer(b);
  var t1=(a-(0x7fffffff+1));
  var t2=(b-(0x7fffffff+1));
  if (t1>=0)
    if (t2>=0)
      return ((t1|t2)+(0x7fffffff+1));
    else
      return ((t1|b)+(0x7fffffff+1));
  else
    if (t2>=0)
      return ((a|t2)+(0x7fffffff+1));
    else
      return (a|b); 
}

function xor(a,b) {
  a=integer(a);
  b=integer(b);
  var t1=(a-(0x7fffffff+1));
  var t2=(b-(0x7fffffff+1));
  if (t1>=0)
    if (t2>=0)
      return (t1^t2);
    else
      return ((t1^b)+(0x7fffffff+1));
  else
    if (t2>=0)
      return ((a^t2)+(0x7fffffff+1));
    else
      return (a^b); 
}

function not(a) {
  a=integer(a);
  return (0x7fffffff+0x7fffffff+1-a);
}

/* Here begin the real algorithm */

    var state = new array(4);
    var count = new array(2);
    count***91;0***93; = 0;
    count***91;1***93; = 0;                   
    var buffer = new array(64);
    var transformBuffer = new array(16);
    var digestBits = new array(16);

    var S11 = 7;
    var S12 = 12;
    var S13 = 17;
    var S14 = 22;
    var S21 = 5;
    var S22 = 9;
    var S23 = 14;
    var S24 = 20;
    var S31 = 4;
    var S32 = 11;
    var S33 = 16;
    var S34 = 23;
    var S41 = 6;
    var S42 = 10;
    var S43 = 15;
    var S44 = 21;

    function F(x,y,z) {
    return or(and(x,y),and(not(x),z));
    }

    function G(x,y,z) {
    return or(and(x,z),and(y,not(z)));
    }

    function H(x,y,z) {
    return xor(xor(x,y),z);
    }

    function I(x,y,z) {
    return xor(y ,or(x , not(z)));
    }

    function rotateLeft(a,n) {
    return or(shl(a, n),(shr(a,(32 - n))));
    }


    function FF(a,b,c,d,x,s,ac) {
        a = a+F(b, c, d) + x + ac;
    a = rotateLeft(a, s);
    a = a+b;
    return a;
    }

    function GG(a,b,c,d,x,s,ac) {
    a = a+G(b, c, d) +x + ac;
    a = rotateLeft(a, s);
    a = a+b;
    return a;
    }

    function HH(a,b,c,d,x,s,ac) {
    a = a+H(b, c, d) + x + ac;
    a = rotateLeft(a, s);
    a = a+b;
    return a;
    }

    function II(a,b,c,d,x,s,ac) {
    a = a+I(b, c, d) + x + ac;
    a = rotateLeft(a, s);
    a = a+b;
    return a;
    }

    function transform(buf,offset) {
    var a=0, b=0, c=0, d=0;
    var x = transformBuffer;
   
    a = state***91;0***93;;
    b = state***91;1***93;;
    c = state***91;2***93;;
    d = state***91;3***93;;
   
    for (i = 0; i < 16; i++) {
        x***91;i***93; = and(buf***91;i*4+offset***93;,0xff);
        for (j = 1; j < 4; j++) {
        x***91;i***93;+=shl(and(buf***91;i*4+j+offset***93; ,0xff), j * 8);
        }
    }

    /* Round 1 */
    a = FF ( a, b, c, d, x***91; 0***93;, S11, 0x576aa479+0x7fffffff); /* 1 */
    d = FF ( d, a, b, c, x***91; 1***93;, S12, 0x68c7b757+0x7fffffff); /* 2 */
    c = FF ( c, d, a, b, x***91; 2***93;, S13, 0x242070db); /* 3 */
    b = FF ( b, c, d, a, x***91; 3***93;, S14, 0x41bdceef+0x7fffffff); /* 4 */
    a = FF ( a, b, c, d, x***91; 4***93;, S11, 0x757c0fb0+0x7fffffff); /* 5 */
    d = FF ( d, a, b, c, x***91; 5***93;, S12, 0x4787c62a); /* 6 */
    c = FF ( c, d, a, b, x***91; 6***93;, S13, 0x28304614+0x7fffffff); /* 7 */
    b = FF ( b, c, d, a, x***91; 7***93;, S14, 0x7d469502+0x7fffffff); /* 8 */
    a = FF ( a, b, c, d, x***91; 8***93;, S11, 0x698098d8); /* 9 */
    d = FF ( d, a, b, c, x***91; 9***93;, S12, 0x0b44f7b0+0x7fffffff); /* 10 */
    c = FF ( c, d, a, b, x***91;10***93;, S13, 0x7fff5bb2+0x7fffffff); /* 11 */
    b = FF ( b, c, d, a, x***91;11***93;, S14, 0x095cd7bf+0x7fffffff); /* 12 */
    a = FF ( a, b, c, d, x***91;12***93;, S11, 0x6b901122); /* 13 */
    d = FF ( d, a, b, c, x***91;13***93;, S12, 0x7d987194+0x7fffffff); /* 14 */
    c = FF ( c, d, a, b, x***91;14***93;, S13, 0x2679438f+0x7fffffff); /* 15 */
    b = FF ( b, c, d, a, x***91;15***93;, S14, 0x49b40821); /* 16 */

    /* Round 2 */
    a = GG ( a, b, c, d, x***91; 1***93;, S21, 0x761e2563+0x7fffffff); /* 17 */
    d = GG ( d, a, b, c, x***91; 6***93;, S22, 0x4040b341+0x7fffffff); /* 18 */
    c = GG ( c, d, a, b, x***91;11***93;, S23, 0x265e5a51); /* 19 */
    b = GG ( b, c, d, a, x***91; 0***93;, S24, 0x69b6c7ab+0x7fffffff); /* 20 */
    a = GG ( a, b, c, d, x***91; 5***93;, S21, 0x562f105e+0x7fffffff); /* 21 */
    d = GG ( d, a, b, c, x***91;10***93;, S22, 0x02441453); /* 22 */
    c = GG ( c, d, a, b, x***91;15***93;, S23, 0x58a1e682+0x7fffffff); /* 23 */
    b = GG ( b, c, d, a, x***91; 4***93;, S24, 0x67d3fbc9+0x7fffffff); /* 24 */
    a = GG ( a, b, c, d, x***91; 9***93;, S21, 0x21e1cde6); /* 25 */
    d = GG ( d, a, b, c, x***91;14***93;, S22, 0x433707d7+0x7fffffff); /* 26 */
    c = GG ( c, d, a, b, x***91; 3***93;, S23, 0x74d50d88+0x7fffffff); /* 27 */
    b = GG ( b, c, d, a, x***91; 8***93;, S24, 0x455a14ed); /* 28 */
    a = GG ( a, b, c, d, x***91;13***93;, S21, 0x29e3e906+0x7fffffff); /* 29 */
    d = GG ( d, a, b, c, x***91; 2***93;, S22, 0x7cefa3f9+0x7fffffff); /* 30 */
    c = GG ( c, d, a, b, x***91; 7***93;, S23, 0x676f02d9); /* 31 */
    b = GG ( b, c, d, a, x***91;12***93;, S24, 0x0d2a4c8b+0x7fffffff); /* 32 */

    /* Round 3 */
    a = HH ( a, b, c, d, x***91; 5***93;, S31, 0x7ffa3943+0x7fffffff); /* 33 */
    d = HH ( d, a, b, c, x***91; 8***93;, S32, 0x0771f682+0x7fffffff); /* 34 */
    c = HH ( c, d, a, b, x***91;11***93;, S33, 0x6d9d6122); /* 35 */
    b = HH ( b, c, d, a, x***91;14***93;, S34, 0x7de5380d+0x7fffffff); /* 36 */
    a = HH ( a, b, c, d, x***91; 1***93;, S31, 0x24beea45+0x7fffffff); /* 37 */
    d = HH ( d, a, b, c, x***91; 4***93;, S32, 0x4bdecfa9); /* 38 */
    c = HH ( c, d, a, b, x***91; 7***93;, S33, 0x76bb4b61+0x7fffffff); /* 39 */
    b = HH ( b, c, d, a, x***91;10***93;, S34, 0x3ebfbc71+0x7fffffff); /* 40 */
    a = HH ( a, b, c, d, x***91;13***93;, S31, 0x289b7ec6); /* 41 */
    d = HH ( d, a, b, c, x***91; 0***93;, S32, 0x6aa127fb+0x7fffffff); /* 42 */
    c = HH ( c, d, a, b, x***91; 3***93;, S33, 0x54ef3086+0x7fffffff); /* 43 */
    b = HH ( b, c, d, a, x***91; 6***93;, S34, 0x04881d05); /* 44 */
    a = HH ( a, b, c, d, x***91; 9***93;, S31, 0x59d4d03a+0x7fffffff); /* 45 */
    d = HH ( d, a, b, c, x***91;12***93;, S32, 0x66db99e6+0x7fffffff); /* 46 */
    c = HH ( c, d, a, b, x***91;15***93;, S33, 0x1fa27cf8); /* 47 */
    b = HH ( b, c, d, a, x***91; 2***93;, S34, 0x44ac5666+0x7fffffff); /* 48 */

    /* Round 4 */
    a = II ( a, b, c, d, x***91; 0***93;, S41, 0x74292245+0x7fffffff); /* 49 */
    d = II ( d, a, b, c, x***91; 7***93;, S42, 0x432aff97); /* 50 */
    c = II ( c, d, a, b, x***91;14***93;, S43, 0x2b9423a8+0x7fffffff); /* 51 */
    b = II ( b, c, d, a, x***91; 5***93;, S44, 0x7c93a03a+0x7fffffff); /* 52 */
    a = II ( a, b, c, d, x***91;12***93;, S41, 0x655b59c3); /* 53 */
    d = II ( d, a, b, c, x***91; 3***93;, S42, 0x0f0ccc93+0x7fffffff); /* 54 */
    c = II ( c, d, a, b, x***91;10***93;, S43, 0x7feff47e+0x7fffffff); /* 55 */
    b = II ( b, c, d, a, x***91; 1***93;, S44, 0x05845dd2+0x7fffffff); /* 56 */
    a = II ( a, b, c, d, x***91; 8***93;, S41, 0x6fa87e4f); /* 57 */
    d = II ( d, a, b, c, x***91;15***93;, S42, 0x7e2ce6e1+0x7fffffff); /* 58 */
    c = II ( c, d, a, b, x***91; 6***93;, S43, 0x23014315+0x7fffffff); /* 59 */
    b = II ( b, c, d, a, x***91;13***93;, S44, 0x4e0811a1); /* 60 */
    a = II ( a, b, c, d, x***91; 4***93;, S41, 0x77537e83+0x7fffffff); /* 61 */
    d = II ( d, a, b, c, x***91;11***93;, S42, 0x3d3af236+0x7fffffff); /* 62 */
    c = II ( c, d, a, b, x***91; 2***93;, S43, 0x2ad7d2bb); /* 63 */
    b = II ( b, c, d, a, x***91; 9***93;, S44, 0x6b86d392+0x7fffffff); /* 64 */

    state***91;0***93; +=a;
    state***91;1***93; +=b;
    state***91;2***93; +=c;
    state***91;3***93; +=d;

    }

    function init() {
    count***91;0***93;=count***91;1***93; = 0;
    state***91;0***93; = 0x67452301;
    state***91;1***93; = 0x6fcdab8a+0x7fffffff;
    state***91;2***93; = 0x18badcff+0x7fffffff;
    state***91;3***93; = 0x10325476;
    for (i = 0; i < digestBits.length; i++)
        digestBits***91;i***93; = 0;
    }

    function update(b) {
    var index,i;
   
    index = and(shr(count***91;0***93;,3) , 0x3f);
    if (count***91;0***93;<0x7fffffff+0x7fffffff-6)
      count***91;0***93; += 8;
        else {
      count***91;1***93;++;
      count***91;0***93;-=0x7fffffff+0x7fffffff+2;
          count***91;0***93;+=8;
        }
    buffer***91;index***93; = and(b,0xff);
    if (index  >= 63) {
        transform(buffer, 0);
    }
    }

    function finish() {
    var bits = new array(8);
    var    padding;
    var    i=0, index=0, padLen=0;

    for (i = 0; i < 4; i++) {
        bits***91;i***93; = and(shr(count***91;0***93;,(i * 8)), 0xff);
    }
        for (i = 0; i < 4; i++) {
        bits***91;i+4***93;=and(shr(count***91;1***93;,(i * 8)), 0xff);
    }
    index = and(shr(count***91;0***93;, 3) ,0x3f);
    padLen = (index < 56) ? (56 - index) : (120 - index);
    padding = new array(64);
    padding***91;0***93; = 0x80;
        for (i=0;i<padLen;i++)
      update(padding***91;i***93;);
        for (i=0;i<8;i++)
      update(bits***91;i***93;);

    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
        digestBits***91;i*4+j***93; = and(shr(state***91;i***93;, (j * 8)) , 0xff);
        }
    }
    }

/* End of the MD5 algorithm */

function hexa(n) {
 var hexa_h = "0123456789abcdef";
 var hexa_c="";
 var hexa_m=n;
 for (hexa_i=0;hexa_i<8;hexa_i++) {
  hexa_c=hexa_h.charAt(Math.abs(hexa_m)%16)+hexa_c;
  hexa_m=Math.floor(hexa_m/16);
 }
 return hexa_c;
}


var ascii="01234567890123456789012345678901" +
          " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"+
          "***91;\\***93;^_`abcdefghijklmnopqrstuvwxyz{|}~";

function MD5(entree)
{
 var l,s,k,ka,kb,kc,kd;

 init();
 for (k=0;k<entree.length;k++) {
  l=entree.charAt(k);
  update(ascii.lastIndexOf(l));
 }
 finish();
 ka=kb=kc=kd=0;
 for (i=0;i<4;i++) ka+=shl(digestBits***91;15-i***93;, (i*8));
 for (i=4;i<8;i++) kb+=shl(digestBits***91;15-i***93;, ((i-4)*8));
 for (i=8;i<12;i++) kc+=shl(digestBits***91;15-i***93;, ((i-8)*8));
 for (i=12;i<16;i++) kd+=shl(digestBits***91;15-i***93;, ((i-12)*8));
 s=hexa(kd)+hexa(kc)+hexa(kb)+hexa(ka);
 return s;
}

loaded_MD5=true

bạn lưu lại nội dung trên vào file md5.js và có thể mã hóa bằng cách gọi hàm MD5 trong javascript

Code:
<script language="JavaScript1.2">

    var hash = MD5(str);
    document.write(hash);
</script>



Admin
Admin

Tổng số bài gửi : 782
Join date : 2009-08-15

View user profile http://hackis.forumotion.com

Back to top Go down

View previous topic View next topic Back to top


 
Permissions in this forum:
You cannot reply to topics in this forum