|
You last visited: Today at 04:53
Advertisement
DES Ent/Verschlüsseln
Discussion on DES Ent/Verschlüsseln within the AutoIt forum part of the Coders Den category.
01/10/2013, 16:59
|
#1
|
elite*gold: 256 
Join Date: Feb 2012
Posts: 1,370
Received Thanks: 2,918
|
DES Ent/Verschlüsseln
Ich habe keine Funktionierende Udf gefunden, welche mich eine in "DES" verschlüsselte Datei entschlüsseln lässt.
Da der key ein "00" Byte enthält, wäre es vorteilhaft, wenn sich der Key in Hex übergeben lässt.
Der DES Calculator auf  Seite funktioniert, jedoch ist die Funktion dafür nur in Python verfügbar.
Falls jemand was hat bitte Antworten.
Info:
Key: 6A68737375676900
Test Text: 28645876A48E189C
Ergebnis: 07002e5c64617461
|
|
|
|
01/10/2013, 17:12
|
#2
|
elite*gold: 528
Join Date: Jan 2012
Posts: 2,127
Received Thanks: 2,404
|
Hast du schon nach einer DLL gesucht?
Ich habe das hier gefunden:
"DES" scheint wohl nicht sehr weit verbreitet zu sein.
MfG
|
|
|
|
|
01/10/2013, 17:14
|
#3
|
elite*gold: 256
Join Date: Feb 2012
Posts: 1,370
Received Thanks: 2,918
|
Ok wobei ich allerdings nicht nach einer Tripple-Des Entschlüsselung gesucht habe ^^
|
|
|
|
|
01/10/2013, 17:21
|
#4
|
elite*gold: 528
Join Date: Jan 2012
Posts: 2,127
Received Thanks: 2,404
|
Ohne "tripple" 
Ist von 2005, vielleicht geht es ja noch.
MfG
|
|
|
|
|
01/10/2013, 22:32
|
#5
|
elite*gold: 256
Join Date: Feb 2012
Posts: 1,370
Received Thanks: 2,918
|
Ich gebs auf gibt nix das mir hilft.
Werd dann wohl den Scheiß Pythoncode in Autoit Übersetzen müssen...
Drecks Python.
|
|
|
|
|
01/10/2013, 23:07
|
#6
|
elite*gold: 528
Join Date: Jan 2012
Posts: 2,127
Received Thanks: 2,404
|
Python --> DLL
AutoIt --> DLLCall
geht nicht?
Du könntest die Webseite ja mit Packets benutzen, das wäre dann aber ziemlich langsam.
€dit:
Das ist doch ein Java Applet? Vlt kannst du das ja automatisieren.
€dit2:
Hier noch Möglichkeiten, was du tun könntest:
- Thread eröffnen im Forum.
- Thread eröffnen in
- Thread eröffnen im Forum
- "den Scheiß Pythoncode in Autoit Übersetzen" und dann hier eine UDF releasen.
MfG
|
|
|
|
|
01/11/2013, 12:36
|
#7
|
elite*gold: 2
Join Date: Jul 2009
Posts: 14,456
Received Thanks: 4,685
|
Quote:
Originally Posted by Crack-wtf
Da der key ein "00" Byte enthält, wäre es vorteilhaft, wenn sich der Key in Hex übergeben lässt.
|
Warum nicht Chr(00) ?
|
|
|
|
|
01/11/2013, 19:45
|
#8
|
elite*gold: 256
Join Date: Feb 2012
Posts: 1,370
Received Thanks: 2,918
|
Quote:
Originally Posted by Lawliet!
Warum nicht Chr(00) ?
|
Naja das wäre das kleinste Problem, aber mein Hauptproblem ist, dass ich keinen Weg finde mein Vorhaben zu Realisieren.
Keine Autoit DES Udf hat mir das Ergebnis geliefert, dass mir der Calculator auf im ersten Post erwähnten Seite liefert.
|
|
|
|
|
01/11/2013, 20:06
|
#9
|
elite*gold: 2
Join Date: Jul 2009
Posts: 14,456
Received Thanks: 4,685
|
Lad die eine native Dll, binde sie über FileInstall ein und nutz DllCall. Es gibt auch eine UDF im Dols direkt in den RAM zu laden, so hast du kein Tempfiles.
|
|
|
|
|
01/11/2013, 21:02
|
#10
|
elite*gold: 256
Join Date: Feb 2012
Posts: 1,370
Received Thanks: 2,918
|
Habe die Dll getestet, funktioniert aber nicht.
Returnt immer 0.
PHP Code:
#include <array.au3>
$test = DllCall(DllOpen("DESCrypt.dll"), "string;stdcall", "DeCrypt", "str", BinaryToString("0x28645876A48E189C"), "str", BinaryToString("0x6A68737375676900"))
_ArrayDisplay($test)
|
|
|
|
|
01/11/2013, 23:21
|
#11
|
elite*gold: 528
Join Date: Jan 2012
Posts: 2,127
Received Thanks: 2,404
|
Code:
DllCall(DllOpen("DESCrypt.dll")
$hDLL= Dllopen
Dllcall($hDll
So?
MfG
|
|
|
|
|
01/11/2013, 23:28
|
#12
|
elite*gold: 256
Join Date: Feb 2012
Posts: 1,370
Received Thanks: 2,918
|
Thats the same **** -.-
|
|
|
|
|
01/12/2013, 01:32
|
#13
|
elite*gold: 574
Join Date: Nov 2010
Posts: 2,498
Received Thanks: 726
|
Versuch es mal mit '$test[0]'
Quote:
If the function call fails then @error is set to 1. Otherwise an array is returned that contains the function return value and a copy of all the parameters (including parameters that the function may have modified when passed by reference).
$return[0] = function return value
$return[1] = param1
$return[2] = param2
...
$return[n] = paramn
|
http://www.autoitscript.com/autoit3/docs/functions/DllCall.htm
|
|
|
|
|
01/12/2013, 08:41
|
#14
|
elite*gold: 280
Join Date: May 2007
Posts: 2,818
Received Thanks: 3,483
|
gibts das ganze zb auch in php realisiert.
php und autoit sind sich so ähnlich, das eigentlich auch ein par einfache search und replaces ausreichen sollten, um den code in autoit zu konvertieren.
|
|
|
|
|
01/14/2013, 23:18
|
#15
|
elite*gold: 256
Join Date: Feb 2012
Posts: 1,370
Received Thanks: 2,918
|
Quote:
Originally Posted by Njahs
Versuch es mal mit '$test[0]'
http://www.autoitscript.com/autoit3/docs/functions/DllCall.htm
|
Ich nutze Arraydisplay, was anspringen sollte, sobald die Variable ein Array ist -.-
Quote:
Originally Posted by lolkop
gibts das ganze zb auch in php realisiert.
php und autoit sind sich so ähnlich, das eigentlich auch ein par einfache search und replaces ausreichen sollten, um den code in autoit zu konvertieren. |
Danke werds mir anschauen 
EDIT:
Habs jetzt damit probiert aber klappt nich 
Versteh einfach nich was das Problem ist >_<
PHP Code:
#include <Array.au3>
Local $key = "6A68737375676900"
Local $message = BinaryToString("0x28645876A48E189C")
Local $recovered_message = des($key, $message, 0, 1)
MsgBox(0,"",$recovered_message)
ConsoleWrite(@CRLF)
;===================================================================
; des
; this takes the key, the message, and whether to encrypt or decrypt
; Error Codes Returned:
; -1 : Incorrect Key Length (must be 16 or 48)
;===================================================================
Func des($key, $message, $encrypt, $mode = 0, $iv = '')
; declaring this locally speeds things up a bit
Local $spfunction1[64] = [0x1010400, 0, 0x10000, 0x1010404, 0x1010004, 0x10404, 0x4, 0x10000, 0x400, 0x1010400, 0x1010404, 0x400, 0x1000404, 0x1010004, 0x1000000, 0x4, 0x404, 0x1000400, 0x1000400, 0x10400, 0x10400, 0x1010000, 0x1010000, 0x1000404, 0x10004, 0x1000004, 0x1000004, 0x10004, 0, 0x404, 0x10404, 0x1000000, 0x10000, 0x1010404, 0x4, 0x1010000, 0x1010400, 0x1000000, 0x1000000, 0x400, 0x1010004, 0x10000, 0x10400, 0x1000004, 0x400, 0x4, 0x1000404, 0x10404, 0x1010404, 0x10004, 0x1010000, 0x1000404, 0x1000004, 0x404, 0x10404, 0x1010400, 0x404, 0x1000400, 0x1000400, 0, 0x10004, 0x10400, 0, 0x1010004]
Local $spfunction2[64] = [ -0x7fef7fe0, -0x7fff8000, 0x8000, 0x108020, 0x100000, 0x20, -0x7fefffe0, -0x7fff7fe0, -0x7fffffe0, -0x7fef7fe0, -0x7fef8000, -0x80000000, -0x7fff8000, 0x100000, 0x20, -0x7fefffe0, 0x108000, 0x100020, -0x7fff7fe0, 0, -0x80000000, 0x8000, 0x108020, -0x7ff00000, 0x100020, -0x7fffffe0, 0, 0x108000, 0x8020, -0x7fef8000, -0x7ff00000, 0x8020, 0, 0x108020, -0x7fefffe0, 0x100000, -0x7fff7fe0, -0x7ff00000, -0x7fef8000, 0x8000, -0x7ff00000, -0x7fff8000, 0x20, -0x7fef7fe0, 0x108020, 0x20, 0x8000, -0x80000000, 0x8020, -0x7fef8000, 0x100000, -0x7fffffe0, 0x100020, -0x7fff7fe0, -0x7fffffe0, 0x100020, 0x108000, 0, -0x7fff8000, 0x8020, -0x80000000, -0x7fefffe0, -0x7fef7fe0, 0x108000]
Local $spfunction3[64] = [0x208, 0x8020200, 0, 0x8020008, 0x8000200, 0, 0x20208, 0x8000200, 0x20008, 0x8000008, 0x8000008, 0x20000, 0x8020208, 0x20008, 0x8020000, 0x208, 0x8000000, 0x8, 0x8020200, 0x200, 0x20200, 0x8020000, 0x8020008, 0x20208, 0x8000208, 0x20200, 0x20000, 0x8000208, 0x8, 0x8020208, 0x200, 0x8000000, 0x8020200, 0x8000000, 0x20008, 0x208, 0x20000, 0x8020200, 0x8000200, 0, 0x200, 0x20008, 0x8020208, 0x8000200, 0x8000008, 0x200, 0, 0x8020008, 0x8000208, 0x20000, 0x8000000, 0x8020208, 0x8, 0x20208, 0x20200, 0x8000008, 0x8020000, 0x8000208, 0x208, 0x8020000, 0x20208, 0x8, 0x8020008, 0x20200]
Local $spfunction4[64] = [0x802001, 0x2081, 0x2081, 0x80, 0x802080, 0x800081, 0x800001, 0x2001, 0, 0x802000, 0x802000, 0x802081, 0x81, 0, 0x800080, 0x800001, 0x1, 0x2000, 0x800000, 0x802001, 0x80, 0x800000, 0x2001, 0x2080, 0x800081, 0x1, 0x2080, 0x800080, 0x2000, 0x802080, 0x802081, 0x81, 0x800080, 0x800001, 0x802000, 0x802081, 0x81, 0, 0, 0x802000, 0x2080, 0x800080, 0x800081, 0x1, 0x802001, 0x2081, 0x2081, 0x80, 0x802081, 0x81, 0x1, 0x2000, 0x800001, 0x2001, 0x802080, 0x800081, 0x2001, 0x2080, 0x800000, 0x802001, 0x80, 0x800000, 0x2000, 0x802080]
Local $spfunction5[64] = [0x100, 0x2080100, 0x2080000, 0x42000100, 0x80000, 0x100, 0x40000000, 0x2080000, 0x40080100, 0x80000, 0x2000100, 0x40080100, 0x42000100, 0x42080000, 0x80100, 0x40000000, 0x2000000, 0x40080000, 0x40080000, 0, 0x40000100, 0x42080100, 0x42080100, 0x2000100, 0x42080000, 0x40000100, 0, 0x42000000, 0x2080100, 0x2000000, 0x42000000, 0x80100, 0x80000, 0x42000100, 0x100, 0x2000000, 0x40000000, 0x2080000, 0x42000100, 0x40080100, 0x2000100, 0x40000000, 0x42080000, 0x2080100, 0x40080100, 0x100, 0x2000000, 0x42080000, 0x42080100, 0x80100, 0x42000000, 0x42080100, 0x2080000, 0, 0x40080000, 0x42000000, 0x80100, 0x2000100, 0x40000100, 0x80000, 0, 0x40080000, 0x2080100, 0x40000100]
Local $spfunction6[64] = [0x20000010, 0x20400000, 0x4000, 0x20404010, 0x20400000, 0x10, 0x20404010, 0x400000, 0x20004000, 0x404010, 0x400000, 0x20000010, 0x400010, 0x20004000, 0x20000000, 0x4010, 0, 0x400010, 0x20004010, 0x4000, 0x404000, 0x20004010, 0x10, 0x20400010, 0x20400010, 0, 0x404010, 0x20404000, 0x4010, 0x404000, 0x20404000, 0x20000000, 0x20004000, 0x10, 0x20400010, 0x404000, 0x20404010, 0x400000, 0x4010, 0x20000010, 0x400000, 0x20004000, 0x20000000, 0x4010, 0x20000010, 0x20404010, 0x404000, 0x20400000, 0x404010, 0x20404000, 0, 0x20400010, 0x10, 0x4000, 0x20400000, 0x404010, 0x4000, 0x400010, 0x20004010, 0, 0x20404000, 0x20000000, 0x400010, 0x20004010]
Local $spfunction7[64] = [0x200000, 0x4200002, 0x4000802, 0, 0x800, 0x4000802, 0x200802, 0x4200800, 0x4200802, 0x200000, 0, 0x4000002, 0x2, 0x4000000, 0x4200002, 0x802, 0x4000800, 0x200802, 0x200002, 0x4000800, 0x4000002, 0x4200000, 0x4200800, 0x200002, 0x4200000, 0x800, 0x802, 0x4200802, 0x200800, 0x2, 0x4000000, 0x200800, 0x4000000, 0x200800, 0x200000, 0x4000802, 0x4000802, 0x4200002, 0x4200002, 0x2, 0x200002, 0x4000000, 0x4000800, 0x200000, 0x4200800, 0x802, 0x200802, 0x4200800, 0x802, 0x4000002, 0x4200802, 0x4200000, 0x200800, 0, 0x2, 0x4200802, 0, 0x200802, 0x4200000, 0x800, 0x4000002, 0x4000800, 0x800, 0x200002]
Local $spfunction8[64] = [0x10001040, 0x1000, 0x40000, 0x10041040, 0x10000000, 0x10001040, 0x40, 0x10000000, 0x40040, 0x10040000, 0x10041040, 0x41000, 0x10041000, 0x41040, 0x1000, 0x40, 0x10040000, 0x10000040, 0x10001000, 0x1040, 0x41000, 0x40040, 0x10040040, 0x10041000, 0x1040, 0, 0, 0x10040040, 0x10000040, 0x10001000, 0x41040, 0x40000, 0x41040, 0x40000, 0x10041000, 0x1000, 0x40, 0x10040040, 0x1000, 0x41040, 0x10001000, 0x40, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x40000, 0x10001040, 0, 0x10041040, 0x40040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0, 0x10041040, 0x41000, 0x41000, 0x1040, 0x1040, 0x40040, 0x10000000, 0x10041000]
Local $masks[33] = [4294967295, 2147483647, 1073741823, 536870911, 268435455, 134217727, 67108863, 33554431, 16777215, 8388607, 4194303, 2097151, 1048575, 524287, 262143, 131071, 65535, 32767, 16383, 8191, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0]
Local $fill
; create the 16 or 48 subkeys we will need
$keys = des_createKeys($key)
If @error == 1 Then
SetError(-1)
Return 0
EndIf
$m = 0
$chunk = 0
; set up the loops for single and triple des
If UBound($keys) == 32 Then
Local $iterations = 3
Else
Local $iterations = 9
EndIf
If ($iterations == 3) Then
If $encrypt == 1 Then
Local $looping[3] = [0, 32, 2]
Else
Local $looping[3] = [30, -2, -2]
EndIf
Else
If $encrypt == 1 Then
Local $looping[9] = [0, 32, 2, 62, 30, -2, 64, 96, 2]
Else
Local $looping[9] = [94, 62, -2, 32, 64, 2, 30, -2, -2]
EndIf
EndIf
If $encrypt == 1 Then
$fill = 8
If Mod(StringLen($message), 8) <> 0 Then
$fill = 8 - Mod(StringLen($message), 8)
EndIf
For $i = 1 To $fill
$message &= Chr($fill)
Next
EndIf
$len = StringLen($message)
; store the result here
$result = ""
$tempresult = ""
If ($mode == 1) Then ; CBC mode
$cbcleft = BitOR(BitShift(Asc(StringMid($iv, 1, 1)), -24), BitShift(Asc(StringMid($iv, 2, 1)), -16), BitShift(Asc(StringMid($iv, 3, 1)), -8), Asc(StringMid($iv, 4, 1)))
$cbcright = BitOR(BitShift(Asc(StringMid($iv, 5, 1)), -24), BitShift(Asc(StringMid($iv, 6, 1)), -16), BitShift(Asc(StringMid($iv, 7, 1)), -8), Asc(StringMid($iv, 8, 1)))
EndIf
; loop through each 64 bit chunk of the message
While $m < $len
$left = BitOR(BitShift(Asc(StringMid($message, $m + 1, 1)), -24), BitShift(Asc(StringMid($message, $m + 2, 1)), -16), BitShift(Asc(StringMid($message, $m + 3, 1)), -8), Asc(StringMid($message, $m + 4, 1)))
$right = BitOR(BitShift(Asc(StringMid($message, $m + 5, 1)), -24), BitShift(Asc(StringMid($message, $m + 6, 1)), -16), BitShift(Asc(StringMid($message, $m + 7, 1)), -8), Asc(StringMid($message, $m + 8, 1)))
$m += 8
; for Cipher Block Chaining mode, xor the message with the previous result
If $mode == 1 Then
If $encrypt Then
$left = BitXOR($left, $cbcleft)
$right = BitXOR($right, $cbcright)
Else
$cbcleft2 = $cbcleft
$cbcright2 = $cbcright
$cbcleft = $left
$cbcright = $right
EndIf
EndIf
; first each 64 but chunk of the message must be permuted according to IP
$temp = BitAND(BitXOR(BitAND(BitShift($left, 4), $masks[4]), $right), 0x0f0f0f0f)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -4))
$temp = BitAND(BitXOR(BitAND(BitShift($left, 16), $masks[16]), $right), 0x0000ffff)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -16))
$temp = BitAND(BitXOR(BitAND(BitShift($right, 2), $masks[2]), $left), 0x33333333)
$left = BitXOR($left, $temp)
$right = BitXOR($right, BitShift($temp, -2))
$temp = BitAND(BitXOR(BitAND(BitShift($right, 8), $masks[8]), $left), 0x00ff00ff)
$left = BitXOR($left, $temp)
$right = BitXOR($right, BitShift($temp, -8))
$temp = BitAND(BitXOR(BitAND(BitShift($left, 1), $masks[1]), $right), 0x55555555)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -1))
$left = BitOR(BitShift($left, -1), BitAND(BitShift($left, 31), $masks[31]))
$right = BitOR(BitShift($right, -1), BitAND(BitShift($right, 31), $masks[31]))
; do this either 1 or 3 times for each chunk of the message
For $j = 0 To $iterations - 1 Step 3
$endloop = $looping[$j + 1]
$loopinc = $looping[$j + 2]
; now go through and perform the encryption or decryption
$i = $looping[$j]
While $i <> $endloop ; for efficiency
$right1 = BitXOR($right, $keys[$i])
$right2 = BitXOR(BitOR(BitAND(BitShift($right, 4), $masks[4]), BitShift($right, -28)), $keys[$i + 1])
; the result is attained by passing these bytes through the S selection functions
$temp = $left
$left = $right
$right = BitXOR($temp, BitOR($spfunction2[BitAND(BitAND(BitShift($right1, 24), $masks[24]), 0x3f) ], $spfunction4[BitAND(BitAND(BitShift($right1, 16), $masks[16]), 0x3f) ], $spfunction6[BitAND(BitAND(BitShift($right1, 8), $masks[8]), 0x3f) ], $spfunction8[BitAND($right1, 0x3f) ], $spfunction1[BitAND(BitAND(BitShift($right2, 24), $masks[24]), 0x3f) ], $spfunction3[BitAND(BitAND(BitShift($right2, 16), $masks[16]), 0x3f) ], $spfunction5[BitAND(BitAND(BitShift($right2, 8), $masks[8]), 0x3f) ], $spfunction7[BitAND($right2, 0x3f) ]))
$i += $loopinc
WEnd
; unreverse left and right
$temp = $left
$left = $right
$right = $temp
Next ; for either 1 or 3 iterations
; move then each one bit to the right
$left = BitOR(BitAND(BitShift($left, 1), $masks[1]), BitShift($left, -31))
$right = BitOR(BitAND(BitShift($right, 1), $masks[1]), BitShift($right, -31))
; now perform IP-1, which is IP in the opposite direction
$temp = BitAND(BitXOR(BitAND(BitShift($left, 1), $masks[1]), $right), 0x55555555)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -1))
$temp = BitAND(BitXOR(BitAND(BitShift($right, 8), $masks[8]), $left), 0x00ff00ff)
$left = BitXOR($left, $temp)
$right = BitXOR($right, BitShift($temp, -8))
$temp = BitAND(BitXOR(BitAND(BitShift($right, 2), $masks[2]), $left), 0x33333333)
$left = BitXOR($left, $temp)
$right = BitXOR($right, BitShift($temp, -2))
$temp = BitAND(BitXOR(BitAND(BitShift($left, 16), $masks[16]), $right), 0x0000ffff)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -16))
$temp = BitAND(BitXOR(BitAND(BitShift($left, 4), $masks[4]), $right), 0x0f0f0f0f)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -4))
; for Cipher Block Chaining mode, xor the message with the previous result
If $mode == 1 Then
If $encrypt == 1 Then
$cbcleft = $left
$cbcright = $right
Else
$left = BitXOR($left, $cbcleft2)
$right = BitXOR($right, $cbcright2)
EndIf
EndIf
$tempresult &= Chr(BitAND(BitShift($left, 24), $masks[24]))
$tempresult &= Chr(BitAND(BitAND(BitShift($left, 16), $masks[16]), 0xff))
$tempresult &= Chr(BitAND(BitAND(BitShift($left, 8), $masks[8]), 0xff))
$tempresult &= Chr(BitAND($left, 0xff))
$tempresult &= Chr(BitAND(BitShift($right, 24), $masks[24]))
$tempresult &= Chr(BitAND(BitAND(BitShift($right, 16), $masks[16]), 0xff))
$tempresult &= Chr(BitAND(BitAND(BitShift($right, 8), $masks[8]), 0xff))
$tempresult &= Chr(BitAND($right, 0xff))
$chunk += 8
If $chunk == 512 Then
$result &= $tempresult
$tempresult = ""
$chunk = 0
EndIf
WEnd ; for every 8 characters, or 64 bits in the message
$result &= $tempresult
If $encrypt == 0 Then
$fill = Asc(StringRight($result, 1))
$result = StringTrimRight($result, $fill)
EndIf
Return $result
EndFunc ;==>des
; des_createKeys
; this takes as input a 64 bit key (even though only 56 bits are used)
; as an array of 2 integers, and returns 16 48 bit keys
Func des_createKeys($key)
; declaring this locally speeds things up a bit
Local $pc2bytes0[16] = [0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000, 0x20010004, 0x200, 0x204, 0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200, 0x20010204]
Local $pc2bytes1[16] = [0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000, 0x4100001, 0x100, 0x101, 0x100100, 0x100101, 0x4000100, 0x4000101, 0x4100100, 0x4100101]
Local $pc2bytes2[16] = [0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808, 0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808]
Local $pc2bytes3[16] = [0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000, 0x8202000, 0x20000, 0x220000, 0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000, 0x8222000]
Local $pc2bytes4[16] = [0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000, 0x41000, 0x1010, 0x41010, 0x1000, 0x41000, 0x1010, 0x41010]
Local $pc2bytes5[16] = [0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400, 0x2000020, 0x2000420, 0x2000000, 0x2000400, 0x2000020, 0x2000420]
Local $pc2bytes6[16] = [0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002, 0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002]
Local $pc2bytes7[16] = [0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800, 0x20010800, 0x20000, 0x30000, 0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800, 0x20030800]
Local $pc2bytes8[16] = [0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000, 0x2040000, 0x2000000, 0x2040000, 0x2000002, 0x2040002, 0x2000002, 0x2040002]
Local $pc2bytes9[16] = [0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008, 0x400, 0x10000400, 0x408, 0x10000408, 0x400, 0x10000400, 0x408, 0x10000408]
Local $pc2bytes10[16] = [0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000, 0x2020, 0x2000, 0x2020, 0x102000, 0x102020, 0x102000, 0x102020]
Local $pc2bytes11[16] = [0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200, 0x1200200, 0x4000000, 0x5000000, 0x4000200, 0x5000200, 0x4200000, 0x5200000, 0x4200200, 0x5200200]
Local $pc2bytes12[16] = [0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000, 0x8081000, 0x10, 0x1010, 0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010]
Local $pc2bytes13[16] = [0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101, 0x105, 0x1, 0x5, 0x101, 0x105]
Local $masks[33] = [4294967295, 2147483647, 1073741823, 536870911, 268435455, 134217727, 67108863, 33554431, 16777215, 8388607, 4194303, 2097151, 1048575, 524287, 262143, 131071, 65535, 32767, 16383, 8191, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0]
; how many iterations (1 for des, 3 for triple des)
If StringLen($key) == 48 Then
Local $iterations = 3
ElseIf StringLen($key) == 16 Then
Local $iterations = 1
Else
SetError(1)
Return 0
EndIf
; stores the return keys
Local $keys[32 * $iterations]
; now define the left shifts which need to be done
Local $shifts[16] = [0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0]
; other variables
Local $lefttemp, $righttemp, $m = 0, $n = 0, $temp
For $j = 1 To $iterations ; either 1 or 3 iterations
$left = BitOR(BitShift(Dec(StringMid($key, $m + 1, 2)), -24), BitShift(Dec(StringMid($key, $m + 3, 2)), -16), BitShift(Dec(StringMid($key, $m + 5, 2)), -8), Dec(StringMid($key, $m + 7, 2)))
$right = BitOR(BitShift(Dec(StringMid($key, $m + 9, 2)), -24), BitShift(Dec(StringMid($key, $m + 11, 2)), -16), BitShift(Dec(StringMid($key, $m + 13, 2)), -8), Dec(StringMid($key, $m + 15, 2)))
$m += 16
$temp = BitAND(BitXOR(BitAND(BitShift($left, 4), $masks[4]), $right), 0x0f0f0f0f)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -4))
$temp = BitAND(BitXOR(BitAND(BitShift($right, 16), $masks[16]), $left), 0x0000ffff)
$left = BitXOR($left, $temp)
$right = BitXOR($right, BitShift($temp, -16))
$temp = BitAND(BitXOR(BitAND(BitShift($left, 2), $masks[2]), $right), 0x33333333)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -2))
$temp = BitAND(BitXOR(BitAND(BitShift($right, 16), $masks[16]), $left), 0x0000ffff)
$left = BitXOR($left, $temp)
$right = BitXOR($right, BitShift($temp, -16))
$temp = BitAND(BitXOR(BitAND(BitShift($left, 1), $masks[1]), $right), 0x55555555)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -1))
$temp = BitAND(BitXOR(BitAND(BitShift($right, 8), $masks[8]), $left), 0x00ff00ff)
$left = BitXOR($left, $temp)
$right = BitXOR($right, BitShift($temp, -8))
$temp = BitAND(BitXOR(BitAND(BitShift($left, 1), $masks[1]), $right), 0x55555555)
$right = BitXOR($right, $temp)
$left = BitXOR($left, BitShift($temp, -1))
; the right side needs to be shifted and to get the last four bits of the left side
$temp = BitOR(BitShift($left, -8), BitAND(BitAND(BitShift($right, 20), $masks[20]), 0x000000f0))
; left needs to be put upside down
$left = BitOR(BitShift($right, -24), BitAND(BitShift($right, -8), 0xff0000), BitAND(BitAND(BitShift($right, 8), $masks[8]), 0xff00), BitAND(BitAND(BitShift($right, 24), $masks[24]), 0xf0))
$right = $temp
; now go through and perform these shifts on the left and right keys
For $i = 0 To UBound($shifts) - 1
; shift the keys either one or two bits to the left
If $shifts[$i] == 1 Then
$left = BitOR(BitShift($left, -2), BitAND(BitShift($left, 26), $masks[26]))
$right = BitOR(BitShift($right, -2), BitAND(BitShift($right, 26), $masks[26]))
Else
$left = BitOR(BitShift($left, -1), BitAND(BitShift($left, 27), $masks[27]))
$right = BitOR(BitShift($right, -1), BitAND(BitShift($right, 27), $masks[27]))
EndIf
$left = BitAND($left, -0xf)
$right = BitAND($right, -0xf)
; now apply PC-2, in such a way that E is easier when encrypting or decrypting
; this conversion will look like PC-2 except only the last 6 bits of each byte are used
; rather than 48 consecutive bits and the order of lines will be according to
; how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7
$lefttemp = BitOR($pc2bytes0[BitAND(BitShift($left, 28), $masks[28]) ], $pc2bytes1[BitAND(BitAND(BitShift($left, 24), $masks[24]), 0xf) ], $pc2bytes2[BitAND(BitAND(BitShift($left, 20), $masks[20]), 0xf) ], $pc2bytes3[BitAND(BitAND(BitShift($left, 16), $masks[16]), 0xf) ], $pc2bytes4[BitAND(BitAND(BitShift($left, 12), $masks[12]), 0xf) ], $pc2bytes5[BitAND(BitAND(BitShift($left, 8), $masks[8]), 0xf) ], $pc2bytes6[BitAND(BitAND(BitShift($left, 4), $masks[4]), 0xf) ])
$righttemp = BitOR($pc2bytes7[BitAND(BitShift($right, 28), $masks[28]) ], $pc2bytes8[BitAND(BitAND(BitShift($right, 24), $masks[24]), 0xf) ], $pc2bytes9[BitAND(BitAND(BitShift($right, 20), $masks[20]), 0xf) ], $pc2bytes10[BitAND(BitAND(BitShift($right, 16), $masks[16]), 0xf) ], $pc2bytes11[BitAND(BitAND(BitShift($right, 12), $masks[12]), 0xf) ], $pc2bytes12[BitAND(BitAND(BitShift($right, 8), $masks[8]), 0xf) ], $pc2bytes13[BitAND(BitAND(BitShift($right, 4), $masks[4]), 0xf) ])
$temp = BitAND(BitXOR(BitAND(BitShift($righttemp, 16), $masks[16]), $lefttemp), 0x0000ffff)
$keys[$n] = BitXOR($lefttemp, $temp)
$keys[$n + 1] = BitXOR($righttemp, BitShift($temp, -16))
$n += 2
Next
Next ; for each iterations
; return the keys we've created
Return $keys
EndFunc ;==>des_createKeys
Func stringToHex($s)
Dim $result = "0x"
Dim $temp = StringSplit($s, "")
For $i = 1 To $temp[0]
$result &= Hex(Asc($temp[$i]), 2)
Next
Return $result
EndFunc ;==>stringToHex
|
|
|
|
 |
Similar Threads
|
Verschlüsseln?
01/14/2012 - Metin2 Private Server - 2 Replies
Hab ne frage wie verschlüsselt mann Pack datein epk und eix datein ?
|
Verschlüsseln
04/17/2011 - Metin2 Private Server - 0 Replies
Guten Abend,
lassen sich Metin2 P Server Dateien mit MD5 Verschlüsseln oder nur mit dem Verschlüsseler von Tim?
Es wäre gut, wenn ich heute schon alles verschlüsselt hätte.
Danke im voraus.
MfG netterwurm8
|
*.txt verschlüsseln
03/20/2011 - Main - 7 Replies
hey com,
ich habe mal eine frage,
kann ich *.txt, also editor dateien irgendwie verschlüsseln?
also ncih nicht verschlüsseln, sondern so machen, das man sie öffnet,
alles sieht, aber trotzdem nichts ändern kann??
weil habe keine lust davon eine PDF zumachen!
naja, wenns nich anders geht, mach ich es hald,
aber hof auf ne antwort :)
|
epk eix verschlüsseln?
11/25/2010 - Metin2 Private Server - 6 Replies
hey com,ist es möglich die epk und eix so zu verschlüsseln das der 2010er client sie lesen kann aber mir keiner in meinen datein rumpfuschen kann? also sie nicht entpacken kann?
|
verschlüsseln
05/12/2008 - Kal Online - 0 Replies
also ich hab das pw von unity v2 herausgefunden und will jetzt die jobsystem-e datei wechseln also lösch ich die eine und tuh die neue rein muss jetzt noch die neue verschlüseln aber das klappt nicht ich hab schon viele sachenn gedownloaded und probiert die verschlüsseln alle aber das klappt trotztdem nie.deswegen wollt ich fragen wie ich es verschlüsseln soll.mit winrar verschlüsselt das garnet wen ich probiere.hab das jobsystem-e von zogga benutz der hat hier ma ein tut geschrieben.
und das...
|
All times are GMT +2. The time now is 04:53.
|
|
