PureBoard

Code: Alles auswählen

;- AES128-Test, Textblock-und Keyword-Länge jeweils 128 Bit, ECB- und CBC-Modus 
;- "Helle" Klaus Helbing, 27.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 ist (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
;-  nicht 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 Key.l                 ;Zeiger auf Passwort
Global Laenge.l
Global Auffuell.l
Global CBC.l      
Global IVec.l
Global IVecE.l

Array1=AllocateMemory(4112)  ;der eigentliche "Arbeitsplatz"
X=Array1%16
If X
  Array1+X
EndIf

Array2=Array1

RoundKey=AllocateMemory(176) ;für 10 Rundenschlüssel a 16 Bytes           
X=RoundKey%16
If X
  RoundKey+X
EndIf

CipherKey$=Space(32)
Key=@CipherKey$
  
InitVec$=Space(16)
IVec=@InitVec$
InitVecE$=Space(16)
IVecE=@InitVecE$

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 edx,[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 ebp,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 ebp
!jnz RoundKeys
;- Ende RoundKey2 - RoundKey10
EndProcedure 

Procedure EnCrypt()
;- Test auf CBC-Modus und wenn ja dann Array1 mit InitVec XOR-verknüpfen (16 Bytes)
!cmp [v_CBC],0
!je NoCBC1
!mov edi,[v_Array1]
!mov esi,[v_IVec]
!mov ecx,4
!@@:
!mov eax,[esi]
!xor [edi],eax
!add edi,4
!add esi,4
!dec ecx
!jnz @b
!NoCBC1:

;- 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]
!mov ebp,4
!S0EC:
!mov ecx,4
!mov edx,[edi]
!@@:
!mov ebx,edx
!and ebx,0ffh
!mov eax,[esi+ebx]
!mov [edi],al
!shr edx,8
!inc edi
!dec ecx
!jnz @b
!dec ebp
!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 edi,4
!Mix2EC:
!mov ebx,[esi]
!mov ecx,408h
!Mix1EC:
!mov edx,ebx
!shl dl,1
!jnc @f  
!xor edx,1bh 
!@@:  
!ror ebx,cl
!mov eax,ebx
!shl al,1
!jnc @f  
!xor eax,1bh 
!@@:  
!xor eax,ebx
!xor eax,edx
!ror ebx,cl
!xor eax,ebx
!ror ebx,cl
!xor eax,ebx
!mov [esi],al
!inc esi
!ror ebx,16
!dec ch
!jnz Mix1EC 
;--------------------------------------

!dec edi
!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

!cmp [v_CBC],0
!je NoCBC2
!mov edi,[v_Array1]
!mov esi,[v_IVec]
!mov ecx,4
!@@:
!mov eax,[edi]
!mov [esi],eax
!add edi,4
!add esi,4
!dec ecx
!jnz @b
!NoCBC2:
;--------------------------------------
EndProcedure 

Procedure DeCrypt()
;- Test auf CBC-Modus und wenn ja dann Array1 in InitVecE kopieren (16 Bytes)
!cmp [v_CBC],0
!je NoCBC3
!mov esi,[v_Array1]
!mov edi,[v_IVecE]
!mov ecx,4
!@@:
!mov eax,[esi]
!mov [edi],eax
!add edi,4
!add esi,4
!dec ecx
!jnz @b
!NoCBC3:

;- 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
!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 ebp,4
!S0DC:
!mov ecx,4
!mov edx,[edi]
!@@:
!mov ebx,edx
!and ebx,0ffh
!mov eax,[esi+ebx]
!mov [edi],al
!shr edx,8
!inc edi
!dec ecx
!jnz @b
!dec ebp
!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 ebp,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
!lea eax,[l_xtime1]
!mov al,[eax+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 ebp
!jnz Mix2DC

!sub [v_Round],16
!jmp 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

!cmp [v_CBC],0
!je NoCBC4
!mov edi,[v_Array1]
!mov esi,[v_IVec]
!mov ecx,4
!@@:
!mov eax,[esi]
!xor [edi],eax
!add edi,4
!add esi,4
!dec ecx
!jnz @b

!mov eax,[v_IVec]
!xchg [v_IVecE],eax
!mov [v_IVec],eax

!NoCBC4:
;--------------------------------------
EndProcedure 

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

If OpenWindow(0,0,0,450,280,"AES128, ECB- und CBC-Modus",#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)

  OptionGadget(12,50,70,100,20,"EBC-Modus") ;wie kann man EventGadget() neutralisieren???
  OptionGadget(13,300,70,100,20,"CBC-Modus")

  Repeat
    Event=WaitWindowEvent()
    If Event=#PB_Event_CloseWindow
      End 
    EndIf   
  Until EventGadget()=12 Or EventGadget()=13
    
  Modus=GetActiveGadget()
  If Modus=12
    Modus$="EBC"
   Else
    Modus$="CBC"  
  EndIf
    
  FreeGadget(12):FreeGadget(13)
  
  TextGadget(2,10,70,430,20,"Bearbeitungsart : "+Art$,#PB_Text_Center)
  
  TextGadget(3,10,90,430,20,"Modus : "+Modus$,#PB_Text_Center)

  If Modus=13
    CBC=1
    
    TextGadget(4,35,120,380,20,"Bitte Initialisierungs-Vektor 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  

    InitVec$=Mid(GetGadgetText(5),1,16) 
    InitVec$=LSet(InitVec$,16)         ;oder mit anderen Zeichen als Space auffüllen
 
    FreeGadget(4):FreeGadget(5):FreeGadget(6) 
  EndIf
    
  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
XTime1:                      ;wird nur für Decrypt benötigt   
  Data.b $00, $0E, $1C, $12, $38, $36, $24, $2A, $70, $7E, $6C, $62, $48, $46, $54, $5A
  Data.b $E0, $EE, $FC, $F2, $D8, $D6, $C4, $CA, $90, $9E, $8C, $82, $A8, $A6, $B4, $BA
  Data.b $DB, $D5, $C7, $C9, $E3, $ED, $FF, $F1, $AB, $A5, $B7, $B9, $93, $9D, $8F, $81
  Data.b $3B, $35, $27, $29, $03, $0D, $1F, $11, $4B, $45, $57, $59, $73, $7D, $6F, $61
  Data.b $AD, $A3, $B1, $BF, $95, $9B, $89, $87, $DD, $D3, $C1, $CF, $E5, $EB, $F9, $F7
  Data.b $4D, $43, $51, $5F, $75, $7B, $69, $67, $3D, $33, $21, $2F, $05, $0B, $19, $17
  Data.b $76, $78, $6A, $64, $4E, $40, $52, $5C, $06, $08, $1A, $14, $3E, $30, $22, $2C
  Data.b $96, $98, $8A, $84, $AE, $A0, $B2, $BC, $E6, $E8, $FA, $F4, $DE, $D0, $C2, $CC
  Data.b $41, $4F, $5D, $53, $79, $77, $65, $6B, $31, $3F, $2D, $23, $09, $07, $15, $1B
  Data.b $A1, $AF, $BD, $B3, $99, $97, $85, $8B, $D1, $DF, $CD, $C3, $E9, $E7, $F5, $FB
  Data.b $9A, $94, $86, $88, $A2, $AC, $BE, $B0, $EA, $E4, $F6, $F8, $D2, $DC, $CE, $C0
  Data.b $7A, $74, $66, $68, $42, $4C, $5E, $50, $0A, $04, $16, $18, $32, $3C, $2E, $20
  Data.b $EC, $E2, $F0, $FE, $D4, $DA, $C8, $C6, $9C, $92, $80, $8E, $A4, $AA, $B8, $B6
  Data.b $0C, $02, $10, $1E, $34, $3A, $28, $26, $7C, $72, $60, $6E, $44, $4A, $58, $56
  Data.b $37, $39, $2B, $25, $0F, $01, $13, $1D, $47, $49, $5B, $55, $7F, $71, $63, $6D
  Data.b $D7, $D9, $CB, $C5, $EF, $E1, $F3, $FD, $A7, $A9, $BB, $B5, $9F, $91, $83, $8D
RCon:                        ;wird für En-und Decrypt benötigt
  Data.l $1, $2, $4, $8, $10, $20, $40, $80, $1b, $36 
EndDataSection