加密解密问题-『提问交流』-AUTOIT CN

botanycc 发表于 2010-3-18 15:57:46

加密解密问题

我把密码设置在*.ini文件中，如何将密码加密过存入*.ini文件，读取ini文件时，自动解密读取，要不然打开ini文件就看到密码了。

afan 发表于 2010-3-18 16:11:37

_StringEncrypt()

botanycc 发表于 2010-3-18 16:53:09

不太会弄，能举个简单例子吗，1.ini
写入

1=

读取
$a = IniRead ( "1.ini", "tt", "1", "" )
If $a <>'' Then
MsgBox('','',$a )
Else
MsgBox('','','NotFound')
EndIf

谢谢:face (7):

lpxx 发表于 2010-3-18 17:05:02

搜索了一下，不知改的对不对，你可以参考一下。#include <md5.au3>
#include <GUIConstants.au3>
Const $Path = @ScriptDir & "\config.ini"
Dim $Pass
Dim $MD5Pass
$read = IniRead($Path, "config", "Pass", $Pass)
If $read = "" Then
$Pass = InputBox("这是第一次", "请尝试输入任意字符，他将写入脚本目录config.ini文件，然后再次运行脚本查看结果", "", "*")
$MD5Pass = md5 ($Pass)
IniWrite($Path, "config", "Pass", $Pass)
IniWrite($Path, "config", "MD5Pass", $MD5Pass)
Else
$Pass = InputBox("这是第二次", "请输入你刚才设置的字符", "", "*")
$MD5Pass = IniRead($Path, "config", "md5pass", $MD5Pass)
If md5 ($Pass) = $MD5Pass Then
;Run('notepad.exe')
MsgBox(0, "不加密的结果", $Pass, 3)
MsgBox(0, "MD5加密后的结果", $MD5Pass, 3)
Else
MsgBox(0, "检查结果", "不对啊，3秒后程序将自动退出", 3)
Exit
EndIf
EndIf需要的md5文件可以搜索论坛，也可以用下面的。Const $BITS_TO_A_BYTE= 8
Const $BYTES_TO_A_WORD = 4
Const $BITS_TO_A_WORD= $BYTES_TO_A_WORD * $BITS_TO_A_BYTE

Dim $m_lOnBits
Dim $m_l2Power

Func Class_Initialize()

$m_lOnBits = 1          ; 00000000000000000000000000000001
$m_lOnBits = 3          ; 00000000000000000000000000000011
$m_lOnBits = 7          ; 00000000000000000000000000000111
$m_lOnBits = 15       ; 00000000000000000000000000001111
$m_lOnBits = 31       ; 00000000000000000000000000011111
$m_lOnBits = 63       ; 00000000000000000000000000111111
$m_lOnBits = 127       ; 00000000000000000000000001111111
$m_lOnBits = 255       ; 00000000000000000000000011111111
$m_lOnBits = 511       ; 00000000000000000000000111111111
$m_lOnBits = 1023       ; 00000000000000000000001111111111
$m_lOnBits = 2047    ; 00000000000000000000011111111111
$m_lOnBits = 4095    ; 00000000000000000000111111111111
$m_lOnBits = 8191    ; 00000000000000000001111111111111
$m_lOnBits = 16383    ; 00000000000000000011111111111111
$m_lOnBits = 32767    ; 00000000000000000111111111111111
$m_lOnBits = 65535    ; 00000000000000001111111111111111
$m_lOnBits = 131071    ; 00000000000000011111111111111111
$m_lOnBits = 262143    ; 00000000000000111111111111111111
$m_lOnBits = 524287    ; 00000000000001111111111111111111
$m_lOnBits = 1048575 ; 00000000000011111111111111111111
$m_lOnBits = 2097151 ; 00000000000111111111111111111111
$m_lOnBits = 4194303 ; 00000000001111111111111111111111
$m_lOnBits = 8388607 ; 00000000011111111111111111111111
$m_lOnBits = 16777215 ; 00000000111111111111111111111111
$m_lOnBits = 33554431 ; 00000001111111111111111111111111
$m_lOnBits = 67108863 ; 00000011111111111111111111111111
$m_lOnBits = 134217727 ; 00000111111111111111111111111111
$m_lOnBits = 268435455 ; 00001111111111111111111111111111
$m_lOnBits = 536870911 ; 00011111111111111111111111111111
$m_lOnBits = 1073741823; 00111111111111111111111111111111
$m_lOnBits = 2147483647; 01111111111111111111111111111111

$m_l2Power = 1          ; 00000000000000000000000000000001
$m_l2Power = 2          ; 00000000000000000000000000000010
$m_l2Power = 4          ; 00000000000000000000000000000100
$m_l2Power = 8          ; 00000000000000000000000000001000
$m_l2Power = 16       ; 00000000000000000000000000010000
$m_l2Power = 32       ; 00000000000000000000000000100000
$m_l2Power = 64       ; 00000000000000000000000001000000
$m_l2Power = 128       ; 00000000000000000000000010000000
$m_l2Power = 256       ; 00000000000000000000000100000000
$m_l2Power = 512       ; 00000000000000000000001000000000
$m_l2Power = 1024    ; 00000000000000000000010000000000
$m_l2Power = 2048    ; 00000000000000000000100000000000
$m_l2Power = 4096    ; 00000000000000000001000000000000
$m_l2Power = 8192    ; 00000000000000000010000000000000
$m_l2Power = 16384    ; 00000000000000000100000000000000
$m_l2Power = 32768    ; 00000000000000001000000000000000
$m_l2Power = 65536    ; 00000000000000010000000000000000
$m_l2Power = 131072    ; 00000000000000100000000000000000
$m_l2Power = 262144    ; 00000000000001000000000000000000
$m_l2Power = 524288    ; 00000000000010000000000000000000
$m_l2Power = 1048576 ; 00000000000100000000000000000000
$m_l2Power = 2097152 ; 00000000001000000000000000000000
$m_l2Power = 4194304 ; 00000000010000000000000000000000
$m_l2Power = 8388608 ; 00000000100000000000000000000000
$m_l2Power = 16777216 ; 00000001000000000000000000000000
$m_l2Power = 33554432 ; 00000010000000000000000000000000
$m_l2Power = 67108864 ; 00000100000000000000000000000000
$m_l2Power = 134217728 ; 00001000000000000000000000000000
$m_l2Power = 268435456 ; 00010000000000000000000000000000
$m_l2Power = 536870912 ; 00100000000000000000000000000000
$m_l2Power = 1073741824; 01000000000000000000000000000000
EndFunc

Func LShift($lValue,$iShiftBits)

If $iShiftBits = 0 Then
   Return $lValue


ElseIf $iShiftBits = 31 Then
   If BitAND($lValue, 1) Then
         Return 0x80000000
   Else
         Return 0
   Endif



ElseIf $iShiftBits < 0 Or $iShiftBits > 31 Then
   SetError(6)
Endif

If BitAND($lValue, $m_l2Power) Then


   Return BitOR((BitAND($lValue, $m_lOnBits) * _
         $m_l2Power[$iShiftBits]) , 0x80000000)

Else

   Return (BitAND($lValue, $m_lOnBits) * _
         $m_l2Power[$iShiftBits])

Endif
EndFunc

Func RShift($lValue, $iShiftBits)

Local $RShift

If $iShiftBits = 0 Then
   Return $lValue


ElseIf $iShiftBits = 31 Then
   If BitAND($lValue, 0x80000000) Then
         Return 1
   Else
         Return 0
   Endif


ElseIf $iShiftBits < 0 Or $iShiftBits > 31 Then
   SetError(6)
Endif

$RShift = int(BitAND($lValue, 0x7FFFFFFE) / $m_l2Power[$iShiftBits])

If BitAND($lValue, 0x80000000) Then

   $RShift = int(BitOR($RShift, (0x40000000 / $m_l2Power[$iShiftBits - 1])))
Endif

Return $RShift

EndFunc

Func RShiftSigned($lValue , $iShiftBits)

If $iShiftBits = 0 Then
   Return $lValue

ElseIf $iShiftBits = 31 Then

   If BitAND($lValue, 0x80000000) Then
         Return -1
   Else
         Return 0
   Endif

ElseIf $iShiftBits < 0 Or $iShiftBits > 31 Then
   SetError(6)
Endif

Return Int($lValue / $m_l2Power[$iShiftBits])
EndFunc

Func RotateLeft($lValue , $iShiftBits)
Return BitOR(LShift($lValue, $iShiftBits), RShift($lValue, (32 - $iShiftBits)))
EndFunc

Func AddUnsigned($lX , $lY )

$lX8 = BitAND($lX, 0x80000000)
$lY8 = BitAND($lY, 0x80000000)
$lX4 = BitAND($lX, 0x40000000)
$lY4 = BitAND($lY, 0x40000000)

$lResult = BitAND($lX, 0x3FFFFFFF) + BitAND($lY, 0x3FFFFFFF)

If BitAND($lX4, $lY4) Then
   $lResult = BitXOR($lResult, 0x80000000, $lX8, $lY8)
ElseIf BitOR($lX4 , $lY4) Then
   If BitAND($lResult, 0x40000000) Then
         $lResult = BitXOR($lResult, 0xC0000000, $lX8, $lY8)
   Else
         $lResult = BitXOR($lResult, 0x40000000, $lX8, $lY8)
   Endif
Else
   $lResult = BitXOR($lResult, $lX8, $lY8)
Endif

Return $lResult
EndFunc

Func F($x , $y , $z )
Return BitOR(BitAND($x, $y) , BitAND((BitNOT($x)), $z))
EndFunc

Func G($x , $y , $z )
Return BitOR(BitAND($x, $z) , BitAND($y , (BitNOT($z))))
EndFunc

Func H($x , $y , $z )
Return BitXOR($x , $y , $z)
EndFunc

Func I($x , $y , $z )
Return BitXOR($y , BitOR($x , (BitNOT($z))))
EndFunc

Func FF(ByRef $a , $b , $c , $d , $x , $s , $ac )
$a = AddUnsigned($a, AddUnsigned(AddUnsigned(F($b, $c, $d), $x), $ac))
$a = RotateLeft($a, $s)
$a = AddUnsigned($a, $b)
EndFunc

Func GG(ByRef $a , $b , $c , $d , $x , $s , $ac )
$a = AddUnsigned($a, AddUnsigned(AddUnsigned(G($b, $c, $d), $x), $ac))
$a = RotateLeft($a, $s)
$a = AddUnsigned($a, $b)
EndFunc

Func HH(ByRef $a , $b , $c , $d , $x , $s , $ac )
$a = AddUnsigned($a, AddUnsigned(AddUnsigned(H($b, $c, $d), $x), $ac))
$a = RotateLeft($a, $s)
$a = AddUnsigned($a, $b)
EndFunc

Func II(ByRef $a , $b , $c , $d , $x , $s , $ac )
$a = AddUnsigned($a, AddUnsigned(AddUnsigned(I($b, $c, $d), $x), $ac))
$a = RotateLeft($a, $s)
$a = AddUnsigned($a, $b)
EndFunc

Func ConvertToWordArray($sMessage )
Dim $lWordArray

Const $MODULUS_BITS = 512
Const $CONGRUENT_BITS = 448

$lMessageLength = StringLen($sMessage)

   $lNumberOfWords = (int(($lMessageLength + _
   int(($MODULUS_BITS - $CONGRUENT_BITS) / $BITS_TO_A_BYTE)) / _
   int($MODULUS_BITS / $BITS_TO_A_BYTE)) + 1) * _
   int($MODULUS_BITS / $BITS_TO_A_WORD)
ReDim $lWordArray[$lNumberOfWords]

$lBytePosition = 0
$lByteCount = 0
Do

   $lWordCount = int($lByteCount / $BYTES_TO_A_WORD)


   $lBytePosition = (Mod($lByteCount , $BYTES_TO_A_WORD)) * $BITS_TO_A_BYTE
   $lWordArray[$lWordCount] = BitOR($lWordArray[$lWordCount] , _
         LShift(Asc(StringMid($sMessage, $lByteCount + 1, 1)), $lBytePosition))
   $lByteCount = $lByteCount + 1
Until $lByteCount >= $lMessageLength

$lWordCount = int($lByteCount / $BYTES_TO_A_WORD)
$lBytePosition = (Mod($lByteCount , $BYTES_TO_A_WORD)) * $BITS_TO_A_BYTE

$lWordArray[$lWordCount] = BitOR($lWordArray[$lWordCount] , _
   LShift(0x80, $lBytePosition))

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

Return $lWordArray
EndFunc

Func WordToHex($lValue)

$WordToHex=""

For $lCount = 0 To 3
   $lByte = BitAND(RShift($lValue, $lCount * $BITS_TO_A_BYTE) , _
         $m_lOnBits[$BITS_TO_A_BYTE - 1])
   $WordToHex = $WordToHex & StringRight("0" & Hex($lByte,2), 2)
Next
Return $WordToHex
EndFunc

Func MD5($sMessage)

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

Class_Initialize()

$x = ConvertToWordArray($sMessage)

$a = 0x67452301
$b = 0xEFCDAB89
$c = 0x98BADCFE
$d = 0x10325476

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


   FF( $a, $b, $c, $d, $x[$k + 0], $S11, 0xD76AA478 )
   FF( $d, $a, $b, $c, $x[$k + 1], $S12, 0xE8C7B756 )
   FF( $c, $d, $a, $b, $x[$k + 2], $S13, 0x242070DB )
   FF( $b, $c, $d, $a, $x[$k + 3], $S14, 0xC1BDCEEE )
   FF( $a, $b, $c, $d, $x[$k + 4], $S11, 0xF57C0FAF )
   FF( $d, $a, $b, $c, $x[$k + 5], $S12, 0x4787C62A )
   FF( $c, $d, $a, $b, $x[$k + 6], $S13, 0xA8304613 )
   FF( $b, $c, $d, $a, $x[$k + 7], $S14, 0xFD469501 )
   FF( $a, $b, $c, $d, $x[$k + 8], $S11, 0x698098D8 )
   FF( $d, $a, $b, $c, $x[$k + 9], $S12, 0x8B44F7AF )
   FF( $c, $d, $a, $b, $x[$k + 10], $S13, 0xFFFF5BB1)
   FF( $b, $c, $d, $a, $x[$k + 11], $S14, 0x895CD7BE)
   FF( $a, $b, $c, $d, $x[$k + 12], $S11, 0x6B901122)
   FF( $d, $a, $b, $c, $x[$k + 13], $S12, 0xFD987193)
   FF( $c, $d, $a, $b, $x[$k + 14], $S13, 0xA679438E)
   FF( $b, $c, $d, $a, $x[$k + 15], $S14, 0x49B40821)

   GG( $a, $b, $c, $d, $x[$k + 1], $S21, 0xF61E2562 )
   GG( $d, $a, $b, $c, $x[$k + 6], $S22, 0xC040B340 )
   GG( $c, $d, $a, $b, $x[$k + 11], $S23, 0x265E5A51)
   GG( $b, $c, $d, $a, $x[$k + 0], $S24, 0xE9B6C7AA )
   GG( $a, $b, $c, $d, $x[$k + 5], $S21, 0xD62F105D )
   GG( $d, $a, $b, $c, $x[$k + 10], $S22, 0x2441453 )
   GG( $c, $d, $a, $b, $x[$k + 15], $S23, 0xD8A1E681)
   GG( $b, $c, $d, $a, $x[$k + 4], $S24, 0xE7D3FBC8 )
   GG( $a, $b, $c, $d, $x[$k + 9], $S21, 0x21E1CDE6 )
   GG( $d, $a, $b, $c, $x[$k + 14], $S22, 0xC33707D6)
   GG( $c, $d, $a, $b, $x[$k + 3], $S23, 0xF4D50D87 )
   GG( $b, $c, $d, $a, $x[$k + 8], $S24, 0x455A14ED )
   GG( $a, $b, $c, $d, $x[$k + 13], $S21, 0xA9E3E905)
   GG( $d, $a, $b, $c, $x[$k + 2], $S22, 0xFCEFA3F8 )
   GG( $c, $d, $a, $b, $x[$k + 7], $S23, 0x676F02D9 )
   GG( $b, $c, $d, $a, $x[$k + 12], $S24, 0x8D2A4C8A)

   HH( $a, $b, $c, $d, $x[$k + 5], $S31, 0xFFFA3942 )
   HH( $d, $a, $b, $c, $x[$k + 8], $S32, 0x8771F681 )
   HH( $c, $d, $a, $b, $x[$k + 11], $S33, 0x6D9D6122)
   HH( $b, $c, $d, $a, $x[$k + 14], $S34, 0xFDE5380C)
   HH( $a, $b, $c, $d, $x[$k + 1], $S31, 0xA4BEEA44 )
   HH( $d, $a, $b, $c, $x[$k + 4], $S32, 0x4BDECFA9 )
   HH( $c, $d, $a, $b, $x[$k + 7], $S33, 0xF6BB4B60 )
   HH( $b, $c, $d, $a, $x[$k + 10], $S34, 0xBEBFBC70)
   HH( $a, $b, $c, $d, $x[$k + 13], $S31, 0x289B7EC6)
   HH( $d, $a, $b, $c, $x[$k + 0], $S32, 0xEAA127FA )
   HH( $c, $d, $a, $b, $x[$k + 3], $S33, 0xD4EF3085 )
   HH( $b, $c, $d, $a, $x[$k + 6], $S34, 0x4881D05)
   HH( $a, $b, $c, $d, $x[$k + 9], $S31, 0xD9D4D039 )
   HH( $d, $a, $b, $c, $x[$k + 12], $S32, 0xE6DB99E5)
   HH( $c, $d, $a, $b, $x[$k + 15], $S33, 0x1FA27CF8)
   HH( $b, $c, $d, $a, $x[$k + 2], $S34, 0xC4AC5665 )

   II( $a, $b, $c, $d, $x[$k + 0], $S41, 0xF4292244 )
   II( $d, $a, $b, $c, $x[$k + 7], $S42, 0x432AFF97 )
   II( $c, $d, $a, $b, $x[$k + 14], $S43, 0xAB9423A7)
   II( $b, $c, $d, $a, $x[$k + 5], $S44, 0xFC93A039 )
   II( $a, $b, $c, $d, $x[$k + 12], $S41, 0x655B59C3)
   II( $d, $a, $b, $c, $x[$k + 3], $S42, 0x8F0CCC92 )
   II( $c, $d, $a, $b, $x[$k + 10], $S43, 0xFFEFF47D)
   II( $b, $c, $d, $a, $x[$k + 1], $S44, 0x85845DD1 )
   II( $a, $b, $c, $d, $x[$k + 8], $S41, 0x6FA87E4F )
   II( $d, $a, $b, $c, $x[$k + 15], $S42, 0xFE2CE6E0)
   II( $c, $d, $a, $b, $x[$k + 6], $S43, 0xA3014314 )
   II( $b, $c, $d, $a, $x[$k + 13], $S44, 0x4E0811A1)
   II( $a, $b, $c, $d, $x[$k + 4], $S41, 0xF7537E82 )
   II( $d, $a, $b, $c, $x[$k + 11], $S42, 0xBD3AF235)
   II( $c, $d, $a, $b, $x[$k + 2], $S43, 0x2AD7D2BB )
   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)
Next

Return StringLower(WordToHex($a) & WordToHex($b) & WordToHex($c) & WordToHex($d))
EndFunc

botanycc 发表于 2010-3-18 20:41:32

真是太棒了，谢谢

rikthhpgf2005 发表于 2010-3-18 20:43:55

:face (20):哦哦~~~~

水木子 发表于 2010-3-18 21:16:49

本帖最后由水木子于 2010-3-18 21:22 编辑

如何将密码加密过存入*.ini文件，读取ini文件时，自动解密读取。
botanycc 发表于 2010-3-18 15:57 http://www.autoitx.com/images/common/back.gif
MD5？不是说不可以逆的吗？
既然不可逆，那怎么解呢？有点疑惑！

水木子 发表于 2010-3-18 21:37:07

刚刚读了一遍4楼代码的意思，大概明白是怎么回事了。
不可逆，但是可以对比，将第2次输入的字符加密后对比第1次的加密字符就可以了，妙！

afan 发表于 2010-3-18 21:38:32

Md5实质上应该是不可逆的，因此也应该只能做核对使用~ 所以对LZ的要求自动读取解密Md5是不适合的
4#的例子这样改下就好理解了#include <md5.au3>
#include <GUIConstants.au3>
Const $Path = @ScriptDir & "\config.ini"
Dim $Pass
$read = IniRead($Path, "config", "Pass", $Pass)
If $read = "" Then
$Pass = InputBox("这是第一次", "请尝试输入任意字符，他将写入脚本目录config.ini文件，然后再次运行脚本查看结果", "", "*")
$MD5Pass = md5($Pass)
IniWrite($Path, "config", "Pass", $MD5Pass)
Else
$Pass = InputBox("这是第二次", "请输入你刚才设置的字符", "", "*")
$MD5Pass = IniRead($Path, "config", "Pass", '')
If md5($Pass) = $MD5Pass Then
;Run('notepad.exe')
MsgBox(0, "检查结果", '正确', 3)
Else
MsgBox(0, "检查结果", "不对啊，3秒后程序将自动退出", 3)
EndIf
EndIf

lpxx 发表于 2010-3-18 22:43:04

玩笑开大了。
代码是我搜索论坛改的，非原创，我没那能耐写出来。
其次，md5算法本身“不可逆”，但是可以靠字典穷举。
不过，我用的md5.au3算法为公版，未改过。
要是改过算法，那么字典就没有意义了。
名气比较大的md5查询网站：http://www.cmd5.com
以下是我查询结果：
密文:2055f89f98f52de5feb79de61fa36e6b
密文加密类型: MD5
查询结果：autoit

lxz 发表于 2010-3-18 23:19:46

学习中！！

botanycc 发表于 2010-3-19 21:39:44

回复 8# 水木子

是的，通过对比来模拟解密。

页: [1]

AUTOIT CN's Archiver

加密解密问题