PureBoard

Das deutsche PureBasic-Forum
https://www.purebasic.fr/german/

AES-verschlüsselung

https://www.purebasic.fr/german/viewtopic.php?t=15057

Seite 3 von 4

Verfasst: 14.12.2007 15:47
von onny
Danke Helle!
Leider versteh ichs noch nicht ganz (schon garnicht ASM xD), wo ist da der INPUT, also dass, was verschlüsselt werden soll? Oo

Verfasst: 14.12.2007 16:00
von hardfalcon
Ich hab den Code mal so angepasst, dass er auch unter Linux Läuft (einfach die DataSection zwischen DataSection und EndDataSection gesetzt, und das ASM-Konstrukt am Beginn der DataSection entfernt).

//EDIT: Hab die DataSection für nicht-ASMler noch etwas leserlicher und verständlicher gemacht, sowie die Inverse SBox zur Entschlüsselung eingefügt. Die SBoxen hab ich dabei aus diesem Code kopiert:
http://homepage.ruhr-uni-bochum.de/Florian.Feldmann/AES Layout.asm

//EDIT2: Data.c durch Data.b ersetzt (kommt letztlich auf das Gleiche raus)

//EDIT3: ASM-Sprungmarken soweit wie möglich durch PB-Sprungmarken ersetzt. Kann mir jemand sagen, was der Block ganz am Ende des Codes (alles unter RoundKey:) genau macht, und wie man den mit reinem PB-code ohne Inline-ASM umsetzten könnte? Da steig ich mit meinen nicht vorhandenen ASM-Kenntnissen nämlich absolut nicht durch... :?

Code: Alles auswählen

;- AES-Rijndael-Encryption-Test, Textblock-und Keyword-Länge jeweils 128 Bit 
 ;- "Helle" Klaus Helbing, 13.12.2007, PB4.10 
 ;- Ohne Gewähr! Lässt sich bestimmt noch optimieren 
 
 Global Array1.l 
 Global Array2.l 
   
 Array1=AllocateMemory(16)              ;für (Zwischen-)Ergebnisse, so auch wegen einfache 
 Array2=AllocateMemory(16)              ; Zugriffs-Möglichkeit für PB (Anzeige) 
 
 ;- RoundKeys ermitteln 
 ;- RoundKey1, Ergebnis steht in RoundKey 
 !lea edi,[l_cipherkey] 
 !mov eax,[edi+12] 
 !ror eax,8 
 
 !lea edi,[l_roundkey] 
 !lea esi,[l_sbox] 
 !xor ebx,ebx 
 !mov ecx,4 
 !@@: 
 !mov bl,al 
 !mov dl,[esi+ebx] 
 !mov [edi],dl 
 !shr eax,8 
 !inc edi 
 !dec ecx 
 !jnz @b 
 
 !lea esi,[l_roundkey] 
 !lea edi,[l_cipherkey] 
 !lea edx,[l_rcon] 
 !mov eax,[edi] 
 !xor [esi],eax 
 !mov ebx,[edx] 
 !xor [esi],ebx               ;1.DWord von RoundKey1 
 
 !mov edx,[esi] 
 !mov eax,[edi+4] 
 !xor eax,edx 
 !mov [esi+4],eax             ;2.DWord von RoundKey1 
 
 !xor eax,[edi+8] 
 !mov [esi+8],eax             ;3.DWord von RoundKey1 
 
 !xor eax,[edi+12] 
 !mov [esi+12],eax            ;4.DWord von RoundKey1 
 ;- Ende RoundKey1 
 
 ;- RoundKey2 - RoundKey10 
 !mov [Schleife1],9 
 !RoundKeys: 
 !add [RConZ],4 
 !ror eax,8 
 !lea esi,[l_sbox] 
 !mov ecx,4 
 !@@: 
 !mov ebx,eax 
 !and ebx,0ffh 
 !mov dl,[esi+ebx] 
 !dec ecx 
 !jz @f 
 !shl edx,8 
 !shr eax,8 
 !jmp @b 
 !@@: 
 !bswap edx 
 !lea edi,[l_roundkey]          
 !add edi,[Round]             ;1.DWord vom "VorKey" 
 !mov eax,[edi] 
 !xor eax,edx 
 !lea esi,[l_rcon] 
 !add esi,[RConZ] 
 !xor eax,[esi] 
 !add edi,16                  ;hier soll abgespeichert werden 
 !mov [edi],eax 
 !add edi,4 
 !xor eax,[edi-16] 
 !mov [edi],eax               ;2.DWord 
 !add edi,4 
 !xor eax,[edi-16] 
 !mov [edi],eax               ;3.DWord     Fehler beim Uru in RoundKey2 (Schreib-Fehler)! 
 !add edi,4 
 !xor eax,[edi-16] 
 !mov [edi],eax               ;4.DWord 
 !add [Round],16 
 !dec [Schleife1] 
 !jnz RoundKeys 
 ;- Ende RoundKey2 - RoundKey10 
 
 ;- 1.Schritt State XOR Cipher Key ----- 
 ;- Ergebnis steht in Array1 
 !mov edi,[v_Array1] 
 !lea esi,[l_state] 
 !mov ecx,4 
 !@@: 
 !mov eax,[esi] 
 !xor eax,[esi+16] 
 !mov [edi],eax 
 !add edi,4 
 !add esi,4 
 !dec ecx 
 !jnz @b 
 ;-------------------------------------- 
 
 !mov [Round],0               ;für Schleife unten 
 !Schleife: 
 
 ;- 2.Schritt Werte aus S-Box holen ---- 
 ;- Ergebnis steht in Array1 
 !mov edi,[v_Array1] 
 !lea esi,[l_sbox] 
 !xor ebx,ebx 
 !mov edx,4 
 !S0: 
 !mov ecx,4 
 !@@: 
 !mov bl,[edi] 
 !mov al,[esi+ebx] 
 !mov [edi],al 
 !inc edi 
 !dec ecx 
 !jnz @b 
 !dec edx 
 !jnz S0 
 ;-------------------------------------- 
 
 ;- 3.Schritt Rotationen --------------- 
 ;- Ergebnis steht in Array1 
 !mov esi,[v_Array1] 
 !mov ecx,8 
 !Rotat: 
 !inc esi 
 !mov edx,12 
 !@@: 
 !mov al,[esi+edx] 
 !sub edx,4 
 !jc @f 
 !shl eax,8 
 !jmp @b 
 !@@: 
 !ror eax,cl 
 !xor edx,edx 
 !@@: 
 !mov [esi+edx],al 
 !add edx,4 
 !cmp edx,16 
 !je @f 
 !shr eax,8 
 !jmp @b 
 !@@: 
 !add ecx,8 
 !cmp ecx,24 
 !jbe Rotat 
 ;-------------------------------------- 
 
 ;- 4.Schritt Mix-Columns -------------- 
 ;- Ergebnis steht in Array2 
 !cmp [Round],144 
 !jne @f 
 !mov edi,[v_Array1] 
 !jmp NoMix                   ;letzte Runde nicht 
 !@@: 
 !mov esi,[v_Array1] 
 !mov edi,[v_Array2] 
 !mov [Schleife2],4 
 !Mix2: 
 !mov ebx,[esi] 
 !mov [Schleife1],4 
 !Mix1: 
 !xor eax,eax 
 !mov ecx,eax 
 !mov edx,ebx 
 
 !shl dl,1 
 !jnc @f  
 !xor dl,1bh  
 !@@:  
 !ror ebx,8 
 !mov al,bl 
 !shl ax,1 
 !mov cl,bl 
 !xor ax,cx 
 !or ah,ah 
 !je @f  
 !xor al,1bh  
 !@@:  
 !xor al,dl 
 !ror ebx,8 
 !xor al,bl 
 !ror ebx,8 
 !xor al,bl 
 !mov [edi],al 
 !inc edi 
 !ror ebx,16 
 !dec [Schleife1] 
 !jnz Mix1 
 
 !add esi,4 
 !dec [Schleife2] 
 !jnz Mix2 
 ;-------------------------------------- 
 
 ;- 5.Schritt AddRoundKey -------------- 
 ;- Ergebnis steht in Array1 für Schleife 
 !mov edi,[v_Array2] 
 !NoMix: 
 !mov ebx,[v_Array1] 
 !lea esi,[l_roundkey] 
 !add esi,[Round] 
 !mov ecx,4 
 !@@: 
 !mov eax,[esi] 
 !mov edx,[edi] 
 !xor eax,edx 
 !mov [ebx],eax 
 !add ebx,4 
 !add edi,4 
 !add esi,4 
 !dec ecx 
 !jnz @b 
 
 !add [Round],16 ;Zeiger in RoundKey 
 !cmp [Round],160 
 !jne Schleife 
 ;-------------------------------------- 
 
 ;- Anzeige des Ergebnisses 
 For k=0 To 15 
   X.c=PeekB(Array1+k) 
   X$=Hex(X) 
   Erg$+RSet(X$,2,"0") 
 Next 
 
 MessageRequester("AES-Rijndael-Encryption-Test", "Die verschlüsselten 16 Bytes lauten : "+Erg$) 
 
 End 
 
 ;-------- 
DataSection
  State:
  ;16 Bytes des zu verschlüsselnden Textes 
  Data.c $32, $43, $F6, $A8, $88, $5A, $30, $8D, $31, $31, $98, $A2, $E0, $37, $07, $34 
 
  CipherKey:
  ;das Passwort (16 Bytes) 
  ; Voräufiger Testschlüssel aus den offiziellen Spezifikationen
  Data.c $2b, $7e, $15, $16, $28, $ae, $d2, $a6, $ab, $f7, $15, $88, $09, $cf, $4f, $3c

  SBox:
  ; S-Box für AES-Encryption
  ;       0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f
  Data.b $63, $7c, $77, $7b, $f2, $6b, $6f, $c5, $30, $01, $67, $2b, $fe, $d7, $ab, $76 ; 0
  Data.b $ca, $82, $c9, $7d, $fa, $59, $47, $f0, $ad, $d4, $a2, $af, $9c, $a4, $72, $c0 ; 1
  Data.b $b7, $fd, $93, $26, $36, $3f, $f7, $cc, $34, $a5, $e5, $f1, $71, $d8, $31, $15 ; 2
  Data.b $04, $c7, $23, $c3, $18, $96, $05, $9a, $07, $12, $80, $e2, $eb, $27, $b2, $75 ; 3
  Data.b $09, $83, $2c, $1a, $1b, $6e, $5a, $a0, $52, $3b, $d6, $b3, $29, $e3, $2f, $84 ; 4
  Data.b $53, $d1, $00, $ed, $20, $fc, $b1, $5b, $6a, $cb, $be, $39, $4a, $4c, $58, $cf ; 5
  Data.b $d0, $ef, $aa, $fb, $43, $4d, $33, $85, $45, $f9, $02, $7f, $50, $3c, $9f, $a8 ; 6
  Data.b $51, $a3, $40, $8f, $92, $9d, $38, $f5, $bc, $b6, $da, $21, $10, $ff, $f3, $d2 ; 7
  Data.b $cd, $0c, $13, $ec, $5f, $97, $44, $17, $c4, $a7, $7e, $3d, $64, $5d, $19, $73 ; 8
  Data.b $60, $81, $4f, $dc, $22, $2a, $90, $88, $46, $ee, $b8, $14, $de, $5e, $0b, $db ; 9
  Data.b $e0, $32, $3a, $0a, $49, $06, $24, $5c, $c2, $d3, $ac, $62, $91, $95, $e4, $79 ; a
  Data.b $e7, $c8, $37, $6d, $8d, $d5, $4e, $a9, $6c, $56, $f4, $ea, $65, $7a, $ae, $08 ; b
  Data.b $ba, $78, $25, $2e, $1c, $a6, $b4, $c6, $e8, $dd, $74, $1f, $4b, $bd, $8b, $8a ; c
  Data.b $70, $3e, $b5, $66, $48, $03, $f6, $0e, $61, $35, $57, $b9, $86, $c1, $1d, $9e ; d
  Data.b $e1, $f8, $98, $11, $69, $d9, $8e, $94, $9b, $1e, $87, $e9, $ce, $55, $28, $df ; e
  Data.b $8c, $a1, $89, $0d, $bf, $e6, $42, $68, $41, $99, $2d, $0f, $b0, $54, $bb, $16 ; f
  
  InvSBox:
  ; Inverse S-Box für AES-Decryption
  ;       0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f
  Data.b $52, $09, $6a, $d5, $30, $36, $a5, $38, $bf, $40, $a3, $9e, $81, $f3, $d7, $fb ; 0
  Data.b $7c, $e3, $39, $82, $9b, $2f, $ff, $87, $34, $8e, $43, $44, $c4, $de, $e9, $cb ; 1
  Data.b $54, $7b, $94, $32, $a6, $c2, $23, $3d, $ee, $4c, $95, $0b, $42, $fa, $c3, $4e ; 2
  Data.b $08, $2e, $a1, $66, $28, $d9, $24, $b2, $76, $5b, $a2, $49, $6d, $8b, $d1, $25 ; 3
  Data.b $72, $f8, $f6, $64, $86, $68, $98, $16, $d4, $a4, $5c, $cc, $5d, $65, $b6, $92 ; 4
  Data.b $6c, $70, $48, $50, $fd, $ed, $b9, $da, $5e, $15, $46, $57, $a7, $8d, $9d, $84 ; 5
  Data.b $90, $d8, $ab, $00, $8c, $bc, $d3, $0a, $f7, $e4, $58, $05, $b8, $b3, $45, $06 ; 6
  Data.b $d0, $2c, $1e, $8f, $ca, $3f, $0f, $02, $c1, $af, $bd, $03, $01, $13, $8a, $6b ; 7
  Data.b $3a, $91, $11, $41, $4f, $67, $dc, $ea, $97, $f2, $cf, $ce, $f0, $b4, $e6, $73 ; 8
  Data.b $96, $ac, $74, $22, $e7, $ad, $35, $85, $e2, $f9, $37, $e8, $1c, $75, $df, $6e ; 9
  Data.b $47, $f1, $1a, $71, $1d, $29, $c5, $89, $6f, $b7, $62, $0e, $aa, $18, $be, $1b ; a
  Data.b $fc, $56, $3e, $4b, $c6, $d2, $79, $20, $9a, $db, $c0, $fe, $78, $cd, $5a, $f4 ; b
  Data.b $1f, $dd, $a8, $33, $88, $07, $c7, $31, $b1, $12, $10, $59, $27, $80, $ec, $5f ; c
  Data.b $60, $51, $7f, $a9, $19, $b5, $4a, $0d, $2d, $e5, $7a, $9f, $93, $c9, $9c, $ef ; d
  Data.b $a0, $e0, $3b, $4d, $ae, $2a, $f5, $b0, $c8, $eb, $bb, $3c, $83, $53, $99, $61 ; e
  Data.b $17, $2b, $04, $7e, $ba, $77, $d6, $26, $e1, $69, $14, $63, $55, $21, $0c, $7d ; f

  RCon: 
  Data.l $1, $2, $4, $8, $10, $20, $40, $80, $1b, $36 
  
  RoundKey:
  !RB 160 
  !Round DD 0 ;spielt den Rundenzähler 
  !RConZ DD 0 
  !Schleife1 DD ?
  !Schleife2 DD ?
EndDataSection

Verfasst: 14.12.2007 18:49
von onny
super, danke dir! Machts nochmal um einiges einfacher! wie "wandel" ich nun einen beliebigen text in 16 bytes um :freak: ^^

Verfasst: 14.12.2007 19:04
von hardfalcon
http://linux.die.net/man/n/aes
Lies dir da mal den Abschnitt "Modes of Operation" durch.

Fürn Anfang sollte es der "Electronic Code Book"-Mode (ECB) tun. Dabei teilst du deinen zu verschlüsselnden Buffer in 16 Byte große Blöcke, die du alle mit dem gleichen Schüssel verschlüsselst. Die verschlüsselten Blöcke haben immer noch die gleiche Größe wie die Ausgangsblöcke, somit kannst du die verschlüsselten Blöcke einfach wieder zusammenhängen, und erhälst damit deinen verschlüsselten Buffer.

//EDIT: Je nachdem in welchem Programm du diese Verschlüsselung einsetzt ist es vielleicht unerwünscht, dass man herausfinden kann, mit welchem Algorithmus verschlüsselt wird. Dir sollte klar sein, dass man den AES-Algorithmus ganz einfach an der S-Box, die ja in deinem Programm "hardcoded" enthalten ist, erknnen kann.

Verfasst: 14.12.2007 19:15
von onny
achso jetzt ist alles klar, vielen dank! hab da was durcheinandergebracht ;D

Verfasst: 15.12.2007 11:29
von Helle
Hier jetzt die Decrypt-Routine. Für Inv-Mix-Columns fiel mir auch nichts besseres ein als eine vorhandene Tabelle zu benutzen (xtime genannt).
Ich habe auf eine ASM-Data-Section verzichtet und hoffe so die Zustimmung von hardfalcon zu erhalten.
Beide Routinen müssen noch optimiert werden (z.B.Encrypt:Array2); mal sehen...

Code: Alles auswählen

;- AES-Rijndael-Decryption-Test, Textblock-und Keyword-Länge jeweils 128 Bit 
;- "Helle" Klaus Helbing, 15.12.2007, PB4.10 
;- Ohne Gewähr! Lässt sich bestimmt noch optimieren

Global Array1.l
Global RoundKey.l
Global Round.l
Global RConZ.l
Global Schleife1.l

Array1=AllocateMemory(16)
RoundKey=AllocateMemory(160)

;- RoundKeys ermitteln
;- RoundKey1, Ergebnis steht in RoundKey
!lea edi,[l_cipherkey]
!mov eax,[edi+12]
!ror eax,8

!mov edi,[v_RoundKey]
!lea esi,[l_sbox]
!xor ebx,ebx
!mov ecx,4
!@@:
!mov bl,al
!mov dl,[esi+ebx]
!mov [edi],dl
!shr eax,8
!inc edi
!dec ecx
!jnz @b

!mov esi,[v_RoundKey]
!lea edi,[l_cipherkey]
!lea edx,[l_rcon]
!mov eax,[edi]
!xor [esi],eax
!mov ebx,[edx]
!xor [esi],ebx               ;1.DWord von RoundKey1

!mov edx,[esi]
!mov eax,[edi+4]
!xor eax,edx
!mov [esi+4],eax             ;2.DWord von RoundKey1

!xor eax,[edi+8]
!mov [esi+8],eax             ;3.DWord von RoundKey1

!xor eax,[edi+12]
!mov [esi+12],eax            ;4.DWord von RoundKey1
;- Ende RoundKey1

;- RoundKey2 - RoundKey10
!mov [v_Schleife1],9
!RoundKeys:
!add [v_RConZ],4
!ror eax,8
!lea esi,[l_sbox]
!mov ecx,4
!@@:
!mov ebx,eax
!and ebx,0ffh
!mov dl,[esi+ebx]
!dec ecx
!jz @f
!shl edx,8
!shr eax,8
!jmp @b
!@@:
!bswap edx
!mov edi,[v_RoundKey]          
!add edi,[v_Round]           ;1.DWord vom "VorKey"
!mov eax,[edi]
!xor eax,edx
!lea esi,[l_rcon]
!add esi,[v_RConZ]
!xor eax,[esi]
!add edi,16                  ;hier soll abgespeichert werden
!mov [edi],eax
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;2.DWord
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;3.DWord     Fehler beim Uru in RoundKey2 (Schreib-Fehler)!
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;4.DWord
!add [v_Round],16 
!dec [v_Schleife1]
!jnz RoundKeys
;- Ende RoundKey2 - RoundKey10

;- 1.Schritt State XOR RoundKey10 -----
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_RoundKey]
!add esi,144
!lea ebx,[l_state]
!mov ecx,4
!@@:
!mov eax,[esi]
!xor eax,[ebx]            ;State      
!mov [edi],eax
!add edi,4
!add esi,4
!add ebx,4
!dec ecx
!jnz @b
;--------------------------------------

!mov [v_Round],128
!mov [v_Schleife1],10
!Schleife:

;- 2.Schritt Rotationen ---------------
;- Ergebnis steht in Array1
!mov esi,[v_Array1]
!mov ecx,8
!Rotat:
!inc esi
!mov edx,12
!@@:
!mov al,[esi+edx]
!sub edx,4
!jc @f
!shl eax,8
!jmp @b
!@@:
!rol eax,cl                  ;hier "andersrum"
!xor edx,edx
!@@:
!mov [esi+edx],al
!add edx,4
!cmp edx,16
!je @f
!shr eax,8
!jmp @b
!@@:
!add ecx,8
!cmp ecx,24
!jbe Rotat
;--------------------------------------

;- 3.Schritt Werte aus InvSBox holen --
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!lea esi,[l_invsbox]
!xor ebx,ebx
!mov edx,4
!S0:
!mov ecx,4
!@@:
!mov bl,[edi]
!mov al,[esi+ebx]
!mov [edi],al
!inc edi
!dec ecx
!jnz @b
!dec edx
!jnz S0
;--------------------------------------

!cmp [v_Round],-16
!je EndWert

;- 4.Schritt AddRoundKey --------------
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_RoundKey]
!add esi,[v_Round]
!mov ecx,4
!@@:
!mov edx,[esi]
!xor [edi],edx
!add edi,4
!add esi,4
!dec ecx
!jnz @b

;- 5.Schritt Inv-Mix-Columns ----------
!mov esi,[v_Array1]
!lea ebx,[l_xtime]

!mov edi,4
!Mix2:
!mov ecx,4
!mov edx,[esi]                     ;4 Bytes einer Spalte dl=cl usw.

!Mix1:
;1.
!mov al,dl
!xlatb
!mov ah,al
!xlatb
!xor ah,al
!xlatb
!xor ah,al
;2.
!ror edx,8
!mov al,dl
!xor ah,al
!xlatb
!xor ah,al
!xlatb
!xlatb
!xor ah,al
;3.
!ror edx,8
!mov al,dl
!xor ah,al
!xlatb
!xlatb
!xor ah,al
!xlatb
!xor ah,al
;4.
!ror edx,8
!mov al,dl
!xor ah,al
!xlatb
!xlatb
!xlatb
!xor ah,al

!mov [esi],ah
!ror edx,16
!inc esi
!dec ecx
!jnz Mix1

!dec edi
!jnz Mix2

!sub [v_Round],16
!dec [v_Schleife1]
!jnz Schleife
;--------------------------------------

!EndWert:
;- Endergebnis steht in Array1
!mov edi,[v_Array1]
!lea esi,[l_cipherkey]
!mov ecx,4
!@@:
!mov edx,[esi]
!xor [edi],edx
!add edi,4
!add esi,4
!dec ecx
!jnz @b
;--------------------------------------

;- Anzeige des Ergebnisses
For k=0 To 15
  X.c=PeekB(Array1+k)
  X$=Hex(X)
  Erg$+RSet(X$,2,"0")
Next

MessageRequester("AES-Rijndael-Decryption-Test", "Die entschlüsselten 16 Bytes lauten : "+Erg$)

End 

;--------
DataSection 
State:                       ;16 Bytes des zu entschlüsselnden Textes 
  Data.b $39, $25 ,$84, $1D, $02, $DC, $09, $FB, $DC, $11, $85, $97, $19, $6A, $0B, $32
CipherKey:                   ;das Passwort (16 Bytes) 
  Data.c $2b, $7e, $15, $16, $28, $ae, $d2, $a6, $ab, $f7, $15, $88, $09, $cf, $4f, $3c 
SBox:
  Data.b $63, $7c, $77, $7b, $f2, $6b, $6f, $c5, $30, $01, $67, $2b, $fe, $d7, $ab, $76 
  Data.b $ca, $82, $c9, $7d, $fa, $59, $47, $f0, $ad, $d4, $a2, $af, $9c, $a4, $72, $c0 
  Data.b $b7, $fd, $93, $26, $36, $3f, $f7, $cc, $34, $a5, $e5, $f1, $71, $d8, $31, $15 
  Data.b $04, $c7, $23, $c3, $18, $96, $05, $9a, $07, $12, $80, $e2, $eb, $27, $b2, $75 
  Data.b $09, $83, $2c, $1a, $1b, $6e, $5a, $a0, $52, $3b, $d6, $b3, $29, $e3, $2f, $84 
  Data.b $53, $d1, $00, $ed, $20, $fc, $b1, $5b, $6a, $cb, $be, $39, $4a, $4c, $58, $cf 
  Data.b $d0, $ef, $aa, $fb, $43, $4d, $33, $85, $45, $f9, $02, $7f, $50, $3c, $9f, $a8 
  Data.b $51, $a3, $40, $8f, $92, $9d, $38, $f5, $bc, $b6, $da, $21, $10, $ff, $f3, $d2 
  Data.b $cd, $0c, $13, $ec, $5f, $97, $44, $17, $c4, $a7, $7e, $3d, $64, $5d, $19, $73 
  Data.b $60, $81, $4f, $dc, $22, $2a, $90, $88, $46, $ee, $b8, $14, $de, $5e, $0b, $db 
  Data.b $e0, $32, $3a, $0a, $49, $06, $24, $5c, $c2, $d3, $ac, $62, $91, $95, $e4, $79 
  Data.b $e7, $c8, $37, $6d, $8d, $d5, $4e, $a9, $6c, $56, $f4, $ea, $65, $7a, $ae, $08 
  Data.b $ba, $78, $25, $2e, $1c, $a6, $b4, $c6, $e8, $dd, $74, $1f, $4b, $bd, $8b, $8a 
  Data.b $70, $3e, $b5, $66, $48, $03, $f6, $0e, $61, $35, $57, $b9, $86, $c1, $1d, $9e 
  Data.b $e1, $f8, $98, $11, $69, $d9, $8e, $94, $9b, $1e, $87, $e9, $ce, $55, $28, $df 
  Data.b $8c, $a1, $89, $0d, $bf, $e6, $42, $68, $41, $99, $2d, $0f, $b0, $54, $bb, $16 
InvSBox:
  Data.b $52, $09, $6a, $d5, $30, $36, $a5, $38, $bf, $40, $a3, $9e, $81, $f3, $d7, $fb 
  Data.b $7c, $e3, $39, $82, $9b, $2f, $ff, $87, $34, $8e, $43, $44, $c4, $de, $e9, $cb 
  Data.b $54, $7b, $94, $32, $a6, $c2, $23, $3d, $ee, $4c, $95, $0b, $42, $fa, $c3, $4e 
  Data.b $08, $2e, $a1, $66, $28, $d9, $24, $b2, $76, $5b, $a2, $49, $6d, $8b, $d1, $25 
  Data.b $72, $f8, $f6, $64, $86, $68, $98, $16, $d4, $a4, $5c, $cc, $5d, $65, $b6, $92 
  Data.b $6c, $70, $48, $50, $fd, $ed, $b9, $da, $5e, $15, $46, $57, $a7, $8d, $9d, $84 
  Data.b $90, $d8, $ab, $00, $8c, $bc, $d3, $0a, $f7, $e4, $58, $05, $b8, $b3, $45, $06 
  Data.b $d0, $2c, $1e, $8f, $ca, $3f, $0f, $02, $c1, $af, $bd, $03, $01, $13, $8a, $6b 
  Data.b $3a, $91, $11, $41, $4f, $67, $dc, $ea, $97, $f2, $cf, $ce, $f0, $b4, $e6, $73 
  Data.b $96, $ac, $74, $22, $e7, $ad, $35, $85, $e2, $f9, $37, $e8, $1c, $75, $df, $6e 
  Data.b $47, $f1, $1a, $71, $1d, $29, $c5, $89, $6f, $b7, $62, $0e, $aa, $18, $be, $1b 
  Data.b $fc, $56, $3e, $4b, $c6, $d2, $79, $20, $9a, $db, $c0, $fe, $78, $cd, $5a, $f4 
  Data.b $1f, $dd, $a8, $33, $88, $07, $c7, $31, $b1, $12, $10, $59, $27, $80, $ec, $5f 
  Data.b $60, $51, $7f, $a9, $19, $b5, $4a, $0d, $2d, $e5, $7a, $9f, $93, $c9, $9c, $ef 
  Data.b $a0, $e0, $3b, $4d, $ae, $2a, $f5, $b0, $c8, $eb, $bb, $3c, $83, $53, $99, $61 
  Data.b $17, $2b, $04, $7e, $ba, $77, $d6, $26, $e1, $69, $14, $63, $55, $21, $0c, $7d 
XTime:
  Data.b $00, $02, $04, $06, $08, $0a, $0c, $0e, $10, $12, $14, $16, $18, $1a, $1c, $1e
  Data.b $20, $22, $24, $26, $28, $2a, $2c, $2e, $30, $32, $34, $36, $38, $3a, $3c, $3e
  Data.b $40, $42, $44, $46, $48, $4a, $4c, $4e, $50, $52, $54, $56, $58, $5a, $5c, $5e
  Data.b $60, $62, $64, $66, $68, $6a, $6c, $6e, $70, $72, $74, $76, $78, $7a, $7c, $7e
  Data.b $80, $82, $84, $86, $88, $8a, $8c, $8e, $90, $92, $94, $96, $98, $9a, $9c, $9e
  Data.b $a0, $a2, $a4, $a6, $a8, $aa, $ac, $ae, $b0, $b2, $b4, $b6, $b8, $ba, $bc, $be
  Data.b $c0, $c2, $c4, $c6, $c8, $ca, $cc, $ce, $d0, $d2, $d4, $d6, $d8, $da, $dc, $de
  Data.b $e0, $e2, $e4, $e6, $e8, $ea, $ec, $ee, $f0, $f2, $f4, $f6, $f8, $fa, $fc, $fe
  Data.b $1b, $19, $1f, $1d, $13, $11, $17, $15, $0b, $09, $0f, $0d, $03, $01, $07, $05
  Data.b $3b, $39, $3f, $3d, $33, $31, $37, $35, $2b, $29, $2f, $2d, $23, $21, $27, $25
  Data.b $5b, $59, $5f, $5d, $53, $51, $57, $55, $4b, $49, $4f, $4d, $43, $41, $47, $45
  Data.b $7b, $79, $7f, $7d, $73, $71, $77, $75, $6b, $69, $6f, $6d, $63, $61, $67, $65
  Data.b $9b, $99, $9f, $9d, $93, $91, $97, $95, $8b, $89, $8f, $8d, $83, $81, $87, $85
  Data.b $bb, $b9, $bf, $bd, $b3, $b1, $b7, $b5, $ab, $a9, $af, $ad, $a3, $a1, $a7, $a5
  Data.b $db, $d9, $df, $dd, $d3, $d1, $d7, $d5, $cb, $c9, $cf, $cd, $c3, $c1, $c7, $c5
  Data.b $fb, $f9, $ff, $fd, $f3, $f1, $f7, $f5, $eb, $e9, $ef, $ed, $e3, $e1, $e7, $e5
RCon: 
  Data.l $1, $2, $4, $8, $10, $20, $40, $80, $1b, $36 
EndDataSection
Gruss
Helle

Verfasst: 15.12.2007 14:43
von Helle
Hier das Ganze etwas aufbereitet:

Code: Alles auswählen

;- AES-Rijndael-En-Decryption-Test, Textblock-und Keyword-Länge jeweils 128 Bit 
;- "Helle" Klaus Helbing, 15.12.2007, PB4.10 
;- Ohne Gewähr! Lässt sich bestimmt noch optimieren

Global Array1.l
Global RoundKey.l
Global Round.l
Global RConZ.l
Global Schleife1.l
Global Schleife2.l
Global Key.l                 ;Zeiger auf Passwort
Global Text.l                ;Zeiger auf Text

Array1=AllocateMemory(16)    ;der eigentliche "Arbeitsplatz"
RoundKey=AllocateMemory(160) ;für 10 Rundenschlüssel a 16 Bytes           

CipherKey$=Space(16)
Key=@CipherKey$

State$=Space(16)
Text=@State$

Procedure GenRoundKeys()
;- RoundKeys ermitteln
;- RoundKey1, Ergebnis steht in RoundKey
!mov [v_RConZ],0
!mov [v_Round],0
!mov edi,[v_Key]
!mov eax,[edi+12]
!ror eax,8

!mov edi,[v_RoundKey]
!lea esi,[l_sbox]
!xor ebx,ebx
!mov ecx,4
!@@:
!mov bl,al
!mov dl,[esi+ebx]
!mov [edi],dl
!shr eax,8
!inc edi
!dec ecx
!jnz @b

!mov esi,[v_RoundKey]
!mov edi,[v_Key]
!lea edx,[l_rcon]
!mov eax,[edi]
!xor [esi],eax
!mov ebx,[edx]
!xor [esi],ebx               ;1.DWord von RoundKey1

!mov eax,[edi+4]
!xor eax,[esi]
!mov [esi+4],eax             ;2.DWord von RoundKey1

!xor eax,[edi+8]
!mov [esi+8],eax             ;3.DWord von RoundKey1

!xor eax,[edi+12]
!mov [esi+12],eax            ;4.DWord von RoundKey1
;- Ende RoundKey1

;- RoundKey2 - RoundKey10
!mov [v_Schleife1],9
!RoundKeys:
!add [v_RConZ],4
!ror eax,8
!lea esi,[l_sbox]
!mov ecx,4
!@@:
!mov ebx,eax
!and ebx,0ffh
!mov dl,[esi+ebx]
!dec ecx
!jz @f
!shl edx,8
!shr eax,8
!jmp @b
!@@:
!bswap edx
!mov edi,[v_RoundKey]          
!add edi,[v_Round]           ;1.DWord vom "VorKey"
!mov eax,[edi]
!xor eax,edx
!lea esi,[l_rcon]
!add esi,[v_RConZ]
!xor eax,[esi]
!add edi,16                  ;hier soll abgespeichert werden
!mov [edi],eax
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;2.DWord
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;3.DWord
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;4.DWord
!add [v_Round],16 
!dec [v_Schleife1]
!jnz RoundKeys
;- Ende RoundKey2 - RoundKey10
EndProcedure 

Procedure EnCrypt()
;- 1.Schritt State XOR Cipher Key -----
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_Text]
!mov ebx,[v_Key]             ;hier von State getrennt!
!mov ecx,4
!@@:
!mov eax,[esi]
!xor eax,[ebx]
!mov [edi],eax
!add edi,4
!add esi,4
!add ebx,4
!dec ecx
!jnz @b
;--------------------------------------

!mov [v_Round],ecx           ;für Schleife unten, ECX=0
!SchleifeEC:

;- 2.Schritt Werte aus S-Box holen ----
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!lea esi,[l_sbox]
!xor ebx,ebx
!mov edx,4
!S0EC:
!mov ecx,4
!@@:
!mov bl,[edi]
!mov al,[esi+ebx]
!mov [edi],al
!inc edi
!dec ecx
!jnz @b
!dec edx
!jnz S0EC
;--------------------------------------

;- 3.Schritt Rotationen ---------------
;- Ergebnis steht in Array1
!mov esi,[v_Array1]
!mov ecx,8
!RotatEC:
!inc esi
!mov edx,12
!@@:
!mov al,[esi+edx]
!sub edx,4
!jc @f
!shl eax,8
!jmp @b
!@@:
!ror eax,cl
!xor edx,edx
!@@:
!mov [esi+edx],al
!add edx,4
!cmp edx,16
!je @f
!shr eax,8
!jmp @b
!@@:
!add ecx,8
!cmp ecx,24
!jbe RotatEC
;--------------------------------------

;- 4.Schritt Mix-Columns --------------
;- Ergebnis steht in Array1
!cmp [v_Round],144
!je NoMix                   ;letzte Runde nicht
!mov esi,[v_Array1]
!mov [v_Schleife2],4
!Mix2EC:
!mov ebx,[esi]
!mov [v_Schleife1],4
!Mix1EC:
!xor eax,eax
!mov ecx,eax
!mov edx,ebx

!shl dl,1
!jnc @f  
!xor dl,1bh  
!@@:  
!ror ebx,8
!mov al,bl
!shl ax,1
!mov cl,bl
!xor ax,cx
!or ah,ah
!je @f  
!xor al,1bh  
!@@:  
!xor al,dl
!ror ebx,8
!xor al,bl
!ror ebx,8
!xor al,bl
!mov [esi],al
!inc esi
!ror ebx,16
!dec [v_Schleife1]
!jnz Mix1EC 
;--------------------------------------

!dec [v_Schleife2]
!jnz Mix2EC

!NoMix:
;- 5.Schritt AddRoundKey --------------
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_RoundKey]
!add esi,[v_Round]
!mov ecx,4
!@@:
!mov eax,[esi]
!xor [edi],eax
!add edi,4
!add esi,4
!dec ecx
!jnz @b
;--------------------------------------

!add [v_Round],16            ;Zeiger in RoundKey
!cmp [v_Round],160
!jne SchleifeEC
;--------------------------------------
EndProcedure 

Procedure DeCrypt()
;- 1.Schritt State XOR RoundKey10 -----
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_RoundKey]
!add esi,144
!mov ebx,[v_Text]
!mov ecx,4
!@@:
!mov eax,[esi]
!xor eax,[ebx]               ;State      
!mov [edi],eax
!add edi,4
!add esi,4
!add ebx,4
!dec ecx
!jnz @b
;--------------------------------------

!mov [v_Round],128
!mov [v_Schleife1],10
!SchleifeDC:

;- 2.Schritt Rotationen ---------------
;- Ergebnis steht in Array1
!mov esi,[v_Array1]
!mov ecx,8
!RotatDC:
!inc esi
!mov edx,12
!@@:
!mov al,[esi+edx]
!sub edx,4
!jc @f
!shl eax,8
!jmp @b
!@@:
!rol eax,cl                  ;hier "andersrum"
!xor edx,edx
!@@:
!mov [esi+edx],al
!add edx,4
!cmp edx,16
!je @f
!shr eax,8
!jmp @b
!@@:
!add ecx,8
!cmp ecx,24
!jbe RotatDC
;--------------------------------------

;- 3.Schritt Werte aus InvSBox holen --
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!lea esi,[l_invsbox]
!xor ebx,ebx
!mov edx,4
!S0DC:
!mov ecx,4
!@@:
!mov bl,[edi]
!mov al,[esi+ebx]
!mov [edi],al
!inc edi
!dec ecx
!jnz @b
!dec edx
!jnz S0DC
;--------------------------------------

!cmp [v_Round],-16
!je EndWert

;- 4.Schritt AddRoundKey --------------
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_RoundKey]
!add esi,[v_Round]
!mov ecx,4
!@@:
!mov edx,[esi]
!xor [edi],edx
!add edi,4
!add esi,4
!dec ecx
!jnz @b

;- 5.Schritt Inv-Mix-Columns ----------
!mov esi,[v_Array1]
!lea ebx,[l_xtime]

!mov edi,4                   ;hier simpler Zähler 
!Mix2DC:
!mov ecx,4
!mov edx,[esi]               ;4 Bytes einer Spalte

!Mix1DC:
;1.Byte
!mov al,dl
!xlatb
!mov ah,al
!xlatb
!xor ah,al
!xlatb
!xor ah,al                   ;*0Eh            
;2.Byte
!ror edx,8
!mov al,dl
!xor ah,al
!xlatb
!xor ah,al
!xlatb
!xlatb
!xor ah,al                   ;*0Bh
;3.Byte
!ror edx,8
!mov al,dl
!xor ah,al
!xlatb
!xlatb
!xor ah,al
!xlatb
!xor ah,al                   ;*0Dh
;4.Byte
!ror edx,8
!mov al,dl
!xor ah,al
!xlatb
!xlatb
!xlatb
!xor ah,al                   ;*09h

!mov [esi],ah
!ror edx,16
!inc esi
!dec ecx
!jnz Mix1DC

!dec edi
!jnz Mix2DC

!sub [v_Round],16
!dec [v_Schleife1]
!jnz SchleifeDC
;--------------------------------------

!EndWert:
;- Endergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_Key]
!mov ecx,4
!@@:
!mov edx,[esi]
!xor [edi],edx
!add edi,4
!add esi,4
!dec ecx
!jnz @b
;--------------------------------------
EndProcedure 

Procedure AnzeigeBytes()
;- Anzeige des Ergebnisses
Erg$=""
For k=0 To 15
  X.c=PeekB(Array1+k)
  X$=Hex(X)
  Erg$+RSet(X$,2,"0")
Next
MessageRequester("AES-Rijndael-Encryption-Test", "Die verschlüsselten 16 Bytes lauten : "+#LFCR$+Erg$)
EndProcedure 

Procedure AnzeigeChars()
;- Anzeige des Ergebnisses
Erg$=""
For k=0 To 15
  X.c=PeekB(Array1+k)
  Erg$+Chr(X)
Next
MessageRequester("AES-Rijndael-Decryption-Test", "Die entschlüsselten 16 Bytes lauten : "+#LFCR$+Erg$)
EndProcedure 


;--------------------------------------------------------------------------------------------------
CipherKey$="Mein Passwort   "     ;16 Bytes frei wählbares Passwort
State$    ="Es weihnachtet !"     ;16 Bytes beliebiger Text(-teil)   Unicode !?     

GenRoundKeys()
EnCrypt()
AnzeigeBytes()

;- für Test Ergebnis von EnCrypt (in Array1) in Startwert für DeCrypt kopieren (State)
 !mov esi,[v_Array1]         ;Ü
 !mov edi,[v_Text]           ;b
 !mov ecx,4                  ;e
 !@@:                        ;r
 !mov eax,[esi]              ;t
 !mov [edi],eax              ;r  
 !add esi,4                  ;a
 !add edi,4                  ;g
 !dec ecx                    ;u
 !jnz @b                     ;n
;------------------          ;g

CipherKey$="Mein Passwort   "     ;zum besseren Verständnis hier mal ändern!
GenRoundKeys()
DeCrypt()
AnzeigeChars()

End 

;--------
DataSection 
SBox:                        ;wird für En-und Decrypt benötigt
  Data.b $63, $7c, $77, $7b, $f2, $6b, $6f, $c5, $30, $01, $67, $2b, $fe, $d7, $ab, $76 
  Data.b $ca, $82, $c9, $7d, $fa, $59, $47, $f0, $ad, $d4, $a2, $af, $9c, $a4, $72, $c0 
  Data.b $b7, $fd, $93, $26, $36, $3f, $f7, $cc, $34, $a5, $e5, $f1, $71, $d8, $31, $15 
  Data.b $04, $c7, $23, $c3, $18, $96, $05, $9a, $07, $12, $80, $e2, $eb, $27, $b2, $75 
  Data.b $09, $83, $2c, $1a, $1b, $6e, $5a, $a0, $52, $3b, $d6, $b3, $29, $e3, $2f, $84 
  Data.b $53, $d1, $00, $ed, $20, $fc, $b1, $5b, $6a, $cb, $be, $39, $4a, $4c, $58, $cf 
  Data.b $d0, $ef, $aa, $fb, $43, $4d, $33, $85, $45, $f9, $02, $7f, $50, $3c, $9f, $a8 
  Data.b $51, $a3, $40, $8f, $92, $9d, $38, $f5, $bc, $b6, $da, $21, $10, $ff, $f3, $d2 
  Data.b $cd, $0c, $13, $ec, $5f, $97, $44, $17, $c4, $a7, $7e, $3d, $64, $5d, $19, $73 
  Data.b $60, $81, $4f, $dc, $22, $2a, $90, $88, $46, $ee, $b8, $14, $de, $5e, $0b, $db 
  Data.b $e0, $32, $3a, $0a, $49, $06, $24, $5c, $c2, $d3, $ac, $62, $91, $95, $e4, $79 
  Data.b $e7, $c8, $37, $6d, $8d, $d5, $4e, $a9, $6c, $56, $f4, $ea, $65, $7a, $ae, $08 
  Data.b $ba, $78, $25, $2e, $1c, $a6, $b4, $c6, $e8, $dd, $74, $1f, $4b, $bd, $8b, $8a 
  Data.b $70, $3e, $b5, $66, $48, $03, $f6, $0e, $61, $35, $57, $b9, $86, $c1, $1d, $9e 
  Data.b $e1, $f8, $98, $11, $69, $d9, $8e, $94, $9b, $1e, $87, $e9, $ce, $55, $28, $df 
  Data.b $8c, $a1, $89, $0d, $bf, $e6, $42, $68, $41, $99, $2d, $0f, $b0, $54, $bb, $16 
InvSBox:                     ;wird nur für Decrypt benötigt
  Data.b $52, $09, $6a, $d5, $30, $36, $a5, $38, $bf, $40, $a3, $9e, $81, $f3, $d7, $fb 
  Data.b $7c, $e3, $39, $82, $9b, $2f, $ff, $87, $34, $8e, $43, $44, $c4, $de, $e9, $cb 
  Data.b $54, $7b, $94, $32, $a6, $c2, $23, $3d, $ee, $4c, $95, $0b, $42, $fa, $c3, $4e 
  Data.b $08, $2e, $a1, $66, $28, $d9, $24, $b2, $76, $5b, $a2, $49, $6d, $8b, $d1, $25 
  Data.b $72, $f8, $f6, $64, $86, $68, $98, $16, $d4, $a4, $5c, $cc, $5d, $65, $b6, $92 
  Data.b $6c, $70, $48, $50, $fd, $ed, $b9, $da, $5e, $15, $46, $57, $a7, $8d, $9d, $84 
  Data.b $90, $d8, $ab, $00, $8c, $bc, $d3, $0a, $f7, $e4, $58, $05, $b8, $b3, $45, $06 
  Data.b $d0, $2c, $1e, $8f, $ca, $3f, $0f, $02, $c1, $af, $bd, $03, $01, $13, $8a, $6b 
  Data.b $3a, $91, $11, $41, $4f, $67, $dc, $ea, $97, $f2, $cf, $ce, $f0, $b4, $e6, $73 
  Data.b $96, $ac, $74, $22, $e7, $ad, $35, $85, $e2, $f9, $37, $e8, $1c, $75, $df, $6e 
  Data.b $47, $f1, $1a, $71, $1d, $29, $c5, $89, $6f, $b7, $62, $0e, $aa, $18, $be, $1b 
  Data.b $fc, $56, $3e, $4b, $c6, $d2, $79, $20, $9a, $db, $c0, $fe, $78, $cd, $5a, $f4 
  Data.b $1f, $dd, $a8, $33, $88, $07, $c7, $31, $b1, $12, $10, $59, $27, $80, $ec, $5f 
  Data.b $60, $51, $7f, $a9, $19, $b5, $4a, $0d, $2d, $e5, $7a, $9f, $93, $c9, $9c, $ef 
  Data.b $a0, $e0, $3b, $4d, $ae, $2a, $f5, $b0, $c8, $eb, $bb, $3c, $83, $53, $99, $61 
  Data.b $17, $2b, $04, $7e, $ba, $77, $d6, $26, $e1, $69, $14, $63, $55, $21, $0c, $7d 
XTime:                       ;wird nur für Decrypt benötigt
  Data.b $00, $02, $04, $06, $08, $0a, $0c, $0e, $10, $12, $14, $16, $18, $1a, $1c, $1e
  Data.b $20, $22, $24, $26, $28, $2a, $2c, $2e, $30, $32, $34, $36, $38, $3a, $3c, $3e
  Data.b $40, $42, $44, $46, $48, $4a, $4c, $4e, $50, $52, $54, $56, $58, $5a, $5c, $5e
  Data.b $60, $62, $64, $66, $68, $6a, $6c, $6e, $70, $72, $74, $76, $78, $7a, $7c, $7e
  Data.b $80, $82, $84, $86, $88, $8a, $8c, $8e, $90, $92, $94, $96, $98, $9a, $9c, $9e
  Data.b $a0, $a2, $a4, $a6, $a8, $aa, $ac, $ae, $b0, $b2, $b4, $b6, $b8, $ba, $bc, $be
  Data.b $c0, $c2, $c4, $c6, $c8, $ca, $cc, $ce, $d0, $d2, $d4, $d6, $d8, $da, $dc, $de
  Data.b $e0, $e2, $e4, $e6, $e8, $ea, $ec, $ee, $f0, $f2, $f4, $f6, $f8, $fa, $fc, $fe
  Data.b $1b, $19, $1f, $1d, $13, $11, $17, $15, $0b, $09, $0f, $0d, $03, $01, $07, $05
  Data.b $3b, $39, $3f, $3d, $33, $31, $37, $35, $2b, $29, $2f, $2d, $23, $21, $27, $25
  Data.b $5b, $59, $5f, $5d, $53, $51, $57, $55, $4b, $49, $4f, $4d, $43, $41, $47, $45
  Data.b $7b, $79, $7f, $7d, $73, $71, $77, $75, $6b, $69, $6f, $6d, $63, $61, $67, $65
  Data.b $9b, $99, $9f, $9d, $93, $91, $97, $95, $8b, $89, $8f, $8d, $83, $81, $87, $85
  Data.b $bb, $b9, $bf, $bd, $b3, $b1, $b7, $b5, $ab, $a9, $af, $ad, $a3, $a1, $a7, $a5
  Data.b $db, $d9, $df, $dd, $d3, $d1, $d7, $d5, $cb, $c9, $cf, $cd, $c3, $c1, $c7, $c5
  Data.b $fb, $f9, $ff, $fd, $f3, $f1, $f7, $f5, $eb, $e9, $ef, $ed, $e3, $e1, $e7, $e5
RCon:                        ;wird für En-und Decrypt benötigt
  Data.l $1, $2, $4, $8, $10, $20, $40, $80, $1b, $36 
EndDataSection
Viel Spaß!

Gruss
Helle

Edit:15.12.2007 Beim Test zum besseren Verständnis 2 Zeilen hinzugefügt.
Edit2: 15.12.2007 Einige Optimierungen (Array2 entfernt)

Verfasst: 15.12.2007 22:12
von hardfalcon
Ok, genehmigt. :lol:

Ne, Spaß, an deinem Code hab ich ja nix geändert, war ja nur Kosmetik... :)

Erinnert mich an so ne Szene, die mein Vater mir mal erzählt hat: 80er Jahre, noch keine offenen Grenzen, er wird als frischgebackener Funkamateur vom Zoll an der deutsch-luxemburgischen Grenze kontrolliert.
"Ja haben Sie denn eine Lizenz für Ihre Funkgeräte?"
Ja, hatte er, aber leider zu Hause vergessen. Egal, er nimmt das Vorladungsschreiben fürs Funkamateur-Examen, das er zufällig noch im Handschuhfach liegen hatte, raus, und gibt es dem Zöllner.
"Ah, das ist ja alles auf französisch! Hmmmm.... Ah! Da ist ja der Stempel! Dann scheint ja alles in Ordnung zu sein..." :mrgreen:

Verfasst: 16.12.2007 18:27
von m0
Hey ihr seid ja spitze, soviel kann sich tun, wenn man ma n wochenende kein Internet hat das ist genial, die Verschlüsselung läuft (hab sie mit files bis 250MB getestet) das einzige waas mich wundert ist, dass ich nicht mehr als 4MB/s rauskrieg... schade eigentlich, aber das ist mir jetzt egal ich bin einfach nur froh dass es funktionniert!! geschwindigkeit optimieren kann ich immernoch, wenn ich mich mal richtig in ASM eingelesen habe

VIELEN VIELEN DANK!!!!!

gruß
m0

Verfasst: 18.12.2007 20:44
von Helle
Zum Abschluss hier ein AES128-Anwendungs-Beispiel in seiner simpelsten Form (trotzdem wohl mehr als sicher). Betreffs Durchsatz fehlen mir Vergleichswerte von anderen Programmen; wer entscheidene Verbesserungen findet kann´s mir mitteilen :)!

Code: Alles auswählen

;- AES128-Test, Textblock-und Keyword-Länge jeweils 128 Bit, ECB-Modus 
;- "Helle" Klaus Helbing, 25.12.2007, PB4.10 
;- Die Original-Datei bleibt unberührt und erhält ein "O" am Ende des Datei-Namens und
;-  kann jederzeit wieder umbenannt werden
;- Die verschlüsselte Datei erhält neben "AES128" ein "_X" am Ende, wobei X ein Hexwert
;-  von 0 bis F sein kann (gibt die Anzahl der evtl. notwendigen Auffüll-Bytes an)
;- Der Vorteil dieser Methode ist, dass für die verschlüsselte Datei auf dem Datenträger
;-  nie mehr Platz als für die Original-Datei benötigt wird 
;- Die verschlüsselte Datei wird im selben Verzeichnis wie die Original-Datei abgespeichert 
;- Als Buffer-Größe wurde 4096 = normale Cluster-Größe NTFS gewählt

Global Array1.l
Global RoundKey.l
Global Round.l
Global RConZ.l
Global Schleife1.l
Global Schleife2.l
Global Key.l                 ;Zeiger auf Passwort
Global Laenge.l
Global Auffuell.l

Array1=AllocateMemory(4096)  ;der eigentliche "Arbeitsplatz"
RoundKey=AllocateMemory(160) ;für 10 Rundenschlüssel a 16 Bytes           
Array2=Array1
CipherKey$=Space(16)
Key=@CipherKey$

Procedure GenRoundKeys()
;- RoundKeys ermitteln
;- RoundKey1, Ergebnis steht in RoundKey
!mov [v_RConZ],0
!mov [v_Round],0
!mov edi,[v_Key]
!mov eax,[edi+12]
!ror eax,8

!mov edi,[v_RoundKey]
!lea esi,[l_sbox]
!xor ebx,ebx
!mov ecx,4
!@@:
!mov bl,al
!mov dl,[esi+ebx]
!mov [edi],dl
!shr eax,8
!inc edi
!dec ecx
!jnz @b

!mov esi,[v_RoundKey]
!mov edi,[v_Key]
!lea edx,[l_rcon]
!mov eax,[edi]
!xor [esi],eax
!mov ebx,[edx]
!xor [esi],ebx               ;1.DWord von RoundKey1

!mov eax,[edi+4]
!xor eax,[esi]
!mov [esi+4],eax             ;2.DWord von RoundKey1

!xor eax,[edi+8]
!mov [esi+8],eax             ;3.DWord von RoundKey1

!xor eax,[edi+12]
!mov [esi+12],eax            ;4.DWord von RoundKey1
;- Ende RoundKey1

;- RoundKey2 - RoundKey10
!mov [v_Schleife1],9
!RoundKeys:
!add [v_RConZ],4
!ror eax,8
!lea esi,[l_sbox]
!mov ecx,4
!@@:
!mov ebx,eax
!and ebx,0ffh
!mov dl,[esi+ebx]
!dec ecx
!jz @f
!shl edx,8
!shr eax,8
!jmp @b
!@@:
!bswap edx
!mov edi,[v_RoundKey]          
!add edi,[v_Round]           ;1.DWord vom "VorKey"
!mov eax,[edi]
!xor eax,edx
!lea esi,[l_rcon]
!add esi,[v_RConZ]
!xor eax,[esi]
!add edi,16                  ;hier soll abgespeichert werden
!mov [edi],eax
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;2.DWord
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;3.DWord
!add edi,4
!xor eax,[edi-16]
!mov [edi],eax               ;4.DWord
!add [v_Round],16 
!dec [v_Schleife1]
!jnz RoundKeys
;- Ende RoundKey2 - RoundKey10
EndProcedure 

Procedure EnCrypt()
;- 1.Schritt State XOR Cipher Key -----
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_Key]
!mov ecx,4
!@@:
!mov eax,[esi]
!xor [edi],eax
!add edi,4
!add esi,4
!dec ecx
!jnz @b
;--------------------------------------

!mov [v_Round],ecx           ;für Schleife unten, ECX=0
!SchleifeEC:

;- 2.Schritt Werte aus S-Box holen ----
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!lea esi,[l_sbox]
!xor ebx,ebx
!mov edx,4
!S0EC:
!mov ecx,4
!@@:
!mov bl,[edi]
!mov al,[esi+ebx]
!mov [edi],al
!inc edi
!dec ecx
!jnz @b
!dec edx
!jnz S0EC
;--------------------------------------

;- 3.Schritt Rotationen ---------------
;- Ergebnis steht in Array1
!mov esi,[v_Array1]
!mov ecx,8
!RotatEC:
!inc esi
!mov edx,12
!@@:
!mov al,[esi+edx]
!sub edx,4
!jc @f
!shl eax,8
!jmp @b
!@@:
!ror eax,cl
!xor edx,edx
!@@:
!mov [esi+edx],al
!add edx,4
!cmp edx,16
!je @f
!shr eax,8
!jmp @b
!@@:
!add ecx,8
!cmp ecx,24
!jbe RotatEC
;--------------------------------------

;- 4.Schritt Mix-Columns --------------
;- Ergebnis steht in Array1
!cmp [v_Round],144
!je NoMix                   ;letzte Runde nicht
!mov esi,[v_Array1]
!mov [v_Schleife2],4
!Mix2EC:
!mov ebx,[esi]
!mov [v_Schleife1],4
!Mix1EC:
!xor eax,eax
!mov ecx,eax
!mov edx,ebx

!shl dl,1
!jnc @f  
!xor dl,1bh  
!@@:  
!ror ebx,8
!mov al,bl
!shl ax,1
!mov cl,bl
!xor ax,cx
!or ah,ah
!je @f  
!xor al,1bh  
!@@:  
!xor al,dl
!ror ebx,8
!xor al,bl
!ror ebx,8
!xor al,bl
!mov [esi],al
!inc esi
!ror ebx,16
!dec [v_Schleife1]
!jnz Mix1EC 
;--------------------------------------

!dec [v_Schleife2]
!jnz Mix2EC

!NoMix:
;- 5.Schritt AddRoundKey --------------
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_RoundKey]
!add esi,[v_Round]
!mov ecx,4
!@@:
!mov eax,[esi]
!xor [edi],eax
!add edi,4
!add esi,4
!dec ecx
!jnz @b
;--------------------------------------

!add [v_Round],16            ;Zeiger in RoundKey
!cmp [v_Round],160
!jne SchleifeEC
;--------------------------------------
EndProcedure 

Procedure DeCrypt()
;- 1.Schritt State XOR RoundKey10 -----
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_RoundKey]
!add esi,144
!mov ecx,4
!@@:
!mov eax,[esi]
!xor [edi],eax    
!add edi,4
!add esi,4
!dec ecx
!jnz @b
;--------------------------------------

!mov [v_Round],128
!mov [v_Schleife1],10
!SchleifeDC:

;- 2.Schritt Rotationen ---------------
;- Ergebnis steht in Array1
!mov esi,[v_Array1]
!mov ecx,8
!RotatDC:
!inc esi
!mov ebx,12
!@@:
!mov al,[esi+ebx]
!sub ebx,4
!jc @f
!shl eax,8
!jmp @b
!@@:
!rol eax,cl                  ;hier "andersrum"
!xor ebx,ebx
!@@:
!mov [esi+ebx],al
!add ebx,4
!cmp ebx,16
!je @f
!shr eax,8
!jmp @b
!@@:
!add ecx,8
!cmp ecx,24
!jbe RotatDC
;--------------------------------------

;- 3.Schritt Werte aus InvSBox holen --
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!lea esi,[l_invsbox]
!mov edx,4
!S0DC:
!mov ecx,4
!@@:
!mov bl,[edi]                ;EBX wurde oben auf Null gesetzt
!mov al,[esi+ebx]
!mov [edi],al
!inc edi
!dec ecx
!jnz @b
!dec edx
!jnz S0DC
;--------------------------------------

!cmp [v_Round],-16
!je EndWert

;- 4.Schritt AddRoundKey --------------
;- Ergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_RoundKey]
!add esi,[v_Round]
!mov ecx,4
!@@:
!mov edx,[esi]
!xor [edi],edx
!add edi,4
!add esi,4
!dec ecx
!jnz @b

;- 5.Schritt Inv-Mix-Columns ----------
!mov esi,[v_Array1]
!lea edi,[l_xtime]
!mov [v_Schleife2],4
!Mix2DC:
!mov ecx,4
!mov edx,[esi]               ;4 Bytes einer Spalte

!Mix1DC:
;1.Byte *0Eh
!mov bl,dl                   ;EBX wurde oben auf Null gesetzt
!mov al,[edi+ebx]
!mov bl,al
!mov bl,[edi+ebx]
!xor al,bl
!xor al,[edi+ebx]

;2.Byte *0Bh
!ror edx,8
!mov bl,dl
!xor al,dl
!mov bl,[edi+ebx]
!xor al,bl
!mov bl,[edi+ebx]
!xor al,[edi+ebx]

;3.Byte *0Dh
!ror edx,8
!mov bl,dl
!xor al,dl
!mov bl,[edi+ebx]
!xor al,[edi+ebx]
!mov bl,[edi+ebx]
!xor al,[edi+ebx]

;4.Byte *09h
!ror edx,8
!mov bl,dl
!xor al,dl
!mov bl,[edi+ebx]
!mov bl,[edi+ebx]
!xor al,[edi+ebx]

;- "gemixtes" Byte abspeichern
!mov [esi],al
!ror edx,16
!inc esi
!dec ecx
!jnz Mix1DC

!dec [v_Schleife2]
!jnz Mix2DC

!sub [v_Round],16
!dec [v_Schleife1]
!jnz SchleifeDC
;--------------------------------------

!EndWert:
;- Endergebnis steht in Array1
!mov edi,[v_Array1]
!mov esi,[v_Key]
!mov ecx,4
!@@:
!mov edx,[esi]
!xor [edi],edx
!add edi,4
!add esi,4
!dec ecx
!jnz @b
;--------------------------------------
EndProcedure 

;=================================== T E S T P R O G R A M M ======================================

If OpenWindow(0,0,0,450,280,"AES128, ECB",#PB_Window_SystemMenu | #PB_Window_ScreenCentered) And CreateGadgetList(WindowID(0))
  TextGadget(0,10,10,430,20,"Zu bearbeitende Datei auswählen :",#PB_Text_Center)  
  ExplorerTreeGadget(1, 10, 30, 430, 240,"",#PB_Explorer_NoDriveRequester)

  Repeat
    Event=WaitWindowEvent()
    If Event=#PB_Event_CloseWindow
      End 
    EndIf   
  Until EventType()=#PB_EventType_LeftDoubleClick And GetGadgetState(1)=#PB_Explorer_File
 
  File$=GetGadgetText(1)
  FreeGadget(0):FreeGadget(1)
  File1$=File$
  If Len(File$)>75
    File1$=Mid(File$,1,75)+#LFCR$+Mid(File$,76,Len(File$)-75)
  EndIf
    
  TextGadget(0,10,10,430,20,"Ausgewählte Datei :",#PB_Text_Center)
  TextGadget(1,10,30,430,40,File1$,#PB_Text_Center)
 
  OptionGadget(2,50,70,100,20,"Verschlüsseln")
  OptionGadget(3,300,70,100,20,"Entschlüsseln")
 
  Repeat
    Event=WaitWindowEvent()
    If Event=#PB_Event_CloseWindow
      End 
    EndIf   
  Until EventGadget()=2 Or EventGadget()=3 
  
  Art=GetActiveGadget()
  If Art=2
    Art$="Verschlüsselung"
   Else
    Art$="Entschlüsselung"  
  EndIf
    
  FreeGadget(2):FreeGadget(3)
  
  TextGadget(2,10,70,430,20,"Bearbeitungsart :",#PB_Text_Center)
  TextGadget(3,10,90,430,20,Art$,#PB_Text_Center)
    
  TextGadget(4,35,120,380,20,"Bitte Passwort eingeben (max.16 Zeichen) :",#PB_Text_Center)
   
  StringGadget(5, 125, 140, 200, 20, "", #PB_String_Password)
  SetActiveGadget(5)
 
  ButtonGadget(6,175,170,100,20,"OK")
   
  Repeat
    Event=WaitWindowEvent()
    If Event=#PB_Event_CloseWindow
      End 
    EndIf   
  Until EventGadget()=6  

  CipherKey$=Mid(GetGadgetText(5),1,16) 
  CipherKey$=LSet(CipherKey$,16)       ;oder mit anderen Zeichen als Space auffüllen
 
  FreeGadget(4):FreeGadget(5):FreeGadget(6) 
 
  TextGadget       (4,10,120,430,20, "Bearbeitungs-Fortschritt :", #PB_Text_Center)
  ProgressBarGadget(5,10,145,430,30,0,100)
    
 Else
  MessageRequester("Fehler !","Auswahl bzw. Eingabe überprüfen !")
  End 
EndIf

;----------------------------
Select Art
;- Verschlüsselung
  Case 2 
    CreateFile(1,File$+".AES128")
    ReadFile(0,File$)                  ;nur zum Lesen öffnen
    FileL=Lof(0)

    FileR=FileL%4096

    FileL/4096 

    TA=ElapsedMilliseconds()
  
    GenRoundKeys()
 
    For i=1 To FileL
      Laenge=ReadData(0,Array1,4096)
      X+Laenge                         ;für Anzeige

      For k=1 To 256                  ;4096/16
        EnCrypt()
        Array1+16
      Next
 
      WriteData(1,Array2,Laenge)
      Array1-Laenge 
 
      Y.f=(X/(FileL*4096))*100
      SetGadgetState(5,Y)
    Next 

    Auffuell=FileR%16

;- Rest der Datei:
    If FileR
      Laenge=ReadData(0,Array1,FileR)

      If Auffuell
        !mov edi,[v_Array1]
        !add edi,[v_Laenge]
        !mov ecx,[v_Auffuell]
        !@@:
        !mov byte[edi],0               ;für Test Null als Auffüll-Byte(s)           
        !inc edi
        !dec ecx
        !jnz @b
      EndIf 

      Laenge+Auffuell
      m=Laenge/16

      For k=1 To m
        EnCrypt()
        Array1+16
      Next
      WriteData(1,Array2,Laenge)
   
      SetGadgetState(5,100)            ;kühn auf fertig gesetzt
    EndIf

    CloseFile(0)
    CloseFile(1)

    ;- an den Namem der verschlüsselten Datei die Anzahl der Auffüll-Bytes anhängen
    FileAlt$=File$+".AES128"
    FileNeu$=FileAlt$+"_"+Hex(Auffuell)     ;Hex, damit nur 1 Zeichen (0 bis F)
    RenameFile(FileAlt$,FileNeu$) 

    ;- an den Namen der Original-Datei ein "O" anhängen, normalerweise wird die Datei gelöscht
    RenameFile(File$,File$+"O")

    TE=ElapsedMilliseconds()-TA
    If TE  
      Durchsatz=FileL*4096/TE
    EndIf 
 
    TextGadget(7,10,190,430,20,"Verschlüsselungs-Zeit = "+ Str(TE)+" ms",#PB_Text_Center)
    TextGadget(8,10,215,430,20,"Durchsatz = "+Str(Durchsatz)+" kB/s" ,#PB_Text_Center) 
      
    ButtonGadget(9,175,240,100,20,"Ende")
   
    Repeat
      Event=WaitWindowEvent()
      If Event=#PB_Event_CloseWindow
        End 
      EndIf   
    Until EventGadget()=9 
    End  

;--------------------------------------------------------------------------------------------------
;- Entschlüsselung
  Case 3
    Auffuell$=Mid(File$,Len(File$),1)
    
    If Asc(Auffuell$)>60
      Auffuell=Asc(Auffuell$)-55
     Else
      Auffuell=Asc(Auffuell$)-48
    EndIf
 
    FileN$=Mid(File$,1,Len(File$)-9)   ;".AES128_"und Anzahl der Auffüll-Bytes entfernen
    CreateFile(1,FileN$)               ;ist der Original-Dateiname
    ReadFile(0,File$)                  ;verschlüsselte Datei nur zum Lesen öffnen
    FileL=Lof(0)

    Array1=AllocateMemory(4096)        ;der eigentliche "Arbeitsplatz"
    Array2=Array1                      ;ist so am einfachsten
    RoundKey=AllocateMemory(160)       ;für 10 Rundenschlüssel a 16 Bytes

    FileR=FileL%4096

    FileL/4096 

    TA=ElapsedMilliseconds()
    
    GenRoundKeys()
 
    For i=1 To FileL
      Laenge=ReadData(0,Array1,4096)   ;sollte immer 4096 sein
      X+Laenge                         ;für Anzeige

      For k=1 To 256                   ;4096/16
        DeCrypt()
        Array1+16
      Next
 
      WriteData(1,Array2,Laenge)
      Array1-Laenge 

      Y.f=(X/(FileL*4096))*100
      SetGadgetState(5,Y)
    Next 

    If FileR
      Laenge=ReadData(0,Array1,FileR)
      m=Laenge/16

      For k=1 To m
        DeCrypt()
        Array1+16
      Next
      WriteData(1,Array2,Laenge)
   
      SetGadgetState(5,100)            ;kühn auf fertig gesetzt
    EndIf

    FileSeek(1,((FileL*4096)+FileR)-Auffuell)
    TruncateFile(1)

    CloseFile(0)
    CloseFile(1)

    TE=ElapsedMilliseconds()-TA
    If TE
      Durchsatz=FileL*4096/TE
    EndIf 
   
    TextGadget(7,10,190,430,20,"Entschlüsselungs-Zeit = "+ Str(TE)+" ms",#PB_Text_Center)
    TextGadget(8,10,215,430,20,"Durchsatz = "+Str(Durchsatz)+" kB/s" ,#PB_Text_Center) 
      
    ButtonGadget(9,175,240,100,20,"Ende")
   
    Repeat
      Event=WaitWindowEvent()
      If Event=#PB_Event_CloseWindow
        End 
      EndIf   
    Until EventGadget()=9 
    End  

EndSelect 

End 

;----------------------------------------------------------------------------------------
DataSection 
SBox:                        ;wird für En-und Decrypt benötigt
  Data.b $63, $7c, $77, $7b, $f2, $6b, $6f, $c5, $30, $01, $67, $2b, $fe, $d7, $ab, $76 
  Data.b $ca, $82, $c9, $7d, $fa, $59, $47, $f0, $ad, $d4, $a2, $af, $9c, $a4, $72, $c0 
  Data.b $b7, $fd, $93, $26, $36, $3f, $f7, $cc, $34, $a5, $e5, $f1, $71, $d8, $31, $15 
  Data.b $04, $c7, $23, $c3, $18, $96, $05, $9a, $07, $12, $80, $e2, $eb, $27, $b2, $75 
  Data.b $09, $83, $2c, $1a, $1b, $6e, $5a, $a0, $52, $3b, $d6, $b3, $29, $e3, $2f, $84 
  Data.b $53, $d1, $00, $ed, $20, $fc, $b1, $5b, $6a, $cb, $be, $39, $4a, $4c, $58, $cf 
  Data.b $d0, $ef, $aa, $fb, $43, $4d, $33, $85, $45, $f9, $02, $7f, $50, $3c, $9f, $a8 
  Data.b $51, $a3, $40, $8f, $92, $9d, $38, $f5, $bc, $b6, $da, $21, $10, $ff, $f3, $d2 
  Data.b $cd, $0c, $13, $ec, $5f, $97, $44, $17, $c4, $a7, $7e, $3d, $64, $5d, $19, $73 
  Data.b $60, $81, $4f, $dc, $22, $2a, $90, $88, $46, $ee, $b8, $14, $de, $5e, $0b, $db 
  Data.b $e0, $32, $3a, $0a, $49, $06, $24, $5c, $c2, $d3, $ac, $62, $91, $95, $e4, $79 
  Data.b $e7, $c8, $37, $6d, $8d, $d5, $4e, $a9, $6c, $56, $f4, $ea, $65, $7a, $ae, $08 
  Data.b $ba, $78, $25, $2e, $1c, $a6, $b4, $c6, $e8, $dd, $74, $1f, $4b, $bd, $8b, $8a 
  Data.b $70, $3e, $b5, $66, $48, $03, $f6, $0e, $61, $35, $57, $b9, $86, $c1, $1d, $9e 
  Data.b $e1, $f8, $98, $11, $69, $d9, $8e, $94, $9b, $1e, $87, $e9, $ce, $55, $28, $df 
  Data.b $8c, $a1, $89, $0d, $bf, $e6, $42, $68, $41, $99, $2d, $0f, $b0, $54, $bb, $16 
InvSBox:                     ;wird nur für Decrypt benötigt
  Data.b $52, $09, $6a, $d5, $30, $36, $a5, $38, $bf, $40, $a3, $9e, $81, $f3, $d7, $fb 
  Data.b $7c, $e3, $39, $82, $9b, $2f, $ff, $87, $34, $8e, $43, $44, $c4, $de, $e9, $cb 
  Data.b $54, $7b, $94, $32, $a6, $c2, $23, $3d, $ee, $4c, $95, $0b, $42, $fa, $c3, $4e 
  Data.b $08, $2e, $a1, $66, $28, $d9, $24, $b2, $76, $5b, $a2, $49, $6d, $8b, $d1, $25 
  Data.b $72, $f8, $f6, $64, $86, $68, $98, $16, $d4, $a4, $5c, $cc, $5d, $65, $b6, $92 
  Data.b $6c, $70, $48, $50, $fd, $ed, $b9, $da, $5e, $15, $46, $57, $a7, $8d, $9d, $84 
  Data.b $90, $d8, $ab, $00, $8c, $bc, $d3, $0a, $f7, $e4, $58, $05, $b8, $b3, $45, $06 
  Data.b $d0, $2c, $1e, $8f, $ca, $3f, $0f, $02, $c1, $af, $bd, $03, $01, $13, $8a, $6b 
  Data.b $3a, $91, $11, $41, $4f, $67, $dc, $ea, $97, $f2, $cf, $ce, $f0, $b4, $e6, $73 
  Data.b $96, $ac, $74, $22, $e7, $ad, $35, $85, $e2, $f9, $37, $e8, $1c, $75, $df, $6e 
  Data.b $47, $f1, $1a, $71, $1d, $29, $c5, $89, $6f, $b7, $62, $0e, $aa, $18, $be, $1b 
  Data.b $fc, $56, $3e, $4b, $c6, $d2, $79, $20, $9a, $db, $c0, $fe, $78, $cd, $5a, $f4 
  Data.b $1f, $dd, $a8, $33, $88, $07, $c7, $31, $b1, $12, $10, $59, $27, $80, $ec, $5f 
  Data.b $60, $51, $7f, $a9, $19, $b5, $4a, $0d, $2d, $e5, $7a, $9f, $93, $c9, $9c, $ef 
  Data.b $a0, $e0, $3b, $4d, $ae, $2a, $f5, $b0, $c8, $eb, $bb, $3c, $83, $53, $99, $61 
  Data.b $17, $2b, $04, $7e, $ba, $77, $d6, $26, $e1, $69, $14, $63, $55, $21, $0c, $7d 
XTime:                       ;wird nur für Decrypt benötigt
  Data.b $00, $02, $04, $06, $08, $0a, $0c, $0e, $10, $12, $14, $16, $18, $1a, $1c, $1e
  Data.b $20, $22, $24, $26, $28, $2a, $2c, $2e, $30, $32, $34, $36, $38, $3a, $3c, $3e
  Data.b $40, $42, $44, $46, $48, $4a, $4c, $4e, $50, $52, $54, $56, $58, $5a, $5c, $5e
  Data.b $60, $62, $64, $66, $68, $6a, $6c, $6e, $70, $72, $74, $76, $78, $7a, $7c, $7e
  Data.b $80, $82, $84, $86, $88, $8a, $8c, $8e, $90, $92, $94, $96, $98, $9a, $9c, $9e
  Data.b $a0, $a2, $a4, $a6, $a8, $aa, $ac, $ae, $b0, $b2, $b4, $b6, $b8, $ba, $bc, $be
  Data.b $c0, $c2, $c4, $c6, $c8, $ca, $cc, $ce, $d0, $d2, $d4, $d6, $d8, $da, $dc, $de
  Data.b $e0, $e2, $e4, $e6, $e8, $ea, $ec, $ee, $f0, $f2, $f4, $f6, $f8, $fa, $fc, $fe
  Data.b $1b, $19, $1f, $1d, $13, $11, $17, $15, $0b, $09, $0f, $0d, $03, $01, $07, $05
  Data.b $3b, $39, $3f, $3d, $33, $31, $37, $35, $2b, $29, $2f, $2d, $23, $21, $27, $25
  Data.b $5b, $59, $5f, $5d, $53, $51, $57, $55, $4b, $49, $4f, $4d, $43, $41, $47, $45
  Data.b $7b, $79, $7f, $7d, $73, $71, $77, $75, $6b, $69, $6f, $6d, $63, $61, $67, $65
  Data.b $9b, $99, $9f, $9d, $93, $91, $97, $95, $8b, $89, $8f, $8d, $83, $81, $87, $85
  Data.b $bb, $b9, $bf, $bd, $b3, $b1, $b7, $b5, $ab, $a9, $af, $ad, $a3, $a1, $a7, $a5
  Data.b $db, $d9, $df, $dd, $d3, $d1, $d7, $d5, $cb, $c9, $cf, $cd, $c3, $c1, $c7, $c5
  Data.b $fb, $f9, $ff, $fd, $f3, $f1, $f7, $f5, $eb, $e9, $ef, $ed, $e3, $e1, $e7, $e5
RCon:                        ;wird für En-und Decrypt benötigt
  Data.l $1, $2, $4, $8, $10, $20, $40, $80, $1b, $36 
EndDataSection
Gruß
Helle

Edit: 19.12.2007 Variable "Text" entfernt
Edit: 19.12.2007 Decrypt beschleunigt (Taktzyklen-Fresser XLATB ersetzt)
Edit: 20.12.2007 Neue Oberfläche, Auffuell in Decrypt korrigiert
Edit: 25.12.2007 Passwort-Fehler in Version v.20.12.2007 korrigiert
Alle Zeiten sind UTC+02:00
Seite 3 von 4

Powered by phpBB® Forum Software © phpBB Limited

Deutsche Übersetzung durch phpBB.de