Bitrotation bzw. Verschlüsselungsroutine

[Karl]

Hallo,

habe mal eine kleine Bitrotationsproc geschrieben, bin mir aber sicher, dass das man in Assembler wesentlich leichter gestalten kann. Also her mit dem Code. Hier ist meiner:

Code: Alles auswählen

Procedure.c rotate(value.c, dir.c)
;rotieren von bits nach links (0) oder rechts (any)

Protected front.c, back.c

If dir=0
   ;nach links rotieren
   front = (value & $80) >> 7
   value = (value << 1) | front
Else
   ;nach rechts rotieren
   back = (value & $01) << 7
   value = (value >> 1) | back
EndIf

ProcedureReturn value

EndProcedure

Gruß Karl (PB4)

[Hellhound66]

Code: Alles auswählen

Macro _ROR(__LONG)
    !ROR [v_#__LONG#],1
    ; !MOV EAX,[v_#__LONG#]
    ; !ROR EAX,1
    ; !MOV [v_#__LONG#],EAX
EndMacro

Macro _ROL(__LONG)
    !ROL [v_#__LONG#],1
    ;!MOV EAX,[v_#__LONG#]
    ;!ROL EAX,1
    ;!MOV [v_#__LONG#],EAX
EndMacro

Global a.l = 1
_ROR(a)
Debug a
_ROL(a)
Debug a

Das könnte schonmal helfen.

[Karl]

Hallo Hellhound66,

wäre nett, wenn du mal kurz einen Kommentar dazu abgibst:

__LONG -> Variablenbezeichnung?

Variable immer im EAX-Register?

[v_#_LONG#] -> wofür steht das?

Was muss ich ändern, wenn ich eine Bitrotation für Char möchte?

Danke.

Gruß Karl

[Hellhound66]

Kein Problem.

Also __LONG ist die Variablenbezeichnung, das hast du richtig erkannt.
Die Geschichte mit dem EAX, also dass, was ich ausgeklammert hab, hab ich bewusst noch drin gelassen, weil ich ehrlich gesagt nicht wusste, ob die Befehle ROL/ROR bei jedem Prozessor mit einer "Variable" funktionieren. Das wäre die Notlösung.
PB übersetzt die Variablen mit v_VARIABLENNAME, es gibt noch mehr verschiedene Abkürzungen, für verschiedene Variablentypen. Ob das jetzt mit Chars geht, hab ich keine Ahnung, da heissts einfach ausprobieren. Wie die einzelnen Variablenüberstzungen zum Assemblercode heißen, weiss ich nicht auswendig, da muss dir hier ein anderer helfen.

/edit:
Und #__LONG# ist macrospzifisch, bevor ich das erklär, kannst du auch einfach in der Hilfe unter macros nachschauen, da ist das eigentlich ganz gut erklärt.

/edit2:
Mal abgesehen davon ist zum Glück noch keinem aufgefallen, dass ROL/ROR eine Rotation über das Carryflag machen und damit die macros so einfach gar nicht funktionieren können ^^.

[Helle]

ROL/ROR verändern keine Flags! Für Rotationsbefehle wären das RCL/RCR.

Gruss
Helle

[Hellhound66]

Natürlich hast du recht. Hab ich verwechselt.

[Karl]

Ha,

es ist so banal. Es genügt ROL/ROR var.c, [Anzahl].

Und ich mach mir so ´ne Rübe. Halt Mist, wenn man keine Ahnung von Assembler hat.

Vielen Dank nochmal.

Gruß Karl

[Edit]

Habe mal eine kleine Verschlüsselungsroutine daraus gebastelt:

Code: Alles auswählen

Procedure.s crypt(text.s, key.s, dir.b)
;Karl 05.10.2006
;Codieren durch Bitrotation nach links und XOR mit dem Schlüssel
;Decodieren durch XOR mit Schlüssel und Bitrotation nach rechts
;dir: decodieren (any) oder codieren (0)
   Protected char.c, zeichenKey.c, lang.l, pos.l, zeichen.c, i.l
   Protected msg.s
   
   If text And key
      lang = Len(key)
      For i=1 To Len(text)
         char = Asc(Mid(text,i,1))
         pos = (i-1) % lang + 1
         zeichenKey = Asc(Mid(key, pos, 1))
         ;eigentliche Codierung/Decodierung
         If dir = 0
            ROL char, 1
            MOV al, zeichenKey
            XOR al, char
            MOV zeichen, al
         Else
            MOV al, zeichenKey
            XOR al, char
            MOV zeichen, al
            ROR zeichen, 1
         EndIf
         msg = msg + Chr(zeichen)
      Next
    EndIf
         
   ProcedureReturn msg
EndProcedure

Der Charcode des Klartextes wird nach links rotiert und dann mit dem Schlüsselzeichen exklusiv verODERt.

Es ist ein einfacher Mechanismus, genügt aber für kleinere Geschichten, z. B. zum Verhindern, dass der Chef meine E-Mails liest

Gruß Karl