base64加密解密　md5加密　asc　ut8　hex转换--伴你一生的家

公　　告

站点日历

日志分类

最新日志

最新评论

最新留言

用户登陆

日志搜索

统计信息

友情连接

base64加密解密 md5加密 asc ut8 hex转换

[ 2006-7-8 17:34:37 | By: myfamily ]

base64.asp

<%
 OPTION EXPLICIT
 const BASE_64_MAP_INIT ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 dim nl
 ' zero based arrays
 dim Base64EncMap(63)
 dim Base64DecMap(127)

' must be called before using anything else
 PUBLIC SUB initCodecs()
 ' init vars
 nl = "" & chr(13) & chr(10)
 ' setup base 64
 dim max, idx
 max = len(BASE_64_MAP_INIT)
 for idx = 0 to max - 1
 ' one based string
 Base64EncMap(idx) = mid(BASE_64_MAP_INIT, idx + 1, 1)
 next
 for idx = 0 to max - 1
 Base64DecMap(ASC(Base64EncMap(idx))) = idx
 next
 END SUB

' encode base 64 encoded string
PUBLIC FUNCTION base64Encode(plain)

          if len(plain) = 0 then
               base64Encode = ""
               exit function
          end if

dim ret, ndx, by3, first, second, third
 by3 = (len(plain) \ 3) * 3
 ndx = 1
 do while ndx <= by3
 first = asc(mid(plain, ndx+0, 1))
 second = asc(mid(plain, ndx+1, 1))
 third = asc(mid(plain, ndx+2, 1))
 ret = ret & Base64EncMap( (first \ 4) AND 63 )
 ret = ret & Base64EncMap( ((first * 16) AND 48) + ((second \16) AND 15 ) )
 ret = ret & Base64EncMap( ((second * 4) AND 60) + ((third \ 64) AND 3 ) )
 ret = ret & Base64EncMap( third AND 63)
 ndx = ndx + 3
 loop
 ' check for stragglers
 if by3 < len(plain) then
 first = asc(mid(plain, ndx+0, 1))
 ret = ret & Base64EncMap( (first \ 4) AND 63 )
 if (len(plain) MOD 3 ) = 2 then
 second = asc(mid(plain, ndx+1, 1))
 ret = ret & Base64EncMap( ((first * 16) AND 48) + ((second \ 16) AND 15 ) )
 ret = ret & Base64EncMap( ((second * 4) AND 60) )
 else
 ret = ret & Base64EncMap( (first * 16) AND 48)
 ret = ret & "="
 end if
 ret = ret & "="
 end if

base64Encode = ret
END FUNCTION

' decode base 64 encoded string
PUBLIC FUNCTION base64Decode(scrambled)

          if len(scrambled) = 0 then
               base64Decode = ""
               exit function
          end if

' ignore padding
 dim realLen
 realLen = len(scrambled)
 do while mid(scrambled, realLen, 1) = "="
 realLen = realLen - 1
 loop
 dim ret, ndx, by4, first, second, third, fourth
 ret = ""
 by4 = (realLen \ 4) * 4
 ndx = 1
 do while ndx <= by4
 first = Base64DecMap(asc(mid(scrambled, ndx+0, 1)))
 second = Base64DecMap(asc(mid(scrambled, ndx+1, 1)))
 third = Base64DecMap(asc(mid(scrambled, ndx+2, 1)))
 fourth = Base64DecMap(asc(mid(scrambled, ndx+3, 1)))
 ret = ret & chr( ((first * 4) AND 255) + ((second \ 16) AND 3))
 ret = ret & chr( ((second * 16) AND 255) + ((third \ 4) AND 15) )
 ret = ret & chr( ((third * 64) AND 255) + (fourth AND 63) )
 ndx = ndx + 4
 loop
 ' check for stragglers, will be 2 or 3 characters
 if ndx < realLen then
 first = Base64DecMap(asc(mid(scrambled, ndx+0, 1)))
 second = Base64DecMap(asc(mid(scrambled, ndx+1, 1)))
 ret = ret & chr( ((first * 4) AND 255) + ((second \ 16) AND 3) )
 if realLen MOD 4 = 3 then
 third = Base64DecMap(asc(mid(scrambled,ndx+2,1)))
 ret = ret & chr( ((second * 16) AND 255) + ((third \ 4) AND 15) )
 end if
 end if

base64Decode = ret
END FUNCTION

' initialize
call initCodecs

' Testing code
    dim inp, encode
    'inp = request.QueryString("input")
    encode = base64Encode("Z934f")
    response.write "Encoded value = " & encode & nl
    response.write "Decoded value = " & base64Decode(encode) & nl
%>

S.ASP '-------------chinesetoutf8,hextochinese

Function chinese2utf8Hex(Salon)
 Dim i
 Dim Salon_one
 Dim Salon_unicode,Salon_utf8
 dim tempUnicode
 dim part1,part2,part3
 dim temp2,temp3
 dim tempstr


 For i = 1 To Len(Salon)

 Salon_unicode=""



 Salon_one = Mid(Salon, i, 1)
 tempUnicode = AscW(Salon_one)
 'Response.Write Salon_one&"**"&tempUnicode&" "
 if tempunicode>=&H0000 and tempunicode<=&H007F then
 part1 = &H007F and tempunicode
 'Response.Write part1
 tempstr=cstr(hex(part1))
 Salon_unicode=tempstr

 end if


 if tempunicode>=&H0080 and tempunicode<=&H07FF then

 '第一部分第一部分先与&H003F，然后或&H0080
 part1=&H003F and tempunicode
 part1=&H0080 or part1

 '第二部分第二部分先左移2位，然后与&H1F00，然后或&HC000
 tempunicode=tempunicode*4
 part2=&H1F00 and tempunicode
 part2=&HC000 or part2
 Salon_unicode = Salon_unicode & (part2 or part1)
 end if

 if (tempunicode>=&H0800 and tempunicode<&H10000) or (tempunicode<0) then 'and tempunicode<=&H00FFFF

 temp2=tempunicode
 temp3=tempunicode


 '''''''''''''''''第一部分第一部分先与&H003F，然后或&H0080

 part1=&H003F and tempunicode
 part1=&H0080 or part1


 Salon_unicode=cstr(hex(part1))&Salon_unicode


 '''''''''''''''''第二部分第二部分先与&H0FA0，然后左移2位，然后或&H8000
 part2=&H0FC0 and temp2



 part2=part2*4



 part2=&H8000 or part2

 tempstr=cstr(hex(part2))
 tempstr=mid(tempstr,5,2)
 Salon_unicode=tempstr&Salon_unicode



 '''''''''''''''第三部分先与&HFFF0，再右移4位，然后与&H0F00，然后在与&EF00，然后左移8位。
 part3=&HFFF0 and temp3
 part3=part3/16

 part3=&H0F00 and part3
 part3=&HE000 or part3

 part3=part3*256

 tempstr=cstr(hex(part3))
 tempstr=mid(tempstr,3,2)
 Salon_unicode=tempstr&Salon_unicode
 end if
 'Response.Write Salon_unicode&" "


 Salon_utf8=Salon_utf8&Salon_unicode
 Next
 chinese2utf8Hex = Salon_utf8
End Function

Response.write chinese2utf8Hex("中国人民")&" "

'本函数只能解析asc函数转换的汉字，不能解析ascw函数转换的汉字。也就是说不支持unicode编码
function HexTochinese(inputBinaryStr)
dim tempBinaryStr,tempDigital
dim result

for i=1 to len(inputBinaryStr)/2
 tempBinaryStr=mid(inputBinaryStr,2*i-1,2)
 'Response.Write tempBinaryStr&" "
 tempDigital=cdbl("&H"&tempBinaryStr)

 'Response.Write tempDigital
 if tempDigital>0 and tempDigital<127 then
 result=result&chr(tempDigital)
 else

 tempBinaryStr=mid(inputBinaryStr,2*i-1,4)
 'Response.Write tempBinaryStr&" "
 tempDigital=cdbl("&H"&tempBinaryStr)
 'Response.Write tempDigital&" "
 result=result&chr(tempDigital)
 i=i+1
 end if

next

HexTochinese=result
end function

'无法用HexTochinese(chinese2utf8Hex("中国人民"))解析出“中国人民”
'只能用HexTochinese(hex(asc("中"))+hex(asc("国"))+hex(asc("人"))+hex(asc("民"))) 解析出“中国人民”
Response.Write HexTochinese(hex(asc("a"))+hex(asc("s"))+hex(asc("s"))+hex(asc("."))+hex(asc("w"))) &" "

Response.Write HexTochinese("485454502F312E3120323030204F4B0D0A5365727665723A204D6963726F736F66742D4949532F352E300D0A446174653A204672692C2030392044656320323030352031303A30393A303820474D540D0A436F6E74656E742D4C656E6774683A20343735380D0A436F6E74656E742D547970653A20746578742F68746D6C0D0A43616368652D636F6E74726F6C3A20707269766174650D0A0D0A0D0A3C68746D6C3E0D0A3C686561643E")&" "

function getHex(s)
 dim tempstr
 tempstr=""
for k=1 to len(s)
 'Response.Write hex(asc(mid(s,k,1)))&" "
 tempstr=tempstr+ hex(asc(mid(s,k,1)))
next
getHex=tempstr
end function

Response.Write getHex("大幅度机")&" "

Response.Write HexTochinese("90ACC20BEB8B447CB855FCDE87970967")

md5.asp (包含javascript 和asp 两种加密)

<SCRIPT LANGUAGE=javascript>
<!--
/* MD5 Message-Digest Algorithm - JavaScript
' MODIFICATION HISTORY:
' 1.0 16-Feb-2001 - Phil Fresle (sales@frez.co.uk) - Initial Version (VB/ASP code)
' 1.0 21-Feb-2001 - Enrico Mosanghini (erik504@yahoo.com) - JavaScript porting
*/
function MD5(sMessage) {

function RotateLeft(lValue, iShiftBits) { return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits)); }

// Step 3. Initialise
a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
// Step 4. Process the message in 16-word blocks
for (k=0;k<x.length;k+=16) {
AA=a; BB=b; CC=c; DD=d;
a=FF(a,b,c,d,x[k+0], S11,0xD76AA478);
d=FF(d,a,b,c,x[k+1], S12,0xE8C7B756);
c=FF(c,d,a,b,x[k+2], S13,0x242070DB);
b=FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE);
a=FF(a,b,c,d,x[k+4], S11,0xF57C0FAF);
d=FF(d,a,b,c,x[k+5], S12,0x4787C62A);
c=FF(c,d,a,b,x[k+6], S13,0xA8304613);
b=FF(b,c,d,a,x[k+7], S14,0xFD469501);
a=FF(a,b,c,d,x[k+8], S11,0x698098D8);
d=FF(d,a,b,c,x[k+9], S12,0x8B44F7AF);
c=FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1);
b=FF(b,c,d,a,x[k+11],S14,0x895CD7BE);
a=FF(a,b,c,d,x[k+12],S11,0x6B901122);
d=FF(d,a,b,c,x[k+13],S12,0xFD987193);
c=FF(c,d,a,b,x[k+14],S13,0xA679438E);
b=FF(b,c,d,a,x[k+15],S14,0x49B40821);
a=GG(a,b,c,d,x[k+1], S21,0xF61E2562);
d=GG(d,a,b,c,x[k+6], S22,0xC040B340);
c=GG(c,d,a,b,x[k+11],S23,0x265E5A51);
b=GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA);
a=GG(a,b,c,d,x[k+5], S21,0xD62F105D);
d=GG(d,a,b,c,x[k+10],S22,0x2441453);
c=GG(c,d,a,b,x[k+15],S23,0xD8A1E681);
b=GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8);
a=GG(a,b,c,d,x[k+9], S21,0x21E1CDE6);
d=GG(d,a,b,c,x[k+14],S22,0xC33707D6);
c=GG(c,d,a,b,x[k+3], S23,0xF4D50D87);
b=GG(b,c,d,a,x[k+8], S24,0x455A14ED);
a=GG(a,b,c,d,x[k+13],S21,0xA9E3E905);
d=GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8);
c=GG(c,d,a,b,x[k+7], S23,0x676F02D9);
b=GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A);
a=HH(a,b,c,d,x[k+5], S31,0xFFFA3942);
d=HH(d,a,b,c,x[k+8], S32,0x8771F681);
c=HH(c,d,a,b,x[k+11],S33,0x6D9D6122);
b=HH(b,c,d,a,x[k+14],S34,0xFDE5380C);
a=HH(a,b,c,d,x[k+1], S31,0xA4BEEA44);
d=HH(d,a,b,c,x[k+4], S32,0x4BDECFA9);
c=HH(c,d,a,b,x[k+7], S33,0xF6BB4B60);
b=HH(b,c,d,a,x[k+10],S34,0xBEBFBC70);
a=HH(a,b,c,d,x[k+13],S31,0x289B7EC6);
d=HH(d,a,b,c,x[k+0], S32,0xEAA127FA);
c=HH(c,d,a,b,x[k+3], S33,0xD4EF3085);
b=HH(b,c,d,a,x[k+6], S34,0x4881D05);
a=HH(a,b,c,d,x[k+9], S31,0xD9D4D039);
d=HH(d,a,b,c,x[k+12],S32,0xE6DB99E5);
c=HH(c,d,a,b,x[k+15],S33,0x1FA27CF8);
b=HH(b,c,d,a,x[k+2], S34,0xC4AC5665);
a=II(a,b,c,d,x[k+0], S41,0xF4292244);
d=II(d,a,b,c,x[k+7], S42,0x432AFF97);
c=II(c,d,a,b,x[k+14],S43,0xAB9423A7);
b=II(b,c,d,a,x[k+5], S44,0xFC93A039);
a=II(a,b,c,d,x[k+12],S41,0x655B59C3);
d=II(d,a,b,c,x[k+3], S42,0x8F0CCC92);
c=II(c,d,a,b,x[k+10],S43,0xFFEFF47D);
b=II(b,c,d,a,x[k+1], S44,0x85845DD1);
a=II(a,b,c,d,x[k+8], S41,0x6FA87E4F);
d=II(d,a,b,c,x[k+15],S42,0xFE2CE6E0);
c=II(c,d,a,b,x[k+6], S43,0xA3014314);
b=II(b,c,d,a,x[k+13],S44,0x4E0811A1);
a=II(a,b,c,d,x[k+4], S41,0xF7537E82);
d=II(d,a,b,c,x[k+11],S42,0xBD3AF235);
c=II(c,d,a,b,x[k+2], S43,0x2AD7D2BB);
b=II(b,c,d,a,x[k+9], S44,0xEB86D391);
a=AddUnsigned(a,AA); b=AddUnsigned(b,BB); c=AddUnsigned(c,CC); d=AddUnsigned(d,DD);
}
// Step 5. Output the 128 bit digest
var temp= WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d);
alert(temp)
return temp.toLowerCase();

}

//MD5(31323334350000000000000000000074657374000000000000000000003133333030303030303031)

//-->
</SCRIPT>

dim s

function getHex(s)
    dim tempstr
    tempstr=""
for k=1 to len(s)
  tempstr=tempstr+ hex(asc(mid(s,k,1)))
next
getHex=tempstr
end function

Response.Write getHex("fdaf.wmv")

<%
Private Const BITS_TO_A_BYTE = 8
Private Const BYTES_TO_A_WORD = 4
Private Const BITS_TO_A_WORD = 32

Private m_lOnBits(30)
Private m_l2Power(30)

Private Function LShift(lValue, iShiftBits)
 If iShiftBits = 0 Then
 LShift = lValue
 Exit Function
 ElseIf iShiftBits = 31 Then
 If lValue And 1 Then
 LShift = &H80000000
 Else
 LShift = 0
 End If
 Exit Function
 ElseIf iShiftBits < 0 Or iShiftBits > 31 Then
 Err.Raise 6
 End If

    If (lValue And m_l2Power(31 - iShiftBits)) Then
        LShift = ((lValue And m_lOnBits(31 - (iShiftBits + 1))) * m_l2Power(iShiftBits)) Or &H80000000
    Else
        LShift = ((lValue And m_lOnBits(31 - iShiftBits)) * m_l2Power(iShiftBits))
    End If
End Function

Private Function RShift(lValue, iShiftBits)
 If iShiftBits = 0 Then
 RShift = lValue
 Exit Function
 ElseIf iShiftBits = 31 Then
 If lValue And &H80000000 Then
 RShift = 1
 Else
 RShift = 0
 End If
 Exit Function
 ElseIf iShiftBits < 0 Or iShiftBits > 31 Then
 Err.Raise 6
 End If

 RShift = (lValue And &H7FFFFFFE) \ m_l2Power(iShiftBits)

    If (lValue And &H80000000) Then
        RShift = (RShift Or (&H40000000 \ m_l2Power(iShiftBits - 1)))
    End If
End Function

Private Function RotateLeft(lValue, iShiftBits)
RotateLeft = LShift(lValue, iShiftBits) Or RShift(lValue, (32 - iShiftBits))
End Function

Private Function AddUnsigned(lX, lY)
    Dim lX4
    Dim lY4
    Dim lX8
    Dim lY8
    Dim lResult

    lX8 = lX And &H80000000
    lY8 = lY And &H80000000
    lX4 = lX And &H40000000
    lY4 = lY And &H40000000

    lResult = (lX And &H3FFFFFFF) + (lY And &H3FFFFFFF)

    If lX4 And lY4 Then
        lResult = lResult Xor &H80000000 Xor lX8 Xor lY8
    ElseIf lX4 Or lY4 Then
        If lResult And &H40000000 Then
            lResult = lResult Xor &HC0000000 Xor lX8 Xor lY8
        Else
            lResult = lResult Xor &H40000000 Xor lX8 Xor lY8
        End If
    Else
        lResult = lResult Xor lX8 Xor lY8
    End If

    AddUnsigned = lResult
End Function

Private Function md5_F(x, y, z)
md5_F = (x And y) Or ((Not x) And z)
End Function

Private Function md5_G(x, y, z)
md5_G = (x And z) Or (y And (Not z))
End Function

Private Function md5_H(x, y, z)
md5_H = (x Xor y Xor z)
End Function

Private Function md5_I(x, y, z)
md5_I = (y Xor (x Or (Not z)))
End Function

Private Sub md5_FF(a, b, c, d, x, s, ac)
    a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_F(b, c, d), x), ac))
    a = RotateLeft(a, s)
    a = AddUnsigned(a, b)
End Sub

Private Sub md5_GG(a, b, c, d, x, s, ac)
    a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_G(b, c, d), x), ac))
    a = RotateLeft(a, s)
    a = AddUnsigned(a, b)
End Sub

Private Sub md5_HH(a, b, c, d, x, s, ac)
    a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_H(b, c, d), x), ac))
    a = RotateLeft(a, s)
    a = AddUnsigned(a, b)
End Sub

Private Sub md5_II(a, b, c, d, x, s, ac)
    a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_I(b, c, d), x), ac))
    a = RotateLeft(a, s)
    a = AddUnsigned(a, b)
End Sub

Private Function ConvertToWordArray(sMessage)
    Dim lMessageLength
    Dim lNumberOfWords
    Dim lWordArray()
    Dim lBytePosition
    Dim lByteCount
    Dim lWordCount

    Const MODULUS_BITS = 512
    Const CONGRUENT_BITS = 448

    lMessageLength = Len(sMessage)

    lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) \ BITS_TO_A_BYTE)) \ (MODULUS_BITS \ BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS \ BITS_TO_A_WORD)
    ReDim lWordArray(lNumberOfWords - 1)

    lBytePosition = 0
    lByteCount = 0
    Do Until lByteCount >= lMessageLength
        lWordCount = lByteCount \ BYTES_TO_A_WORD
        lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE
        lWordArray(lWordCount) = lWordArray(lWordCount) Or LShift(Asc(Mid(sMessage, lByteCount + 1, 1)), lBytePosition)
        lByteCount = lByteCount + 1
    Loop

lWordCount = lByteCount \ BYTES_TO_A_WORD
lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE

lWordArray(lWordCount) = lWordArray(lWordCount) Or LShift(&H80, lBytePosition)

    lWordArray(lNumberOfWords - 2) = LShift(lMessageLength, 3)
    lWordArray(lNumberOfWords - 1) = RShift(lMessageLength, 29)

    ConvertToWordArray = lWordArray
End Function

Private Function WordToHex(lValue)
    Dim lByte
    Dim lCount

    For lCount = 0 To 3
        lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) And m_lOnBits(BITS_TO_A_BYTE - 1)
        WordToHex = WordToHex & Right("0" & Hex(lByte), 2)
    Next
End Function

Public Function MD5(sMessage)
    m_lOnBits(0) = CLng(1)
    m_lOnBits(1) = CLng(3)
    m_lOnBits(2) = CLng(7)
    m_lOnBits(3) = CLng(15)
    m_lOnBits(4) = CLng(31)
    m_lOnBits(5) = CLng(63)
    m_lOnBits(6) = CLng(127)
    m_lOnBits(7) = CLng(255)
    m_lOnBits(8) = CLng(511)
    m_lOnBits(9) = CLng(1023)
    m_lOnBits(10) = CLng(2047)
    m_lOnBits(11) = CLng(4095)
    m_lOnBits(12) = CLng(8191)
    m_lOnBits(13) = CLng(16383)
    m_lOnBits(14) = CLng(32767)
    m_lOnBits(15) = CLng(65535)
    m_lOnBits(16) = CLng(131071)
    m_lOnBits(17) = CLng(262143)
    m_lOnBits(18) = CLng(524287)
    m_lOnBits(19) = CLng(1048575)
    m_lOnBits(20) = CLng(2097151)
    m_lOnBits(21) = CLng(4194303)
    m_lOnBits(22) = CLng(8388607)
    m_lOnBits(23) = CLng(16777215)
    m_lOnBits(24) = CLng(33554431)
    m_lOnBits(25) = CLng(67108863)
    m_lOnBits(26) = CLng(134217727)
    m_lOnBits(27) = CLng(268435455)
    m_lOnBits(28) = CLng(536870911)
    m_lOnBits(29) = CLng(1073741823)
    m_lOnBits(30) = CLng(2147483647)

    m_l2Power(0) = CLng(1)
    m_l2Power(1) = CLng(2)
    m_l2Power(2) = CLng(4)
    m_l2Power(3) = CLng(8)
    m_l2Power(4) = CLng(16)
    m_l2Power(5) = CLng(32)
    m_l2Power(6) = CLng(64)
    m_l2Power(7) = CLng(128)
    m_l2Power(8) = CLng(256)
    m_l2Power(9) = CLng(512)
    m_l2Power(10) = CLng(1024)
    m_l2Power(11) = CLng(2048)
    m_l2Power(12) = CLng(4096)
    m_l2Power(13) = CLng(8192)
    m_l2Power(14) = CLng(16384)
    m_l2Power(15) = CLng(32768)
    m_l2Power(16) = CLng(65536)
    m_l2Power(17) = CLng(131072)
    m_l2Power(18) = CLng(262144)
    m_l2Power(19) = CLng(524288)
    m_l2Power(20) = CLng(1048576)
    m_l2Power(21) = CLng(2097152)
    m_l2Power(22) = CLng(4194304)
    m_l2Power(23) = CLng(8388608)
    m_l2Power(24) = CLng(16777216)
    m_l2Power(25) = CLng(33554432)
    m_l2Power(26) = CLng(67108864)
    m_l2Power(27) = CLng(134217728)
    m_l2Power(28) = CLng(268435456)
    m_l2Power(29) = CLng(536870912)
    m_l2Power(30) = CLng(1073741824)

    Dim x
    Dim k
    Dim AA
    Dim BB
    Dim CC
    Dim DD
    Dim a
    Dim b
    Dim c
    Dim d

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

x = ConvertToWordArray(sMessage)
'for p=0 to ubound(x)
' Response.Write "x("&p&")="&chr(34)&x(p)&chr(34)&" "
'next

    a = &H67452301
    b = &HEFCDAB89
    c = &H98BADCFE
    d = &H10325476

    For k = 0 To UBound(x) Step 16
        AA = a
        BB = b
        CC = c
        DD = d

        md5_FF a, b, c, d, x(k + 0), S11, &HD76AA478
        md5_FF d, a, b, c, x(k + 1), S12, &HE8C7B756
        md5_FF c, d, a, b, x(k + 2), S13, &H242070DB
        md5_FF b, c, d, a, x(k + 3), S14, &HC1BDCEEE
        md5_FF a, b, c, d, x(k + 4), S11, &HF57C0FAF
        md5_FF d, a, b, c, x(k + 5), S12, &H4787C62A
        md5_FF c, d, a, b, x(k + 6), S13, &HA8304613
        md5_FF b, c, d, a, x(k + 7), S14, &HFD469501
        md5_FF a, b, c, d, x(k + 8), S11, &H698098D8
        md5_FF d, a, b, c, x(k + 9), S12, &H8B44F7AF
        md5_FF c, d, a, b, x(k + 10), S13, &HFFFF5BB1
        md5_FF b, c, d, a, x(k + 11), S14, &H895CD7BE
        md5_FF a, b, c, d, x(k + 12), S11, &H6B901122
        md5_FF d, a, b, c, x(k + 13), S12, &HFD987193
        md5_FF c, d, a, b, x(k + 14), S13, &HA679438E
        md5_FF b, c, d, a, x(k + 15), S14, &H49B40821

        md5_GG a, b, c, d, x(k + 1), S21, &HF61E2562
        md5_GG d, a, b, c, x(k + 6), S22, &HC040B340
        md5_GG c, d, a, b, x(k + 11), S23, &H265E5A51
        md5_GG b, c, d, a, x(k + 0), S24, &HE9B6C7AA
        md5_GG a, b, c, d, x(k + 5), S21, &HD62F105D
        md5_GG d, a, b, c, x(k + 10), S22, &H2441453
        md5_GG c, d, a, b, x(k + 15), S23, &HD8A1E681
        md5_GG b, c, d, a, x(k + 4), S24, &HE7D3FBC8
        md5_GG a, b, c, d, x(k + 9), S21, &H21E1CDE6
        md5_GG d, a, b, c, x(k + 14), S22, &HC33707D6
        md5_GG c, d, a, b, x(k + 3), S23, &HF4D50D87
        md5_GG b, c, d, a, x(k + 8), S24, &H455A14ED
        md5_GG a, b, c, d, x(k + 13), S21, &HA9E3E905
        md5_GG d, a, b, c, x(k + 2), S22, &HFCEFA3F8
        md5_GG c, d, a, b, x(k + 7), S23, &H676F02D9
        md5_GG b, c, d, a, x(k + 12), S24, &H8D2A4C8A

        md5_HH a, b, c, d, x(k + 5), S31, &HFFFA3942
        md5_HH d, a, b, c, x(k + 8), S32, &H8771F681
        md5_HH c, d, a, b, x(k + 11), S33, &H6D9D6122
        md5_HH b, c, d, a, x(k + 14), S34, &HFDE5380C
        md5_HH a, b, c, d, x(k + 1), S31, &HA4BEEA44
        md5_HH d, a, b, c, x(k + 4), S32, &H4BDECFA9
        md5_HH c, d, a, b, x(k + 7), S33, &HF6BB4B60
        md5_HH b, c, d, a, x(k + 10), S34, &HBEBFBC70
        md5_HH a, b, c, d, x(k + 13), S31, &H289B7EC6
        md5_HH d, a, b, c, x(k + 0), S32, &HEAA127FA
        md5_HH c, d, a, b, x(k + 3), S33, &HD4EF3085
        md5_HH b, c, d, a, x(k + 6), S34, &H4881D05
        md5_HH a, b, c, d, x(k + 9), S31, &HD9D4D039
        md5_HH d, a, b, c, x(k + 12), S32, &HE6DB99E5
        md5_HH c, d, a, b, x(k + 15), S33, &H1FA27CF8
        md5_HH b, c, d, a, x(k + 2), S34, &HC4AC5665

        md5_II a, b, c, d, x(k + 0), S41, &HF4292244
        md5_II d, a, b, c, x(k + 7), S42, &H432AFF97
        md5_II c, d, a, b, x(k + 14), S43, &HAB9423A7
        md5_II b, c, d, a, x(k + 5), S44, &HFC93A039
        md5_II a, b, c, d, x(k + 12), S41, &H655B59C3
        md5_II d, a, b, c, x(k + 3), S42, &H8F0CCC92
        md5_II c, d, a, b, x(k + 10), S43, &HFFEFF47D
        md5_II b, c, d, a, x(k + 1), S44, &H85845DD1
        md5_II a, b, c, d, x(k + 8), S41, &H6FA87E4F
        md5_II d, a, b, c, x(k + 15), S42, &HFE2CE6E0
        md5_II c, d, a, b, x(k + 6), S43, &HA3014314
        md5_II b, c, d, a, x(k + 13), S44, &H4E0811A1
        md5_II a, b, c, d, x(k + 4), S41, &HF7537E82
        md5_II d, a, b, c, x(k + 11), S42, &HBD3AF235
        md5_II c, d, a, b, x(k + 2), S43, &H2AD7D2BB
        md5_II b, c, d, a, x(k + 9), S44, &HEB86D391

        a = AddUnsigned(a, AA)
        b = AddUnsigned(b, BB)
        c = AddUnsigned(c, CC)
        d = AddUnsigned(d, DD)
    Next

    'MD5 = LCase(WordToHex(a) & WordToHex(b) & WordToHex(c) & WordToHex(d))
    MD5=LCase(WordToHex(b) & WordToHex(c)) 'I crop this to fit 16byte database password :D
End Function

Response.write md5("31323334350000000000000000000074657374000000000000000000003133333030303030303031")
%>

阅读全文 | 回复(1) | 引用通告 | 编辑

上一篇：ASP获取上传图片的长宽
下一篇：JAVA 处理UTF8编码和中文字符

Re:base64加密解密 md5加密 asc ut8 hex转换

[ 2008-7-18 14:27:40 | By: dsfds(游客) ]

54c892de-2a64-4d46-af15-0aec11db3521

个人主页 | 引用 | 返回 | 删除 | 回复

发表评论：