frage zu zwei alten Purebasic Funktionen

[Neutrino]

Hallo *

ich habe hier einen sourcecode der mit einer älteren Purebasic version erstellt worden ist, vermutlich < 2.90 .

hier giebt es 2 Funktionen

CryptString() und DecrypString() anscheinend zum verschlüsseln von
strings, da ziemlich viele verschlüsselte Strings in dem code vorkommen und ich ihn gerne Kompatibel zu der neusten PB version machen will, lautet meine
frage was genau die beiden Funktionen machen bzw ob es ähnliche Funktionen in der neuen PB version giebt. Einträge wie zB

; "application/exe"
s.s = "115BA17F6B3557588CF6004F502AAF00"
Global RES_STRING_mimetype_exe$
RES_STRING_mimetype_exe$ = DecryptString(s,code$)

sind massenweise in dem code vorhanden.

vielen Dank im vorraus für die Hilfe

[D@nte]

Ich wag mal zu behaupten, dass es sich dabei nicht um PB interne Befehle handelt sondern um Prozeduren...
Da weder CryptString() noch DecryptString() in der PB Hilfe unter Geschichte erwähnt werden...

Genau gesagt scheint es sich dabei um die RC4-Lib zu handen...
Nach Suche im englischen Forum:

Code: Alles auswählen

; This example uses Paul's RC4 lib.
Debug CryptString("StringToBeEncrypted",pw$)
Debug DecryptString("AC814A672259E0C12334EE125139D616A964C200",pw$) 

[PureBasic4.0]

Wenn du was verschlüsseln willst, schau in der PB-Help nach oder nehm ne UserLib von PureArea.

Zum Strings ver/entschlüsseln:
Entweder intern Base64De/Encoder
oder von PureArea CaesarChifree

Ob es eine Lib für CaesarChifree gibt, weiß ich nicht. Hab's nur mal auf PureArea gesehen.

[jear]

@Neutrino

Diese Routinen emulieren die Lib von Paul Leischow.

Code: Alles auswählen

;- Umwandlung HEX-String zu Long (dezimal)
Procedure.l Hex2Dec(HexValue.s) 
  Protected x.s, i.w, l.w, n.l, result.l
  x = LCase(HexValue) : l = Len(x) 
  result = 0
  For i = 1 To l
    result * 16
    n = FindString("0123456789abcdef", Mid(x, i, 1), 1) - 1            
    result + n    
  Next i 
  ProcedureReturn result 
EndProcedure

;- RC4-Verschlüsselung
Procedure.l RC4_Mem(Mem.l, memLen.l, key.s) 
  Protected i.l, t.l, x.l, j.l, temp.l, y.l, l.l
  Protected *Sp.Long, *KeyP.Byte, *Memm.Byte 
  If key 
    Dim S.l(255) : Dim K.l(255) 
    j = 1 : l = Len(key) 
    *Sp = @S() : *KeyP = @key 
    For i = 0 To 255 
      *Sp\l = i : *Sp + 4 
      If *KeyP\b = 0 : *KeyP = @key : EndIf 
      K(i) = *KeyP\b : *KeyP+1 
    Next i 
    j = 0 
    For i = 0 To 255 
      j = (j + S(i) + K(i)) & 255 
      temp = S(i) : S(i) = S(j) 
      S(j) = temp 
    Next i 
    i = 0 : j = 0 : *Memm = Mem 
    For x = 0 To memLen -1 
      i = (i+1) & 255 : j = (j + S(i)) & 255 
      temp = S(i) : S(i) = S(j) : S(j) = temp 
      t = (S(i) + (S(j) & 255)) & 255 
      y = S(t) : *Memm\b ! y : *Memm + 1 
    Next 
  EndIf 
  ProcedureReturn Mem 
EndProcedure 

Procedure.s CryptString(String.s, key.s)
  Protected i.l, memLen.l, result.s, *Mem
  memLen = Len(String) 
  *Mem = AllocateMemory(memLen) 
  PokeS(*Mem, String, memLen)  
  RC4_Mem(*Mem, memLen, key)  
  result = "" 
  For i = 0 To memLen -1 
    result + RSet(Hex(PeekB(*Mem + i) & $FF), 2, "0") 
  Next  
  FreeMemory(*Mem)  
  ProcedureReturn result 
EndProcedure 

Procedure.s DecryptString(String.s, key.s)
  Protected i.l, l.l, b.l, a.s, *Mem
  l = Len(String)/2 : If l = 0 : ProcedureReturn : EndIf ; ===================>
  *Mem = AllocateMemory(l) 
  If *Mem = 0 : ProcedureReturn : EndIf                  ; ===================>  
  For i = 0 To l -1 
    a = Mid(String ,i*2 +1, 2) 
    b = Hex2Dec(a) : PokeB(*Mem+i, b) 
  Next  
  RC4_Mem(*Mem, l, key) : String = PeekS(*Mem, l)  
  FreeMemory(*Mem) 
  ProcedureReturn String 
EndProcedure 

key.s = "menetekel"
String.s = "Emulation von Paul Leischows RC4 Crypt/Decrypt"
Debug String

String = CryptString(String.s, key.s)
Debug String

String = DecryptString(String.s, key.s)
Debug String

[ts-soft]

@jear

Nur falls Du das öfters verwendest: Siehe Dir in der RC4 Routine die Zeilen
mit temp an, wenn Du da SWAP nimmst wirds richtig schnell