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
AES-verschlüsselung
gruß oNNy
http://www.onnsoft.de
http://www.onnsoft.de
-
hardfalcon
- Beiträge: 3447
- Registriert: 29.08.2004 20:46
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...
//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 ?
EndDataSectionsuper, danke dir! Machts nochmal um einiges einfacher! wie "wandel" ich nun einen beliebigen text in 16 bytes um 
^^
^^gruß oNNy
http://www.onnsoft.de
http://www.onnsoft.de
-
hardfalcon
- Beiträge: 3447
- Registriert: 29.08.2004 20:46
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.
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.
achso jetzt ist alles klar, vielen dank! hab da was durcheinandergebracht ;D
gruß oNNy
http://www.onnsoft.de
http://www.onnsoft.de
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...
Gruss
Helle
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
Helle
Hier das Ganze etwas aufbereitet:
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)
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
EndDataSectionGruss
Helle
Edit:15.12.2007 Beim Test zum besseren Verständnis 2 Zeilen hinzugefügt.
Edit2: 15.12.2007 Einige Optimierungen (Array2 entfernt)
Zuletzt geändert von Helle am 18.12.2007 16:27, insgesamt 2-mal geändert.
-
hardfalcon
- Beiträge: 3447
- Registriert: 29.08.2004 20:46
Ok, genehmigt. 
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..."
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..."
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
VIELEN VIELEN DANK!!!!!
gruß
m0
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 !
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
!
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
EndDataSectionHelle
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