XProfan & 64-Bit - Paules-PC-Forum.de

**Frabbing** · 01.01.2010, 18:09

Hier bitte 64-Bit Themen zu XProfan posten. Sollte der Thread seinen Rahmen sprengen, wird er zu einem eigenen Unterforum umgewandelt. Bislang aber erst einmal testweise in dieser Form.

Weitere 64-Bit-Threads
64 Bit - XProfan
Dateidialoge unter 64Bit zum korrekten Funktionieren bringen
Suche dringend Leute mit 64Bit Betriebsystemen...

**AHT** · 03.01.2010, 12:52

Das Grundproblem

Das eigentlich Problem, das sich ergibt wenn man 32Bit Programme auf 64Bit Systemen laufen lassen möchte, lässt sich sehr leicht rechnerisch darlegen:

Code:

2^32 = 4294967296

Auf einem 32Bit System können also virtuelle Adressen von 0 bis 4294967296 vergeben werden, mehr geht nicht. Davon wird unter NT basierenden Systemen in der Regel die Hälfte für die Nutzung durch Usermode-Programme und ihre DLLs vorgesehen, die andere Hälfte erhält der Kernel mit seinen Treibern.

Code:

2^64 = 18446744073709551616

Wie man daraus sieht, können unter 64Bit sehr viel höhere Adressen verwaltet werden. DLLs können in höhere Adressbereiche geladen werden und sie können ihre Variablen in höhere Bereiche schreiben - Bereiche, die ein 32Bit Programm nicht auslesen kann, da der Zahlenbereich dort gar nicht so hoch reicht.
Was würde nun passieren, wenn ein 32Bit Programm 64Bit Dlls verwenden würde? Ganz einfach, es würde gewaltig crashen

!

Programmierung funktioniert über API - und API ist nichts anderes als das Ansprechen von Funktionen in vom jeweiligen Programm geladenen
System-DLLs.
Ooops

- 64Bit DLLs können von einem 32Bit Programm ja gar nicht verwendet werden! Wie regelt M$ das bloß, das auch 32Bit Programme auf 64Bit laufen?
Ganz einfach, M$ liefert ganz locker einen zweiten Satz DLLs für 32Bit mit.
Das Problem dabei: Alle Programme laden System-DLLs aus dem Systemverzeichnis (manchmal mit und manchmal ohne Pfadangabe) - und im selben Verzeichnis können sich nicht zwei verschiedene DLLs mit gleichem Namen befinden (einmal für 32Bit und einmal für 64Bit)! 32Bit Programme laufen deshalb in einem Emulator (genannt WOW64), der 32Bit Programmen eine ganz andere Oberfläche vorgaukelt und nebenbei auch Pfade umbiegt.
Unter anderem aus diesem "Umbiegen" heraus ergeben sich einige Spezialitäten bei der Programmierung, die man beachten muss, damit ein 32Bit Programm unter 64Bit lauffähig ist und nicht falsch reagiert.
Um diese Spezialitäten soll es hier gehen - unter anderem mit Quellcodebeispielen.

**AHT** · 04.01.2010, 23:46

Auf 64Bit System testen

Am Anfang ist es erst einmal wichtig zu wissen, ob der eigene 32Bit Prozess überhaupt auf einem 64Bit System läuft oder nicht. Dieser Code wird später noch öfters benötigt, deswegen schreibe ich ihn hier erst mal separat hin:

Code:

'#####################################################################################
'#########    Code von AHT nach einem Beispiel von Andreas Miethe            #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
 
Declare Module$, MHANDLE&, Funktion$
Declare 64Bit&
 
Module$="Kernel32.DLL"
Funktion$="IsWow64Process"
MHANDLE&=GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
 
IF 64Bit&=1
 Print "64Bit System"
else
 Print "32Bit System"
endif
Waitkey

Die Abfrage mit GetProcAdress dient eigentlich nur dazu, um den Code auch unter älteren Systemen lauffähig zu halten. Die Variable 64Bit erhält unter einem 64Bit System den Wert 1, unter einem 32Bit System den Wert 0.

**Frabbing** · 04.01.2010, 23:48

Ja, genau. Danach wollte ich schon gefragt haben.

**AHT** · 05.01.2010, 15:02

Die Umleitung von Systemordnern und ihre Aufhebung

Wie ich schon angemerkt habe, biegt der WOW64 Emulator unter 64Bit für die 32Bit Programme unter anderem Pfade um. "Umbiegen" heißt, er leitet sämtliche Zugriffe auf den Ordner System32 ($SYSPATH) im Windows Installationsordner in den Ordner SysWOW64 im Windowsordner ($WINPATH+"\"+"SysWOW64") um. Diese Umleitung besteht auch für die meisten Unterordner von System32, zum Beispiel für den Ordner System32\Drivers.
Wenn man sich das sämtliche einmal etwas auf der Zunge zergehen lässt, wird man wohl jetzt schon merken, dass das zu ganz gewaltigen Verwicklungen führen kann, auf die ich später noch eingehen werde. Es muss also eine Möglichkeit vorhanden sein, diese Umleitung bei Bedarf aufzuheben - und diese Möglichkeit gibt es auch. Nötig dazu sind zwei APIs, eine hebt die Umleitung auf, die andere aktiviert sie wieder. Eine Aktivierung bzw. Deaktivierung der Umleitung erfolgt immer nur für den aktuellen Thread, nicht für das ganze Programm.
Hier ist der Code dazu:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
 
Declare Wow64DisableWow64FsRedirection&, OldValue&
Declare Wow64EnableWow64FsRedirection&
Declare Module$, MHANDLE&, Funktion$
Declare 64Bit&
 
'Adressen der APIs ermitteln
Module$ = "Kernel32.DLL"
MHANDLE& = GetModuleHandle(ADDR(Module$))
Funktion$ = "Wow64DisableWow64FsRedirection"
Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
Funktion$ = "Wow64EnableWow64FsRedirection"
Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
 
'Auf 64Bit testen
Funktion$ = "IsWow64Process"
MHANDLE& = GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
 
'Umleitung deaktivieren
IF 64Bit& = 1 : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
 
'Umleitung aktivieren
IF 64Bit& = 1 : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif

Bei den Codes zum Deaktivieren und zum Aktivieren der Umleitung fällt einiges an Besonderheiten auf:

1. ) Die APIs werden über Call angesprochen, nicht über External, DEF oder die Header von Profan.
Da die Umleitung aufgehoben wird, bevor der Befehl External beendet wurde, bin ich mir nicht sicher, ob beim Ansprechen der API über eine andere Art und Weise als durch Call Profan immer mit der richtigen DLL hantiert. Ich rate deshalb erst mal an, das ebenso zu machen.

2. ) Vor dem Aufruf der API zum Aufheben der Umleitung wird der FastMode auf 1 gesetzt und erst nach der Reaktivierung der Umleitung wieder auf 0.
Während die Dateiumleitung sollten keine Messages verarbeitet werden. Würden, während der Zeit, in der die Umleitung deaktiviert ist, Profan Subclassingroutinen aufgerufen werden, würde Profan unter Umständen versuchen, die DLLs aus dem 64Bit Ordner zu laden - das wäre tötlich.

Wichtig: Sämtliche API Aufrufe, die erfolgen während die Umleitung deaktiviert ist, müssen über den Call Befehl erfolgen, da sonst versucht wird, falsche DLLs zu laden. Die Adresse für den Call Befehl muss ermittelt werden, bevor die Umleitung deaktiviert wird!
Die Umleitung sollte nur solange deaktiviert bleiben, wie dies unbedingt erforderlich ist. Danach sollte sie sofort wieder reaktiviert werden!

**AHT** · 05.01.2010, 15:23

Das Codewort SysNative

Neben der schon beschriebenen Deaktivierung der Umleitung des Dateisystems gibt es eine zweite Möglichkeit, von einem 32Bit Programm aus Zugriff auf den SYSTEM32 ($SYSPATH) Ordner zu erhalten - die Verwendung des Codewortes Sysnative anstatt System32.
Das heißt: Für C:\Windows\System32 einfach C:\Windows\Sysnative schreiben - das wars.

Wichtig: Bei manchen Sachen ist es unideal, den Zugriffs mittels Codewort zu regeln, manche APIs funktionieren aber scheinbar nur mittels dieses Codewortes und nicht mit deaktivierter Umleitung! Näheres dazu kommt später.

**AHT** · 05.01.2010, 17:51

Der Profan 32Bit Befehl FileSize auf 64Bit Systemen

Aufgrund der schon erwähnten Umleitung des Dateisystems reagiert der Profanbefehl FileSize in der Regel nicht korrekt, wenn die Dateigröße einer Datei ausgelesen werden soll, die sich in dem Ordner System32 oder einem seiner Unterordner befindet. Hier ist Code zum Testen:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
 
Declare File$, Edit&, Checkbox&, Button&, Wow64DisableWow64FsRedirection&, OldValue&
Declare Wow64EnableWow64FsRedirection&
Declare Module$, MHANDLE&, Funktion$
Declare 64Bit&
 
Module$ = "Kernel32.DLL"
MHANDLE& = GetModuleHandle(ADDR(Module$))
Funktion$ = "Wow64DisableWow64FsRedirection"
Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
Funktion$ = "Wow64EnableWow64FsRedirection"
Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
 
Funktion$ = "IsWow64Process"
MHANDLE& = GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
 
Windowstyle 31
WindowTitle "FileSize Test"
Window 0, 0 - 640, 440
Decimals 0
 
Edit& = Create("Edit", %HWND, "C:\Windows\System32\NTDLL.DLL", 20, 20, 500, 30)
Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
 
Repeat
 Waitinput
 IF Clicked(Button&)
  EnableWindow Checkbox&, 0
  EnableWindow Button&, 0
  Locate 12, 0
  File$ = Gettext$(Edit&)
  IF File$ <> ""
   'Umleitung deaktivieren
   IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
   IF FileExists(File$)
    Print "Größe von " + File$ + ": " + Str$(FileSize(File$))+" Bytes                                            "
   else
    Print File$ + " existiert nicht!"+"                                                             "
   endif
   'Umleitung aktivieren
   IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
  endif
  EnableWindow Checkbox&, 1
  EnableWindow Button&, 1
 Else
  File$ = " "
 endif
until File$ = ""

Ist die Checkbox nicht abgehakt und wird dann der Button Testen angeklickt, wird bei mir (Windows7 64Bit) für die NTDLL eine Dateigröße von 1289712 Bytes angegeben.

Ist die Checkbox abgehakt und wird dann Testen geklickt, steht dort 1736792 Bytes.

Warum ist das so? Ganz einfach - ist die Umleitung aktiv, wird die Größe der Datei C:\Windows\SysWOW64\ntdll.dll ermittelt; ist sie deaktiviert ermittelt der Code die Größe der wirklich angegebenen Datei C:\Windows\System32\ntdll.dll.

PS: Was für FileSize gilt, gilt natürlich auch für GetFAttr, GetFDate$, GetFTime$, ...

**AHT** · 05.01.2010, 18:30

Die Profan 32Bit Befehle DirExists und FileExists auf 64Bit Systemen

Man will öfters bei der Programmierung ganz gerne mal überprüfen, ob etwas, das der User eingegeben hat oder irgendwie anders ermittelt wurde eine Datei oder ein Ordner ist. Dafür eignen sich die Profanbefehle FileExists und DirExists recht gut - unter 64Bit machen aber auch dies Befehle im system32 Verzeichnis Probleme.
Hier ist Code zum Testen für DirExists:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
 
Declare Dir$, Edit&, Button&, Checkbox&, Wow64DisableWow64FsRedirection&, OldValue&
Declare Wow64EnableWow64FsRedirection&
Declare Module$, MHANDLE&, Funktion$
Declare 64Bit&
 
Module$ = "Kernel32.DLL"
MHANDLE& = GetModuleHandle(ADDR(Module$))
Funktion$ = "Wow64DisableWow64FsRedirection"
Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
Funktion$ = "Wow64EnableWow64FsRedirection"
Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
 
Funktion$ = "IsWow64Process"
MHANDLE& = GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
 
Windowstyle 31
WindowTitle "DirExists Test"
Window 0, 0 - 640, 440
 
Edit& = Create("Edit", %HWND, "C:\Windows\System32\Boot", 20, 20, 500, 30)
Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
 
Repeat
 Waitinput
 IF Clicked(Button&)
  EnableWindow Checkbox&, 0
  EnableWindow Button&, 0
  CLS
  Locate 12, 0
  Dir$ = Gettext$(Edit&)
  IF Dir$ <> ""
   'Umleitung deaktivieren
   IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
   IF DirExists(Dir$)
    Print Dir$ + " existiert!"
   else
    Print Dir$ + " existiert nicht!"
   endif
   'Umleitung aktivieren
   IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
   EnableWindow Checkbox&, 1
   EnableWindow Button&, 1
  endif
 Else
  Dir$ = " "
 endif
until Dir$ = ""

Ist die Checkbox nicht abgehakt und wird dann der Button Testen angeklickt, wird bei mir (Windows7 64Bit) zurückgemeldet, dass der Ordner C:\Windows\System32\Boot nicht existiert - schaut man in den WindowsExplorer, gibt es den Ordner aber.

Ist die Checkbox abgehakt und wird dann der Button Testen angeklickt, wird bei mir (Windows7 64Bit) zurückgemeldet, das der Orner existiert - was ja korrekt ist.

Wie ist das zu erklären? Ist die Umleitung aktiv, wird nicht im Ordner Boot im Verzeichnis C:\Windows\System32 auf seine Existenz hin überprüft, sondern der Ordner Boot im Verzeichnis von C:\Windows\SysWOW64 - und da existiert er nicht!

Gleiches gilt auch für FileExists - hier ist Code:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
 
Declare File$, Edit&, Checkbox&, Button&, Wow64DisableWow64FsRedirection&, OldValue&
Declare Wow64EnableWow64FsRedirection&
Declare Module$, MHANDLE&, Funktion$
Declare 64Bit&
 
Module$ = "Kernel32.DLL"
MHANDLE& = GetModuleHandle(ADDR(Module$))
Funktion$ = "Wow64DisableWow64FsRedirection"
Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
Funktion$ = "Wow64EnableWow64FsRedirection"
Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
 
Funktion$ = "IsWow64Process"
MHANDLE& = GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
 
Windowstyle 31
WindowTitle "FileExists Test"
Window 0, 0 - 640, 440
 
Edit& = Create("Edit", %HWND, "C:\Windows\System32\Drivers\ACPI.SYS", 20, 20, 500, 30)
Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
 
Repeat
 Waitinput
 IF Clicked(Button&)
  EnableWindow Checkbox&, 0
  EnableWindow Button&, 0
  CLS
  Locate 12, 0
  File$ = Gettext$(Edit&)
  IF File$ <> ""
   'Umleitung deaktivieren
   IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
   IF FileExists(File$)
    Print File$ + " existiert!"
   else
    Print File$ + " existiert nicht!"
   endif
   'Umleitung aktivieren
   IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
  endif
  EnableWindow Checkbox&, 1
  EnableWindow Button&, 1
 Else
  File$ = " "
 endif
until File$ = ""

**AHT** · 06.01.2010, 14:51

Der Profan 32Bit Befehl FindFirst$ auf 64Bit Systemen

Die Tatsache, das alle Zugriffe auf den System32 umgeleitet werden, gilt natürlich auch für das Listing von Dateien. Wil man den Inhalt von C:\Windows\System32 listen, listet man, wenn die Dateiumleitung noch aktiviert ist, in wirklichkeit den Inhalt des Ordners C:\Windows\SysWow64.
Hier ein Quellcode, der mittels FindFirst$ Dateien im Ordner C:\Windows\System32\Drivers listen will

.

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
 
Declare File$, Edit&, Button&, Checkbox&, Wow64DisableWow64FsRedirection&, OldValue&
Declare Wow64EnableWow64FsRedirection&
Declare Module$, MHANDLE&, Funktion$, Dir$
Declare 64Bit&
 
Decimals 0
 
Module$ = "Kernel32.DLL"
MHANDLE& = GetModuleHandle(ADDR(Module$))
Funktion$ = "Wow64DisableWow64FsRedirection"
Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
Funktion$ = "Wow64EnableWow64FsRedirection"
Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
Funktion$ = "IsWow64Process"
MHANDLE& = GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
 
Windowstyle 31
WindowTitle "FindFirst$ Test"
Window 0, 0 - 640, 440
 
Edit& = Create("Edit", %HWND, "C:\Windows\System32\Drivers", 20, 20, 500, 30)
Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
 
Repeat
 Waitinput
 IF Clicked(Button&)
  EnableWindow Checkbox&, 0
  EnableWindow Button&, 0
  ClearList
  Dir$ = Gettext$(Edit&)
  'Umleitung deaktivieren
  IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
  File$ = FindFirst$(Dir$ + "\" + "*.*")
  'Umleitung aktivieren
  IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
  While File$<>""
   Locate 12, 0
   Print Dir$ + "\" + File$ + "                                           "
   'Umleitung deaktivieren
   IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
   IF (FileExists(Dir$ + "\" + File$) = 1) or (DirExists(Dir$ + "\" + File$) = 1)
    Assign #1, Dir$ + "\" + File$
    IF DirExists(Dir$ + "\" + File$) = 1
     Addstring Dir$ + "\" + File$ + ": Geändert-> " + GetFDate$(#1)
    elseif (FileExists(Dir$ + "\" + File$) = 1)
     Addstring Dir$ + "\" + File$ + ": Geändert-> " + GetFDate$(#1) + ", Größe -> " + Str$(FileSize(Dir$ + "\" + File$)) + " Bytes"
    endif
   endif
   'Umleitung aktivieren
   IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
   File$ = FindNext$()
  EndWhile
  EnableWindow Checkbox&, 1
  EnableWindow Button&, 1
  Editbox("Dateien in " + Dir$, 1)
 endif
until 0

Ist die Umleitung noch aktiviert, liefert bei mir der Code folgende Rückmeldung:

Code:

C:\Windows\System32\Drivers\gm.dls: Geändert-> 20090610, Größe -> 3440660 Bytes
C:\Windows\System32\Drivers\gmreadme.txt: Geändert-> 20090610, Größe -> 646 Bytes
C:\Windows\System32\Drivers\ssmdrv.sys: Geändert-> 20090511, Größe -> 28520 Bytes
C:\Windows\System32\Drivers\wimmount.sys: Geändert-> 20090714, Größe -> 19008 Bytes

Ist die Umleitung deaktiviert, listet der Code folgende Dateien:

Code:

C:\Windows\System32\Drivers\1394bus.sys: Geändert-> 20090714, Größe -> 68096 Bytes
C:\Windows\System32\Drivers\1394ohci.sys: Geändert-> 20090714, Größe -> 227840 Bytes
C:\Windows\System32\Drivers\acpi.sys: Geändert-> 20090714, Größe -> 334416 Bytes
C:\Windows\System32\Drivers\acpipmi.sys: Geändert-> 20090714, Größe -> 12288 Bytes
C:\Windows\System32\Drivers\adp94xx.sys: Geändert-> 20090714, Größe -> 491088 Bytes
C:\Windows\System32\Drivers\adpahci.sys: Geändert-> 20090714, Größe -> 339536 Bytes
C:\Windows\System32\Drivers\adpu320.sys: Geändert-> 20090714, Größe -> 182864 Bytes
C:\Windows\System32\Drivers\afd.sys: Geändert-> 20090714, Größe -> 500224 Bytes
C:\Windows\System32\Drivers\agilevpn.sys: Geändert-> 20090714, Größe -> 60416 Bytes
C:\Windows\System32\Drivers\AGP440.sys: Geändert-> 20090714, Größe -> 61008 Bytes
C:\Windows\System32\Drivers\aliide.sys: Geändert-> 20090714, Größe -> 15440 Bytes
C:\Windows\System32\Drivers\amdide.sys: Geändert-> 20090714, Größe -> 15440 Bytes
C:\Windows\System32\Drivers\amdk8.sys: Geändert-> 20090714, Größe -> 64512 Bytes
C:\Windows\System32\Drivers\amdppm.sys: Geändert-> 20090714, Größe -> 60928 Bytes
C:\Windows\System32\Drivers\amdsata.sys: Geändert-> 20090714, Größe -> 106576 Bytes
C:\Windows\System32\Drivers\amdsbs.sys: Geändert-> 20090714, Größe -> 194128 Bytes
C:\Windows\System32\Drivers\amdxata.sys: Geändert-> 20090714, Größe -> 28752 Bytes
C:\Windows\System32\Drivers\appid.sys: Geändert-> 20090714, Größe -> 61440 Bytes
C:\Windows\System32\Drivers\arc.sys: Geändert-> 20090714, Größe -> 87632 Bytes
C:\Windows\System32\Drivers\arcsas.sys: Geändert-> 20090714, Größe -> 97856 Bytes
C:\Windows\System32\Drivers\asyncmac.sys: Geändert-> 20090714, Größe -> 23040 Bytes
C:\Windows\System32\Drivers\atapi.sys: Geändert-> 20090714, Größe -> 24128 Bytes
C:\Windows\System32\Drivers\ataport.sys: Geändert-> 20090714, Größe -> 155728 Bytes
C:\Windows\System32\Drivers\athrx.sys: Geändert-> 20090620, Größe -> 1394688 Bytes
C:\Windows\System32\Drivers\avgntflt.sys: Geändert-> 20091125, Größe -> 74880 Bytes
C:\Windows\System32\Drivers\b57nd60a.sys: Geändert-> 20090610, Größe -> 270848 Bytes
C:\Windows\System32\Drivers\battc.sys: Geändert-> 20090714, Größe -> 28240 Bytes
C:\Windows\System32\Drivers\beep.sys: Geändert-> 20090714, Größe -> 6656 Bytes
C:\Windows\System32\Drivers\blbdrive.sys: Geändert-> 20090714, Größe -> 45056 Bytes
C:\Windows\System32\Drivers\bowser.sys: Geändert-> 20090714, Größe -> 90624 Bytes
C:\Windows\System32\Drivers\BrFiltLo.sys: Geändert-> 20090610, Größe -> 18432 Bytes
C:\Windows\System32\Drivers\BrFiltUp.sys: Geändert-> 20090610, Größe -> 8704 Bytes
C:\Windows\System32\Drivers\bridge.sys: Geändert-> 20090714, Größe -> 95232 Bytes
C:\Windows\System32\Drivers\BrSerId.sys: Geändert-> 20090714, Größe -> 286720 Bytes
C:\Windows\System32\Drivers\BrSerWdm.sys: Geändert-> 20090610, Größe -> 47104 Bytes
C:\Windows\System32\Drivers\BrUsbMdm.sys: Geändert-> 20090610, Größe -> 14976 Bytes
C:\Windows\System32\Drivers\BrUsbSer.sys: Geändert-> 20090610, Größe -> 14720 Bytes
C:\Windows\System32\Drivers\bthmodem.sys: Geändert-> 20090714, Größe -> 72192 Bytes
C:\Windows\System32\Drivers\bxvbda.sys: Geändert-> 20090610, Größe -> 468480 Bytes
C:\Windows\System32\Drivers\cdfs.sys: Geändert-> 20090714, Größe -> 92160 Bytes
C:\Windows\System32\Drivers\cdrom.sys: Geändert-> 20090714, Größe -> 147456 Bytes
C:\Windows\System32\Drivers\circlass.sys: Geändert-> 20090714, Größe -> 45568 Bytes
C:\Windows\System32\Drivers\Classpnp.sys: Geändert-> 20090714, Größe -> 178752 Bytes
C:\Windows\System32\Drivers\CmBatt.sys: Geändert-> 20090714, Größe -> 17664 Bytes
C:\Windows\System32\Drivers\cmdide.sys: Geändert-> 20090714, Größe -> 17488 Bytes
C:\Windows\System32\Drivers\cng.sys: Geändert-> 20090714, Größe -> 460504 Bytes
C:\Windows\System32\Drivers\compbatt.sys: Geändert-> 20090714, Größe -> 21584 Bytes
C:\Windows\System32\Drivers\CompositeBus.sys: Geändert-> 20090714, Größe -> 38912 Bytes
C:\Windows\System32\Drivers\CPQBttn64.sys: Geändert-> 20090420, Größe -> 11264 Bytes
C:\Windows\System32\Drivers\crashdmp.sys: Geändert-> 20090714, Größe -> 39504 Bytes
C:\Windows\System32\Drivers\crcdisk.sys: Geändert-> 20090714, Größe -> 24144 Bytes
C:\Windows\System32\Drivers\dfsc.sys: Geändert-> 20090714, Größe -> 102400 Bytes
C:\Windows\System32\Drivers\discache.sys: Geändert-> 20090714, Größe -> 40448 Bytes
C:\Windows\System32\Drivers\disk.sys: Geändert-> 20090714, Größe -> 73280 Bytes
C:\Windows\System32\Drivers\Diskdump.sys: Geändert-> 20090714, Größe -> 27216 Bytes
C:\Windows\System32\Drivers\drmk.sys: Geändert-> 20090714, Größe -> 116224 Bytes
C:\Windows\System32\Drivers\drmkaud.sys: Geändert-> 20090714, Größe -> 5632 Bytes
C:\Windows\System32\Drivers\Dumpata.sys: Geändert-> 20090714, Größe -> 28736 Bytes
C:\Windows\System32\Drivers\dumpfve.sys: Geändert-> 20090714, Größe -> 55128 Bytes
C:\Windows\System32\Drivers\dxapi.sys: Geändert-> 20090714, Größe -> 16896 Bytes
C:\Windows\System32\Drivers\dxg.sys: Geändert-> 20090714, Größe -> 98816 Bytes
C:\Windows\System32\Drivers\dxgkrnl.sys: Geändert-> 20091002, Größe -> 982600 Bytes
C:\Windows\System32\Drivers\dxgmms1.sys: Geändert-> 20090714, Größe -> 258048 Bytes
C:\Windows\System32\Drivers\elxstor.sys: Geändert-> 20090714, Größe -> 530496 Bytes
C:\Windows\System32\Drivers\errdev.sys: Geändert-> 20090714, Größe -> 9728 Bytes
C:\Windows\System32\Drivers\evbda.sys: Geändert-> 20090610, Größe -> 3286016 Bytes
C:\Windows\System32\Drivers\exfat.sys: Geändert-> 20090714, Größe -> 195072 Bytes
C:\Windows\System32\Drivers\fastfat.sys: Geändert-> 20090714, Größe -> 204800 Bytes
C:\Windows\System32\Drivers\fdc.sys: Geändert-> 20090714, Größe -> 29696 Bytes
C:\Windows\System32\Drivers\fileinfo.sys: Geändert-> 20090714, Größe -> 70224 Bytes
C:\Windows\System32\Drivers\filetrace.sys: Geändert-> 20090714, Größe -> 34304 Bytes
C:\Windows\System32\Drivers\flpydisk.sys: Geändert-> 20090714, Größe -> 24576 Bytes
C:\Windows\System32\Drivers\fltMgr.sys: Geändert-> 20090714, Größe -> 290368 Bytes
C:\Windows\System32\Drivers\fsdepends.sys: Geändert-> 20090714, Größe -> 55376 Bytes
C:\Windows\System32\Drivers\fs_rec.sys: Geändert-> 20090714, Größe -> 23104 Bytes
C:\Windows\System32\Drivers\fvevol.sys: Geändert-> 20090714, Größe -> 223448 Bytes
C:\Windows\System32\Drivers\FWPKCLNT.SYS: Geändert-> 20090714, Größe -> 288336 Bytes
C:\Windows\System32\Drivers\GAGP30KX.SYS: Geändert-> 20090714, Größe -> 65088 Bytes
C:\Windows\System32\Drivers\gm.dls: Geändert-> 20090610, Größe -> 3440660 Bytes
C:\Windows\System32\Drivers\gmreadme.txt: Geändert-> 20090610, Größe -> 646 Bytes
C:\Windows\System32\Drivers\hcw85cir.sys: Geändert-> 20090610, Größe -> 31232 Bytes
C:\Windows\System32\Drivers\hdaudbus.sys: Geändert-> 20090714, Größe -> 122368 Bytes
C:\Windows\System32\Drivers\HdAudio.sys: Geändert-> 20090714, Größe -> 350208 Bytes
C:\Windows\System32\Drivers\hidbatt.sys: Geändert-> 20090714, Größe -> 26624 Bytes
C:\Windows\System32\Drivers\hidbth.sys: Geändert-> 20090714, Größe -> 100864 Bytes
C:\Windows\System32\Drivers\hidclass.sys: Geändert-> 20090714, Größe -> 76288 Bytes
C:\Windows\System32\Drivers\hidir.sys: Geändert-> 20090714, Größe -> 46592 Bytes
C:\Windows\System32\Drivers\hidparse.sys: Geändert-> 20090714, Größe -> 32896 Bytes
C:\Windows\System32\Drivers\hidusb.sys: Geändert-> 20090714, Größe -> 30208 Bytes
C:\Windows\System32\Drivers\HpSAMD.sys: Geändert-> 20090714, Größe -> 77888 Bytes
C:\Windows\System32\Drivers\http.sys: Geändert-> 20090714, Größe -> 751616 Bytes
C:\Windows\System32\Drivers\hwpolicy.sys: Geändert-> 20090714, Größe -> 14416 Bytes
C:\Windows\System32\Drivers\i8042prt.sys: Geändert-> 20090714, Größe -> 105472 Bytes
C:\Windows\System32\Drivers\iaStorV.sys: Geändert-> 20090714, Größe -> 410688 Bytes
C:\Windows\System32\Drivers\iirsp.sys: Geändert-> 20090714, Größe -> 44112 Bytes
C:\Windows\System32\Drivers\intelide.sys: Geändert-> 20090714, Größe -> 16960 Bytes
C:\Windows\System32\Drivers\intelppm.sys: Geändert-> 20090714, Größe -> 62464 Bytes
C:\Windows\System32\Drivers\ipfltdrv.sys: Geändert-> 20090714, Größe -> 82944 Bytes
C:\Windows\System32\Drivers\IPMIDrv.sys: Geändert-> 20090714, Größe -> 78848 Bytes
C:\Windows\System32\Drivers\ipnat.sys: Geändert-> 20090714, Größe -> 116224 Bytes
C:\Windows\System32\Drivers\irda.sys: Geändert-> 20090714, Größe -> 120320 Bytes
C:\Windows\System32\Drivers\irenum.sys: Geändert-> 20090714, Größe -> 17920 Bytes
C:\Windows\System32\Drivers\isapnp.sys: Geändert-> 20090714, Größe -> 20544 Bytes
C:\Windows\System32\Drivers\kbdclass.sys: Geändert-> 20090714, Größe -> 50768 Bytes
C:\Windows\System32\Drivers\kbdhid.sys: Geändert-> 20090714, Größe -> 33280 Bytes
C:\Windows\System32\Drivers\ks.sys: Geändert-> 20090714, Größe -> 243200 Bytes
C:\Windows\System32\Drivers\ksecdd.sys: Geändert-> 20090714, Größe -> 95312 Bytes
C:\Windows\System32\Drivers\ksecpkg.sys: Geändert-> 20090714, Größe -> 153152 Bytes
C:\Windows\System32\Drivers\ksthunk.sys: Geändert-> 20090714, Größe -> 20992 Bytes
C:\Windows\System32\Drivers\lltdio.sys: Geändert-> 20090714, Größe -> 60928 Bytes
C:\Windows\System32\Drivers\lsi_fc.sys: Geändert-> 20090714, Größe -> 114752 Bytes
C:\Windows\System32\Drivers\lsi_sas.sys: Geändert-> 20090714, Größe -> 106560 Bytes
C:\Windows\System32\Drivers\lsi_sas2.sys: Geändert-> 20090714, Größe -> 65600 Bytes
C:\Windows\System32\Drivers\lsi_scsi.sys: Geändert-> 20090714, Größe -> 115776 Bytes
C:\Windows\System32\Drivers\luafv.sys: Geändert-> 20090714, Größe -> 113152 Bytes
C:\Windows\System32\Drivers\mcd.sys: Geändert-> 20090714, Größe -> 22016 Bytes
C:\Windows\System32\Drivers\megasas.sys: Geändert-> 20090714, Größe -> 35392 Bytes
C:\Windows\System32\Drivers\MegaSR.sys: Geändert-> 20090714, Größe -> 284736 Bytes
C:\Windows\System32\Drivers\modem.sys: Geändert-> 20090714, Größe -> 40448 Bytes
C:\Windows\System32\Drivers\monitor.sys: Geändert-> 20090714, Größe -> 30208 Bytes
C:\Windows\System32\Drivers\mouclass.sys: Geändert-> 20090714, Größe -> 49216 Bytes
C:\Windows\System32\Drivers\mouhid.sys: Geändert-> 20090714, Größe -> 31232 Bytes
C:\Windows\System32\Drivers\mountmgr.sys: Geändert-> 20090714, Größe -> 94784 Bytes
C:\Windows\System32\Drivers\mpio.sys: Geändert-> 20090714, Größe -> 155216 Bytes
C:\Windows\System32\Drivers\mpsdrv.sys: Geändert-> 20090714, Größe -> 77312 Bytes
C:\Windows\System32\Drivers\mrxdav.sys: Geändert-> 20090714, Größe -> 140800 Bytes
C:\Windows\System32\Drivers\mrxsmb.sys: Geändert-> 20090714, Größe -> 157184 Bytes
C:\Windows\System32\Drivers\mrxsmb10.sys: Geändert-> 20090714, Größe -> 285696 Bytes
C:\Windows\System32\Drivers\mrxsmb20.sys: Geändert-> 20090714, Größe -> 125952 Bytes
C:\Windows\System32\Drivers\msahci.sys: Geändert-> 20090714, Größe -> 30272 Bytes
C:\Windows\System32\Drivers\msdsm.sys: Geändert-> 20090714, Größe -> 140352 Bytes
C:\Windows\System32\Drivers\msfs.sys: Geändert-> 20090714, Größe -> 26112 Bytes
C:\Windows\System32\Drivers\MsftWdf_Kernel_01009_Inbox_Critical.Wdf: Geändert-> 20090610, Größe -> 3 Bytes
C:\Windows\System32\Drivers\mshidkmdf.sys: Geändert-> 20090714, Größe -> 8192 Bytes
C:\Windows\System32\Drivers\msisadrv.sys: Geändert-> 20090714, Größe -> 15424 Bytes
C:\Windows\System32\Drivers\msiscsi.sys: Geändert-> 20090714, Größe -> 224832 Bytes
C:\Windows\System32\Drivers\mskssrv.sys: Geändert-> 20090714, Größe -> 11136 Bytes
C:\Windows\System32\Drivers\mspclock.sys: Geändert-> 20090714, Größe -> 7168 Bytes
C:\Windows\System32\Drivers\mspqm.sys: Geändert-> 20090714, Größe -> 6784 Bytes
C:\Windows\System32\Drivers\msrpc.sys: Geändert-> 20090714, Größe -> 367168 Bytes
C:\Windows\System32\Drivers\mssmbios.sys: Geändert-> 20090714, Größe -> 32320 Bytes
C:\Windows\System32\Drivers\mstee.sys: Geändert-> 20090714, Größe -> 8064 Bytes
C:\Windows\System32\Drivers\MTConfig.sys: Geändert-> 20090714, Größe -> 15360 Bytes
C:\Windows\System32\Drivers\mup.sys: Geändert-> 20090714, Größe -> 60496 Bytes
C:\Windows\System32\Drivers\ndis.sys: Geändert-> 20090714, Größe -> 947776 Bytes
C:\Windows\System32\Drivers\ndiscap.sys: Geändert-> 20090714, Größe -> 35328 Bytes
C:\Windows\System32\Drivers\ndistapi.sys: Geändert-> 20090714, Größe -> 24064 Bytes
C:\Windows\System32\Drivers\ndisuio.sys: Geändert-> 20090714, Größe -> 56320 Bytes
C:\Windows\System32\Drivers\ndiswan.sys: Geändert-> 20090714, Größe -> 164352 Bytes
C:\Windows\System32\Drivers\ndproxy.sys: Geändert-> 20090714, Größe -> 57856 Bytes
C:\Windows\System32\Drivers\netbios.sys: Geändert-> 20090714, Größe -> 44544 Bytes
C:\Windows\System32\Drivers\netbt.sys: Geändert-> 20090714, Größe -> 259072 Bytes
C:\Windows\System32\Drivers\netio.sys: Geändert-> 20090714, Größe -> 374864 Bytes
C:\Windows\System32\Drivers\nfrd960.sys: Geändert-> 20090714, Größe -> 51264 Bytes
C:\Windows\System32\Drivers\npfs.sys: Geändert-> 20090714, Größe -> 44032 Bytes
C:\Windows\System32\Drivers\nsiproxy.sys: Geändert-> 20090714, Größe -> 24576 Bytes
C:\Windows\System32\Drivers\ntfs.sys: Geändert-> 20090714, Größe -> 1659984 Bytes
C:\Windows\System32\Drivers\null.sys: Geändert-> 20090714, Größe -> 6144 Bytes
C:\Windows\System32\Drivers\nvlddmkm.sys: Geändert-> 20090306, Größe -> 9677600 Bytes
C:\Windows\System32\Drivers\nvm62x64.sys: Geändert-> 20090610, Größe -> 408960 Bytes
C:\Windows\System32\Drivers\nvraid.sys: Geändert-> 20090714, Größe -> 149056 Bytes
C:\Windows\System32\Drivers\nvstor.sys: Geändert-> 20090714, Größe -> 167488 Bytes
C:\Windows\System32\Drivers\NV_AGP.SYS: Geändert-> 20090714, Größe -> 122960 Bytes
C:\Windows\System32\Drivers\nwifi.sys: Geändert-> 20090714, Größe -> 318976 Bytes
C:\Windows\System32\Drivers\ohci1394.sys: Geändert-> 20090714, Größe -> 72832 Bytes
C:\Windows\System32\Drivers\pacer.sys: Geändert-> 20090714, Größe -> 131584 Bytes
C:\Windows\System32\Drivers\parport.sys: Geändert-> 20090714, Größe -> 97280 Bytes
C:\Windows\System32\Drivers\partmgr.sys: Geändert-> 20090714, Größe -> 75840 Bytes
C:\Windows\System32\Drivers\pci.sys: Geändert-> 20090714, Größe -> 183872 Bytes
C:\Windows\System32\Drivers\pciide.sys: Geändert-> 20090714, Größe -> 12352 Bytes
C:\Windows\System32\Drivers\pciidex.sys: Geändert-> 20090714, Größe -> 48720 Bytes
C:\Windows\System32\Drivers\pcmcia.sys: Geändert-> 20090714, Größe -> 220752 Bytes
C:\Windows\System32\Drivers\pcw.sys: Geändert-> 20090714, Größe -> 50768 Bytes
C:\Windows\System32\Drivers\PEAuth.sys: Geändert-> 20090714, Größe -> 651264 Bytes
C:\Windows\System32\Drivers\portcls.sys: Geändert-> 20090714, Größe -> 230400 Bytes
C:\Windows\System32\Drivers\processr.sys: Geändert-> 20090714, Größe -> 60416 Bytes
C:\Windows\System32\Drivers\ql2300.sys: Geändert-> 20090714, Größe -> 1524816 Bytes
C:\Windows\System32\Drivers\ql40xx.sys: Geändert-> 20090714, Größe -> 128592 Bytes
C:\Windows\System32\Drivers\qwavedrv.sys: Geändert-> 20090714, Größe -> 46592 Bytes
C:\Windows\System32\Drivers\rasacd.sys: Geändert-> 20090714, Größe -> 14848 Bytes
C:\Windows\System32\Drivers\rasl2tp.sys: Geändert-> 20090714, Größe -> 130048 Bytes
C:\Windows\System32\Drivers\raspppoe.sys: Geändert-> 20090714, Größe -> 92672 Bytes
C:\Windows\System32\Drivers\raspptp.sys: Geändert-> 20090714, Größe -> 111616 Bytes
C:\Windows\System32\Drivers\rassstp.sys: Geändert-> 20090714, Größe -> 83968 Bytes
C:\Windows\System32\Drivers\rdbss.sys: Geändert-> 20090714, Größe -> 309248 Bytes
C:\Windows\System32\Drivers\rdpbus.sys: Geändert-> 20090714, Größe -> 24064 Bytes
C:\Windows\System32\Drivers\RDPCDD.sys: Geändert-> 20090714, Größe -> 7680 Bytes
C:\Windows\System32\Drivers\RDPENCDD.sys: Geändert-> 20090714, Größe -> 7680 Bytes
C:\Windows\System32\Drivers\RDPREFMP.sys: Geändert-> 20090714, Größe -> 8192 Bytes
C:\Windows\System32\Drivers\rdpwd.sys: Geändert-> 20090714, Größe -> 204800 Bytes
C:\Windows\System32\Drivers\rdyboost.sys: Geändert-> 20090714, Größe -> 214096 Bytes
C:\Windows\System32\Drivers\rmcast.sys: Geändert-> 20090714, Größe -> 145920 Bytes
C:\Windows\System32\Drivers\RNDISMP.sys: Geändert-> 20090714, Größe -> 41472 Bytes
C:\Windows\System32\Drivers\rootmdm.sys: Geändert-> 20090714, Größe -> 11264 Bytes
C:\Windows\System32\Drivers\rspndr.sys: Geändert-> 20090714, Größe -> 76800 Bytes
C:\Windows\System32\Drivers\sbp2port.sys: Geändert-> 20090714, Größe -> 104016 Bytes
C:\Windows\System32\Drivers\scfilter.sys: Geändert-> 20090714, Größe -> 29696 Bytes
C:\Windows\System32\Drivers\scsiport.sys: Geändert-> 20090714, Größe -> 171600 Bytes
C:\Windows\System32\Drivers\secdrv.sys: Geändert-> 20090610, Größe -> 23040 Bytes
C:\Windows\System32\Drivers\serenum.sys: Geändert-> 20090714, Größe -> 23552 Bytes
C:\Windows\System32\Drivers\serial.sys: Geändert-> 20090714, Größe -> 94208 Bytes
C:\Windows\System32\Drivers\sermouse.sys: Geändert-> 20090714, Größe -> 26624 Bytes
C:\Windows\System32\Drivers\sffdisk.sys: Geändert-> 20090714, Größe -> 14336 Bytes
C:\Windows\System32\Drivers\sffp_mmc.sys: Geändert-> 20090714, Größe -> 13824 Bytes
C:\Windows\System32\Drivers\sffp_sd.sys: Geändert-> 20090714, Größe -> 14336 Bytes
C:\Windows\System32\Drivers\sfloppy.sys: Geändert-> 20090714, Größe -> 16896 Bytes
C:\Windows\System32\Drivers\sisraid2.sys: Geändert-> 20090714, Größe -> 43584 Bytes
C:\Windows\System32\Drivers\sisraid4.sys: Geändert-> 20090714, Größe -> 80464 Bytes
C:\Windows\System32\Drivers\smb.sys: Geändert-> 20090714, Größe -> 93184 Bytes
C:\Windows\System32\Drivers\smclib.sys: Geändert-> 20090714, Größe -> 20992 Bytes
C:\Windows\System32\Drivers\spldr.sys: Geändert-> 20090714, Größe -> 19008 Bytes
C:\Windows\System32\Drivers\spsys.sys: Geändert-> 20090610, Größe -> 426496 Bytes
C:\Windows\System32\Drivers\srv.sys: Geändert-> 20090714, Größe -> 465408 Bytes
C:\Windows\System32\Drivers\srv2.sys: Geändert-> 20090714, Größe -> 407040 Bytes
C:\Windows\System32\Drivers\srvnet.sys: Geändert-> 20090714, Größe -> 162816 Bytes
C:\Windows\System32\Drivers\stexstor.sys: Geändert-> 20090714, Größe -> 24656 Bytes
C:\Windows\System32\Drivers\storport.sys: Geändert-> 20090714, Größe -> 185936 Bytes
C:\Windows\System32\Drivers\stream.sys: Geändert-> 20090714, Größe -> 68864 Bytes
C:\Windows\System32\Drivers\swenum.sys: Geändert-> 20090714, Größe -> 12496 Bytes
C:\Windows\System32\Drivers\tape.sys: Geändert-> 20090714, Größe -> 29184 Bytes
C:\Windows\System32\Drivers\tcpip.sys: Geändert-> 20090714, Größe -> 1898576 Bytes
C:\Windows\System32\Drivers\tcpipreg.sys: Geändert-> 20090714, Größe -> 44544 Bytes
C:\Windows\System32\Drivers\tdi.sys: Geändert-> 20090714, Größe -> 26624 Bytes
C:\Windows\System32\Drivers\tdpipe.sys: Geändert-> 20090714, Größe -> 15872 Bytes
C:\Windows\System32\Drivers\tdtcp.sys: Geändert-> 20090714, Größe -> 23552 Bytes
C:\Windows\System32\Drivers\tdx.sys: Geändert-> 20090714, Größe -> 99840 Bytes
C:\Windows\System32\Drivers\termdd.sys: Geändert-> 20090714, Größe -> 62544 Bytes
C:\Windows\System32\Drivers\tssecsrv.sys: Geändert-> 20090714, Größe -> 38400 Bytes
C:\Windows\System32\Drivers\tunnel.sys: Geändert-> 20090714, Größe -> 125440 Bytes
C:\Windows\System32\Drivers\UAGP35.SYS: Geändert-> 20090714, Größe -> 64080 Bytes
C:\Windows\System32\Drivers\udfs.sys: Geändert-> 20090714, Größe -> 327168 Bytes
C:\Windows\System32\Drivers\ULIAGPKX.SYS: Geändert-> 20090714, Größe -> 64592 Bytes
C:\Windows\System32\Drivers\umbus.sys: Geändert-> 20090714, Größe -> 48640 Bytes
C:\Windows\System32\Drivers\umpass.sys: Geändert-> 20090714, Größe -> 9728 Bytes
C:\Windows\System32\Drivers\usb8023.sys: Geändert-> 20090714, Größe -> 19968 Bytes
C:\Windows\System32\Drivers\USBCAMD2.sys: Geändert-> 20090714, Größe -> 32896 Bytes
C:\Windows\System32\Drivers\usbccgp.sys: Geändert-> 20090714, Größe -> 98816 Bytes
C:\Windows\System32\Drivers\usbcir.sys: Geändert-> 20090714, Größe -> 100352 Bytes
C:\Windows\System32\Drivers\usbd.sys: Geändert-> 20090714, Größe -> 7936 Bytes
C:\Windows\System32\Drivers\usbehci.sys: Geändert-> 20090714, Größe -> 51200 Bytes
C:\Windows\System32\Drivers\usbhub.sys: Geändert-> 20090714, Größe -> 343040 Bytes
C:\Windows\System32\Drivers\usbohci.sys: Geändert-> 20090714, Größe -> 25600 Bytes
C:\Windows\System32\Drivers\usbport.sys: Geändert-> 20090714, Größe -> 324608 Bytes
C:\Windows\System32\Drivers\usbprint.sys: Geändert-> 20090714, Größe -> 25088 Bytes
C:\Windows\System32\Drivers\usbrpm.sys: Geändert-> 20090714, Größe -> 31744 Bytes
C:\Windows\System32\Drivers\USBSTOR.SYS: Geändert-> 20090714, Größe -> 89600 Bytes
C:\Windows\System32\Drivers\usbuhci.sys: Geändert-> 20090714, Größe -> 30720 Bytes
C:\Windows\System32\Drivers\usbvideo.sys: Geändert-> 20090714, Größe -> 184576 Bytes
C:\Windows\System32\Drivers\vdrvroot.sys: Geändert-> 20090714, Größe -> 36432 Bytes
C:\Windows\System32\Drivers\vga.sys: Geändert-> 20090714, Größe -> 29184 Bytes
C:\Windows\System32\Drivers\vgapnp.sys: Geändert-> 20090714, Größe -> 29184 Bytes
C:\Windows\System32\Drivers\vhdmp.sys: Geändert-> 20090714, Größe -> 217680 Bytes
C:\Windows\System32\Drivers\viaide.sys: Geändert-> 20090714, Größe -> 17488 Bytes
C:\Windows\System32\Drivers\videoprt.sys: Geändert-> 20090714, Größe -> 129024 Bytes
C:\Windows\System32\Drivers\volmgr.sys: Geändert-> 20090714, Größe -> 71760 Bytes
C:\Windows\System32\Drivers\volmgrx.sys: Geändert-> 20090714, Größe -> 363584 Bytes
C:\Windows\System32\Drivers\volsnap.sys: Geändert-> 20090714, Größe -> 294992 Bytes
C:\Windows\System32\Drivers\vsmraid.sys: Geändert-> 20090714, Größe -> 161872 Bytes
C:\Windows\System32\Drivers\VSTAZL6.SYS: Geändert-> 20090610, Größe -> 292864 Bytes
C:\Windows\System32\Drivers\VSTCNXT6.SYS: Geändert-> 20090610, Größe -> 740864 Bytes
C:\Windows\System32\Drivers\VSTDPV6.SYS: Geändert-> 20090610, Größe -> 1485312 Bytes
C:\Windows\System32\Drivers\VSTProf.cty: Geändert-> 20090610, Größe -> 146036 Bytes
C:\Windows\System32\Drivers\vwifibus.sys: Geändert-> 20090714, Größe -> 24576 Bytes
C:\Windows\System32\Drivers\vwififlt.sys: Geändert-> 20090714, Größe -> 59904 Bytes
C:\Windows\System32\Drivers\vwifimp.sys: Geändert-> 20090714, Größe -> 17920 Bytes
C:\Windows\System32\Drivers\wacompen.sys: Geändert-> 20090714, Größe -> 27776 Bytes
C:\Windows\System32\Drivers\wanarp.sys: Geändert-> 20090714, Größe -> 88576 Bytes
C:\Windows\System32\Drivers\watchdog.sys: Geändert-> 20090714, Größe -> 42496 Bytes
C:\Windows\System32\Drivers\wd.sys: Geändert-> 20090714, Größe -> 21056 Bytes
C:\Windows\System32\Drivers\Wdf01000.sys: Geändert-> 20090714, Größe -> 654928 Bytes
C:\Windows\System32\Drivers\WdfLdr.sys: Geändert-> 20090714, Größe -> 42064 Bytes
C:\Windows\System32\Drivers\wfplwf.sys: Geändert-> 20090714, Größe -> 12800 Bytes
C:\Windows\System32\Drivers\wimmount.sys: Geändert-> 20090714, Größe -> 22096 Bytes
C:\Windows\System32\Drivers\wmiacpi.sys: Geändert-> 20090714, Größe -> 14336 Bytes
C:\Windows\System32\Drivers\wmilib.sys: Geändert-> 20090714, Größe -> 16464 Bytes
C:\Windows\System32\Drivers\ws2ifsl.sys: Geändert-> 20090714, Größe -> 21504 Bytes
C:\Windows\System32\Drivers\WUDFPf.sys: Geändert-> 20090714, Größe -> 112128 Bytes
C:\Windows\System32\Drivers\WUDFRd.sys: Geändert-> 20090714, Größe -> 172544 Bytes

Wie im Code zu sehen ist, muss für FindNext$ die Umleitung nicht deaktiviert werden!

**AHT** · 08.01.2010, 15:50

Welche APIs sind von der Umleitung des Dateisystems betroffen?

In der MSDN Dokumentation steht, das sämtliche Zugriffe umgeleitet werden - es müssten also eigentlich alle APIs betroffen sein, die in irgendeiner Art und Weise mit einem Pfad hantieren. In Wirklichkeit ist das aber nicht der Fall. Die APIs zum auslesen von Dateiresourcen (hier GetFileVersionInfoSize und GetFileVersionInfo) reagieren zum Beispiel ganz normal und landen im richtigen Verzeichnis.
Hier Code zum Testen:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
 
Def GetFileVersionInfoSize(2) !"VERSION", "GetFileVersionInfoSizeA"
DEf VerQueryValue(4) !"VERSION", "VerQueryValueA"
Def GetFileVersionInfo(4) !"VERSION", "GetFileVersionInfoA"
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
 
Declare FEHLER&, FILE$, Zero&, Info_Size&, FileInfoSize&, MODULEINFO#, FILE_VER_INFO&, FILE_VER_INFO#
Declare VERSION$, Ver_Value$
Declare Edit&, Button&, Checkbox&, Wow64DisableWow64FsRedirection&, OldValue&
Declare Wow64EnableWow64FsRedirection&, version&
Declare Module$, MHANDLE&, Funktion$
Declare 64Bit&, GetFileVersionInfoSizeA&
Declare GetFileVersionInfoA&, FILE_FEHLER&
version&=UseDLL("version.dll")
Funktion$ = "GetFileVersionInfoSizeA"
GetFileVersionInfoSizeA& = GetProcAddress(version&, ADDR(FUNKTION$))
Funktion$ = "GetFileVersionInfoA"
GetFileVersionInfoA& = GetProcAddress(version&, ADDR(FUNKTION$))
Module$ = "Kernel32.DLL"
MHANDLE& = GetModuleHandle(ADDR(Module$))
Funktion$ = "Wow64DisableWow64FsRedirection"
Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
Funktion$ = "Wow64EnableWow64FsRedirection"
Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
 
Funktion$ = "IsWow64Process"
MHANDLE& = GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
 
Windowstyle 31 + 512
WindowTitle "Resourcen Test"
Window 0, 0 - 640, 440
Usermessages $10
 
Edit& = Create("Edit", %HWND, "C:\Windows\System32\Drivers\ACPI.SYS", 20, 20, 500, 30)
Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
 
While %Umessage <> $10
 Waitinput
 IF Clicked(Button&)
  EnableWindow Checkbox&, 0
  EnableWindow Button&, 0
  CLS
  Locate 12, 0
  File$ = Gettext$(Edit&)
  IF File$ <> ""
   CLS
   Locate 12, 0
   Print "Versionsnummer der Datei: "
   Print GetFileVersion(File$)
  endif
  EnableWindow Checkbox&, 1
  EnableWindow Button&, 1
 endif
EndWhile
Freedll version&
End
 
Proc GetFileVersion
 Parameters File2$
 Clear Version$
 'Umleitung deaktivieren
 IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
 FileInfoSize& = Call(GetFileVersionInfoSizeA&, ADDR(File2$), ADDR(Zero&))
 IF FileInfoSize& > 0
  DIM MODULEINFO#, FileInfoSize&
  FILE_FEHLER& = Call(GetFileVersionInfoA&, ADDR(File2$), 0, FileInfoSize&, MODULEINFO#)
  'Umleitung aktivieren
  IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
  Ver_Value$ = "\\"
  FEHLER& = VerQueryValue(MODULEINFO#, ADDR(Ver_Value$), ADDR(FILE_VER_INFO&), ADDR(Zero&))
  If FEHLER& = 1
   If Zero& = 0
    Zero& = 4
   endif
   DIM FILE_VER_INFO#, Zero&
   Clear FILE_VER_INFO#
   FILE_VER_INFO# = FILE_VER_INFO&
   VERSION$ = STR$(Word(FILE_VER_INFO#, 10)) + ", "
   VERSION$ = Version$ + STR$(Word(FILE_VER_INFO#, 8)) + ", "
   VERSION$ = Version$ + STR$(Word(FILE_VER_INFO#, 14)) + ", "
   VERSION$ = Version$ + STR$(Word(FILE_VER_INFO#, 12))
   Dispose FILE_VER_INFO#
  endif
  Dispose MODULEINFO#
 endif
 'Umleitung aktivieren
 IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
 Return Version$
endproc

Beispiele für APIs die auf jeden Fall umgeleitet werden sind:
CreateFile, FindFirstFile und WinVerifyTrust.

Bei WinVerifyTrust ist zu beachten, dass hier auf keinen Fall die Dateiumleitung deaktiviert werden darf - Wow64DisableWow64FsRedirection darf also nicht benutzt werden, um für diese API im richtigen Pfad zu landen! WinVerifyTrust reagiert mit deaktivierter Dateiumleitung nicht korrekt und unter Windows7 passieren sogar schwere Fehler, die die API so zerschießen, das auch im Nachhinein Signaturen nicht mehr korrekt ausgelesen werden können.
Um mit WinVerifyTrust die korrekten Signaturen auszulesen, muss das Codewort Sysnative statt System32 werwendet werden! C:\Windows\System32\Drivers\ACPI.sys sollte zum Beispiel also, bevor man damit die API bestückt, in C:\Windows\Sysnative\Drivers\ACPI.SYS umgewandelt werden.
Nach dem Deaktiviren der Dateiumleitung unter Windows7 liefert WinVerifyTrust 8 (Für diesen Befehl ist nicht genügend Speicher verfügbar.) zurück und versagt auch bei späterem Deaktivieren der Umleitung und gleichzeitiger Verwendung des Codewortes Sysnative den Dienst.

**AHT** · 08.01.2010, 18:54

64Bit Betriebsysteme und das Umbiegen von Umgebungsvariablen für 32Bit Programme

Neben den Systempfaden biegen 64Bit Betriebsysteme auch einige Pfade von Umgebungsvariablen um -> %ProgramFiles% und %commonprogramfiles%. %ProgramFiles% wird vom Standardpfad C:\Program files auf C:\Program Files (x86) umgebogen, %commonprogramfiles% landet von C:\Program Files\Common Files auf C:\Program Files (x86)\Common Files.
Hier ist Code zum Testen:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
Clearlist 
 
Addstring GetEnv$("ProgramFiles")
Addstring GetEnv$("CommonProgramFiles")
EditBox("Pfade",1)

Anhand der hier zu lesenden Dokumentation könnte man denken, dass man unter WOW64 durch Anwendung der API SHGetSpecialFolderLocation mit der CSIDL CSIDL_PROGRAM_FILES an den %ProgramFiles% Ordner für 64Bit Programme kommt - dem ist aber nicht so!
Sowohl CSIDL_PROGRAM_FILES als auch CSIDL_PROGRAM_FILESX86 verweisen in 32Bit Programmen auf den selben Pfad.
Gleiches gilt auch für CSIDL_PROGRAM_FILES_COMMON und CSIDL_PROGRAM_FILES_COMMONX86.

**AHT** · 09.01.2010, 19:00

Automatische Umleitung von Registryzugriffen für 32Bit Programme unter 64Bit

Neben der Umleitung des Dateisystems werden auch Registryzugriffe für 32Bit Programme unter 64Bit umgeleitet. Aber was bedeutet das genau?
Hier mal etwas Code zum Testen:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
 
Declare Module$, MHANDLE&, Funktion$, Valuename$
Declare 64Bit&, Edit&, Button&, HKEY$, Key$
 
Module$="Kernel32.DLL"
Funktion$="IsWow64Process"
MHANDLE&=GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
 
Windowstyle 31
WindowTitle "Readini$ Test"
Window 0, 0 - 640, 440
 
Edit& = Create("Edit", %HWND, "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools:SharedFilesDir", 20, 20, 500, 30)
Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
 
While 1
 Waitinput
 IF Clicked(Button&)
  EnableWindow Button&, 0
  EnableWindow Edit&, 0
  Key$ = Substr$(Gettext$(Edit&), 1, ":")
  Valuename$ = Substr$(Gettext$(Edit&), 2, ":")
  HKEY$ = Substr$(Key$, 1, "\")
  Key$ = Right$(Key$, int(Len(Key$) - (Len(HKEY$) + 1)))
  IF HKEY$ = "HKEY_CLASSES_ROOT"
   HKEY$ = "HKEY_0"
  elseif HKEY$ = "HKEY_CURRENT_USER"
   HKEY$ = "HKEY_1"
  elseif HKEY$ = "HKEY_LOCAL_MACHINE"
   HKEY$ = "HKEY_2"
  elseif HKEY$ = "HKEY_USERS"
   HKEY$ = "HKEY_3"
  elseif HKEY$ = "HKEY_PERFORMANCE_DATA"
   HKEY$ = "HKEY_4"
  elseif HKEY$ = "HKEY_CURRENT_CONFIG"
   HKEY$ = "HKEY_5"
  elseif HKEY$ = "HKEY_DYN_DATA"
   HKEY$ = "HKEY_6"
  endif
  CLS
  Locate 12, 0
  Print Readini$(HKEY$,Key$, Valuename$)
  EnableWindow Button&, 1
  EnableWindow Edit&, 1
 endif
Endwhile
end

Der Code liefert nach dem Klicken des Testen Buttons als Rückgabe bei mir (Windows7, 64Bit) den Pfad C:\Program Files (X86)\Common Files\Microsoft Shared zurück.

Schaut man an gleicher Stelle in die Registry, steht dort aber der Pfad C:\Program Files\Common Files\Microsoft Shared\ .

Warum ist das so?

Zur Lösung des Rätsels schauen wir einmal mit Regedit in die Registry.
Unter HKEY_LOCAL_MACHINE\Software (ein Wert eines Unterschlüssels dieses Keys wird hier ja ausgelesen) finden wir einen Registryschlüssel mit dem Namen Wow6432Node.

Als Unterschlüssel dieses Keys finden wir dort so ziemlich alle Schlüssel wieder, die auch unter HKEY_LOCAL_MACHINE\Software vorhanden sind.

Öffnen wir nun mit Regedit den Schlüssel HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Shared Tools. Unter SharedFilesDir finden wir an dieser Stelle folgendes

:

Hier steht also das, was eigentlich unter HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools stehen sollte!

32Bit Programmen wird also für manche Keys eine ganz andere Registry vorgegaukelt. Für diese Keys werden sämtliche Zugriffe in einen Unterschlüssel mit dem Namen Wow6432Node umgeleitet (das gilt natürlich auch für Schreibzugriffe). So kann es nicht nur dazu kommen, das 32Bit Programme andere Werte auslesen als 64Bit Programme - nein, der auszulesende Key kann für 32Bit Programme in manchen Fällen auch gar nicht existieren!

Natürlich gibt es mit der API auch Möglichkeiten, die 64Bit Werte auszulesen und zu bearbeiten - mit den Profanbefehlen Readini$ und Writeini geht das aber nicht!

**AHT** · 09.01.2010, 21:08

Mit Profan 32Bit Programmen die 64Bit Registry auslesen

Um unter 32Bit Programmen Zugriff auf die 64Bit Registry zu bieten, hat M$ einen zusätzlichen Zugriffsflag für Registryschlüssel eingeführt:
KEY_WOW64_64KEY = $100
Wird $100 zusätzlich (Verknüpfung mit | ) beim samDesired Parameter von RegOpenKeyEx oder RegCreateKeyEx angegeben, wird bei 32Bit Programmen, die unter 64Bit Windows laufen, der 64Bit Registryschlüssel geöffnet.
Hier Code zum Testen:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
 
DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
Def RegOpenKeyEx(5) !"ADVAPI32","RegOpenKeyExA"
Def RegCloseKey(1) !"ADVAPI32","RegCloseKey"
Def RegQueryValueEx(6) !"ADVAPI32","RegQueryValueExA"
 
Declare Module$, MHANDLE&, Funktion$, Valuename$
Declare Edit&, Checkbox&, Button&, HKEY&, Key$, HKEY$
Declare Wert3#
Declare 64Bit&, KEY_WOW64_64KEY&
 
Module$="Kernel32.DLL"
Funktion$="IsWow64Process"
MHANDLE&=GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
endif
Windowstyle 31
WindowTitle "Readini$ Test"
Window 0, 0 - 640, 440
Edit& = Create("Edit", %HWND, "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools:SharedFilesDir", 20, 20, 500, 30)
Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
Checkbox& = Create("CheckBox", %HWND, "Registryumleitung deaktivieren", 20, 100, 500, 30)
While 1
 Waitinput
 IF Clicked(Button&)
  EnableWindow Button&, 0
  EnableWindow Edit&, 0
  EnableWindow Checkbox&, 0
  IF (GetCheck(Checkbox&)) and (64Bit&=1)
   KEY_WOW64_64KEY& = $100 'Registryumleitung deaktivieren
  else
   KEY_WOW64_64KEY& = $0 'Registryumleitung aktivieren
  endif
  Key$ = Substr$(Gettext$(Edit&), 1, ":")
  Valuename$ = Substr$(Gettext$(Edit&), 2, ":")
  HKEY$ = Substr$(Key$, 1, "\")
  Key$ = Right$(Key$, int(Len(Key$) - (Len(HKEY$) + 1)))
  IF HKEY$ = "HKEY_CLASSES_ROOT"
   HKEY& = $80000000
  elseif HKEY$ = "HKEY_CURRENT_USER"
   HKEY& = $80000001
  elseif HKEY$ = "HKEY_LOCAL_MACHINE"
   HKEY& = $80000002
  elseif HKEY$ = "HKEY_USERS"
   HKEY& = $80000003
  elseif HKEY$ = "HKEY_PERFORMANCE_DATA"
   HKEY& = $80000004
  elseif HKEY$ = "HKEY_CURRENT_CONFIG"
   HKEY& = $80000005
  elseif HKEY$ = "HKEY_DYN_DATA"
   HKEY& = $80000006
  endif
  CLS
  Locate 12, 0
  Print ReadKey(HKEY&,Key$, Valuename$)
  EnableWindow Button&, 1
  EnableWindow Edit&, 1
  EnableWindow Checkbox&, 1
 endif
Endwhile
end
 
'Registrywert auslesen
Proc ReadKey
 Parameters O_Key&, R_KEY$, R_WERT$
 Declare Wert3$, RegHandle3&, RegError6&, RegSize3&
 Declare RegError7&, RegSize4&, Type3&
 Clear Wert3$, RegError7&
 RegError6& = Regopenkeyex(O_Key&, addr(R_KEY$), 0, $1 | KEY_WOW64_64KEY&, addr(RegHandle3&))
 IF RegError6& = 0
  DIM Wert3#, 1
  RegSize3& = 1
  RegError7& = Regqueryvalueex(RegHandle3&, addr(R_WERT$), 0, addr(Type3&), Wert3#, addr(RegSize3&)) 'Hier erhalte ich einen Wert!!!
  Dispose Wert3#
  DIM Wert3#, RegSize3&+1
  RegSize4& = RegSize3&
  RegError7& = Regqueryvalueex(RegHandle3&, addr(R_WERT$), 0, addr(Type3&), Wert3#, addr(RegSize4&)) 'Hier erhalte ich einen Wert!!!
  Wert3$ = String$(Wert3#, 0)
  Dispose Wert3#
  Regclosekey(RegHandle3&)
 endif
 Return Wert3$
endproc

Wichtig: Es ist zwingend notwendig, zuvor auf 64Bit Systeme zu testen, denn zumindestens unter Windows2000 führt die Angabe des zusätzliche Flag $100 dazu, das RegOpenKeyEx und RegCreateKeyEx nicht funktionieren!

**AHT** · 10.01.2010, 12:25

Besonderheiten beim Listen von Registryinhalten unter HKEY_LOCAL_MACHINE unter 64Bit

Registryschlüssel unter HKEY_LOCAL_MACHINE\Software existieren aufgrund der erwähnten Umleitung von Registryschlüsseln in der Regel auf 64Bit Windowssystemen in doppelter Ausführung - einmal in der 32Bit Version und einmal in der 64Bit Version.
Um zum Beispiel zuverlässig alle durch den Registryschlüssel RUN unter HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion gestarteten Programme zu listen, ist es erforderlich, das Listing doppelt durchzuführen - einmal mit dem Flag $100 und einmal ohne diesen Flag. Programme, die dies nicht berücksichtigen, funktionieren unter 64Bit Systemen nicht korrekt.

**AHT** · 15.01.2010, 16:52

Mit 32Bit Programmen unter 64Bit Module (DLLs) listen

Wie sieht es nun aber aus, wenn man sich die von den einzelnen Prozessen geladenen DLLs listen lassen möchte? Die Toolhelp Funktionen bieten dafür ja die APIs Module32First und Module32Next.
Hier ist Code zum Testen:

Code:

'#####################################################################################
'#########                          Code von AHT                             #########
'#########      Gepostet für http://www.paules-pc-forum.de                   #########
'#####################################################################################
 
Def GetModuleFileNameEx(4) !"Psapi", "GetModuleFileNameExA"
Def CreateToolhelp32Snapshot(2) !"Kernel32", "CreateToolhelp32Snapshot"
Def Process32First(2) !"Kernel32", "Process32First"
Def Process32Next(2) !"Kernel32", "Process32Next"
Def CloseHandle(1) !"Kernel32", "CloseHandle"
Def GetCurrentProcessID(0) !"Kernel32", "GetCurrentProcessId"
Def OpenProcess(3) !"Kernel32", "OpenProcess"
DEF LookupPrivilegeValue(3) !"advapi32","LookupPrivilegeValueA"
DEF AdjustTokenPrivileges(6) !"advapi32","AdjustTokenPrivileges"
DEF OpenProcessToken(3) !"advapi32","OpenProcessToken"
DEF GetCurrentProcess(0) !"KERNEL32","GetCurrentProcess"
DEF CopyMemory(3) !"kernel32","RtlMoveMemory"
DEF GetModuleHandle(1) !"KERNEL32","GetModuleHandleA"
DEF GetProcAddress(2) !"KERNEL32","GetProcAddress"
Def QueryFullProcessImageName(4) !"Kernel32", "QueryFullProcessImageNameA"
DEF CheckTokenMembership(3) !"advapi32","CheckTokenMembership"
Def Module32First(2) !"Kernel32", "Module32First"
Def Module32Next(2) !"Kernel32", "Module32Next"
 
Declare Listbox&, Button&, Wintrust_DLL&
Declare Entry#, err&, handle&, PID$, ProcessName$, PHandle&, Filename#
Declare TOKEN_PRIVILEGES#, LUID#, Fehler&, 64Bit&, MODULE$, Funktion$
Declare MHANDLE&, Size&, Member&, SID#, 64Bit$, 64Bit_test&, Old_LB_String$
Declare New_LB_String$, PR_ID&, DLL_LADEN_mit_Pfad&, DLL_LADEN_ohne_Pfad&
 
Struct PROCESSENTRY32 = dwSize&, \
cntUsage&, \
th32ProcessID&, \
th32DefaultHeapID&, \
th32ModuleID&, \
Threads&, \
th32ParentProcessID&, \
pcPriClassBase&, \
dwFlags&, \
szExeFile$(260)
 
Struct MODULEENTRY32 = dwsize&, th32ModuleID&,th32ProcessID&, GlblcntUsage&,ProccntUsage&, modBaseAddr&, modBaseSize&, hModule&, szModule$(255), szExePath$(260)
 
Clear 64Bit&
MODULE$ = "Kernel32.DLL"
Funktion$ = "IsWow64Process"
MHANDLE& = GetModuleHandle(ADDR(Module$))
IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$)) <> 0
 External("Kernel32.dll", "IsWow64Process", GetCurrentProcess(), Addr(64Bit&))
endif
 
WindowStyle 31+512
WindowTitle "64Bit Test Module listen"
Window 0,0-%MAXX-20,440
UserMessages $10
 
DLL_LADEN_ohne_Pfad& = Create("Button", %HWND, "Wintrust.DLL ohne Pfad laden", 20, 20, 220, 30)
DLL_LADEN_mit_Pfad& = Create("Button", %HWND, "Wintrust.DLL mit Pfad laden", 250, 20, 200, 30)
Button& = Create("Button", %HWND, "Prozesse listen", 460, 20, %MAXX-(70+460), 30)
ListBox& = Create("Listbox", %HWND, "", 20, 60, %MAXX-80, 300)
 
Set_Privilege_Status("SeDebugPrivilege",$2)
FillProcessList
 
While %Umessage<>$10
 WaitInput
 If Clicked(Button&)
  Beep
  FillProcessList
 endif
 If Clicked(DLL_LADEN_ohne_Pfad&)
  Beep
  CASE Wintrust_DLL& <> 0 : FreeDLL Wintrust_DLL&
  Wintrust_DLL& = UseDLL("Wintrust.dll")
 endif
 If Clicked(DLL_LADEN_mit_Pfad&)
  Beep
  CASE Wintrust_DLL& <> 0 : FreeDLL Wintrust_DLL&
  Wintrust_DLL& = UseDLL($SYSPATH + "\" + "Wintrust.dll")
 endif
 If GetCurSel(ListBox&) <> -1
  New_LB_String$ = GetString$(ListBox&, GetCurSel(ListBox&))
  IF New_LB_String$ <> OLD_LB_String$
   OLD_LB_String$ = New_LB_String$
   PR_ID& = Val(SubStr$(New_LB_String$, 1, ","))
   Liste_DLLS(PR_ID&, New_LB_String$)
  endif
 endif
EndWhile
CASE Wintrust_DLL& <> 0 : FreeDLL Wintrust_DLL&
end
 
Proc Set_Privilege_Status
 Parameters Privilege_name$, Aktive&
 Declare NewState&, AH_Token_Handle&, Fehler&, Privret&
 DIM TOKEN_PRIVILEGES#,16
 DIM LUID#,8
 Clear LUID#
 External("advapi32.dll","LookupPrivilegeValueA",0,ADDR(Privilege_name$),LUID#)
 CLEAR AH_Token_Handle&
 LET FEHLER&=External("advapi32.dll","OpenProcessToken",External("KERNEL32.dll","GetCurrentProcess"),$20,ADDR(AH_Token_Handle&))
 LONG TOKEN_PRIVILEGES#,0=1
 NewState&=TOKEN_PRIVILEGES#
 External("KERNEL32.dll","RtlMoveMemory",NewState&+4,LUID#,8)
 LET NewState&=Aktive&
 Clear Aktive&
 IF NewState& | $2 = NewState&
  LET Aktive&=AKTIVE& | $2
 Endif
 IF NewState& | $80000000 = NewState&
  LET Aktive&= AKTIVE& | $80000000
 Endif
 LONG TOKEN_PRIVILEGES#,12=Aktive&
 Privret&=External("advapi32.dll","AdjustTokenPrivileges",AH_Token_Handle&,0,TOKEN_PRIVILEGES#,0,0,0)
 If AH_TOKEN_Handle&<>0
  External("KERNEL32.dll","CloseHandle",AH_Token_Handle&)
 endif
 Dispose TOKEN_PRIVILEGES#
 Dispose LUID#
 Return Privret&
endproc
 
Proc FillProcessList
   SendMessage(Listbox&,$184,0,0)
   Dim Entry#,PROCESSENTRY32
   Clear Entry#
   Entry#.dwSize& = SizeOf(Entry#)
   DIM Filename#, 514
   handle& = CreateToolhelp32Snapshot(2, 0)
   If handle&
      err& = Process32First(handle&, Entry#)
      If err&
         PID$ = Str$(Entry#.th32ProcessID&)
         ProcessName$ = Entry#.szExeFile$
         Clear Filename#, PHandle&
         IF Val($WINVER) < 6.0
          PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
         else
          PHandle& = OpenProcess($1000, 0, Entry#.th32ProcessID&)
         endif
         IF PHandle& > 0
          IF Val($WINVER) < 6.0
           GetModuleFilenameEx(PHandle&, 0, Filename#, 513)
           If 64Bit& = 1
            External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
            IF 64Bit_Test& = 1
             64Bit$ = "32Bit Prozess"
            else
             64Bit$ = "64Bit Prozess"
            endif
           else
            64Bit$ = "32Bit Prozess"
           endif
          else
           Size& = 580
           QueryFullProcessImageName(PHandle&, 0, Filename#, addr(Size&))
           If 64Bit& = 1
            External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
            IF 64Bit_Test&=1
             64Bit$ = "32Bit Prozess"
            else
             64Bit$ = "64Bit Prozess"
            endif
           else
            64Bit$ = "32Bit Prozess"
           endif
          endif
          Closehandle(PHandle&)
         else
          clear 64Bit$
         endif
         ADDSTRING(ListBox&,PID$ + ", " + ProcessName$ + ", " + String$(Filename#, 0) + ", " + 64Bit$)
         Repeat
            err& = Process32Next(handle&, Entry#)
            If err&
               PID$ = Str$(Entry#.th32ProcessID&)
               ProcessName$ = Entry#.szExeFile$
               Clear Filename#, PHandle&
               IF Val($WINVER) < 6.0
                PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
               else
                PHandle& = OpenProcess($1000, 0, Entry#.th32ProcessID&)
               endif
               IF PHandle& > 0
                IF Val($WINVER) < 6.0
                 GetModuleFilenameEx(PHandle&, 0, Filename#, 513)
                 If 64Bit& = 1
                  External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
                  IF 64Bit_Test& = 1
                   64Bit$ = "32Bit Prozess"
                  else
                   64Bit$ = "64Bit Prozess"
                  endif
                 else
                  64Bit$ = "32Bit Prozess"
                 endif
                else
                 Size&=580
                 QueryFullProcessImageName(PHandle&, 0, Filename#, addr(Size&))
                 If 64Bit& = 1
                  External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
                  IF 64Bit_Test& = 1
                   64Bit$ = "32Bit Prozess"
                  else
                   64Bit$ = "64Bit Prozess"
                  endif
                 else
                  64Bit$ = "32Bit Prozess"
                 endif
                endif
                Closehandle(PHandle&)
               endif
               ADDSTRING(ListBox&,PID$ + ", " + ProcessName$ + ", " + String$(Filename#, 0) + ", " + 64Bit$)
            EndIf
         Until err& = 0
         CloseHandle(handle&)
      else
       clear 64Bit$
      EndIf
   EndIf
   Dispose Filename#
   Dispose Entry#
   return
EndProc
 
Proc Liste_DLLS
 Parameters ProcessID&, ProcessData$
 ClearList
 Addstring "Module von " + ProcessData$
 Addstring "_____________________________________________________________________"
 IF ProcessID& <> 0
  Dim Entry#, MODULEENTRY32
  Clear Entry#
  Entry#.dwSize& = SizeOf(Entry#)
  handle& = CreateToolhelp32Snapshot($8, ProcessID&)
  If handle&
   Entry#.th32ProcessID& = ProcessID&
   err& = Module32First(handle&, Entry#)
   If err&
     AddString Str$(Entry#.hModule&) + "  " + Entry#.szExePath$
     Repeat
       err& = Module32Next(handle&, Entry#)
       If err&
         AddString Str$(Entry#.hModule&) + "  " + Entry#.szExePath$
       EndIf
     Until err& = 0
     CloseHandle(handle&)
   EndIf
  EndIf
  Dispose Entry#
 endif
 EditBox("Module: ", 1)
 SendMessage(ListBox&,$186,-1,0)
 Clear OLD_LB_String$
 return
endproc

Damit der Code unter Vista und Windows7 richtig funktioniert, benötigt er Adminrechte. Zum Ausführen des Codes also zuerst den Profaneditor mit Adminrechten starten.
Die Listbox wird nach dem Start mit den laufenden Prozessen gefüllt - hinter dem Dateinamen steht, ob es sich bei dem Prozess um einen 32Bit oder 64Bit Prozess handelt.
Klickt man auf einen Prozess, werden in einer EditBox die vom markierten Prozess geladenen DLLs gelistet. Klickt man auf den Button Prozesse listen, werden die Prozesse neu ausgelesen.
Klickt man auf ´den Button Wintrust.DLL ohne Pfad laden, lädt der Code die Wintrust.dll in den eigenen Prozess - im Code wird diese DLL ohne Angabe des genauen Pfads geladen.

Code:

Wintrust_DLL& = UseDLL("Wintrust.dll")

Klickt man auf ´den Button Wintrust.DLL mit Pfad laden, lädt der Code ebenfalls die Wintrust.dll in den eigenen Prozess - im Code wird aber diese DLL mit Angabe des genauen Pfads geladen.

Code:

Wintrust_DLL& = UseDLL($SYSPATH + "\" + "Wintrust.dll")

Soweit zur Funktionsweise des Codes.

In 32Bit Systemen listet der Code (wenn er mit Adminrechten ausgestattet wird) fast in allen Prozessen die geladenen DLLs - wie sieht das aber unter 64Bit aus?
Unter 64Bit Systemen können 32Bit Programme nur geladene 32Bit Module listen (warum das so ist, erläutere ich bei anderen APIs noch)- bei jedem 64Bit Prozess ist die EditBox also leer, da 64Bit Prozesse auch nur 64Bit DLLs laden können und 32Bit Prozesse nur 32Bit DLLs.
So, jetzt kommt die etwas haarige Besonderheit, die auf den MSDN Seiten nicht zu finden ist...
Wir schauen uns dazu mal die Module an, die vom Prozesse geladen wurden, den unserer Code erzeugt hat. Hier das, was bei mir unter Windows7 in der EditBox steht:

Code:

Module von 928, Profan.exe, C:\Program Files (x86)\XProfan9\Profan.exe, 32Bit Prozess
_____________________________________________________________________
4194304  C:\Program Files (x86)\XProfan9\PROFAN.EXE
1996423168  C:\Windows\SysWOW64\ntdll.dll
1973551104  C:\Windows\syswow64\kernel32.dll
1965948928  C:\Windows\syswow64\KERNELBASE.dll
1962606592  C:\Windows\syswow64\user32.dll
1960247296  C:\Windows\syswow64\GDI32.dll
1989738496  C:\Windows\syswow64\LPK.dll
1987510272  C:\Windows\syswow64\USP10.dll
1967783936  C:\Windows\syswow64\msvcrt.dll
1959460864  C:\Windows\syswow64\ADVAPI32.dll
1960116224  C:\Windows\SysWOW64\sechost.dll
1970470912  C:\Windows\syswow64\RPCRT4.dll
1958084608  C:\Windows\syswow64\SspiCli.dll
1958019072  C:\Windows\syswow64\CRYPTBASE.dll
1969881088  C:\Windows\syswow64\oleaut32.dll
1961164800  C:\Windows\syswow64\ole32.dll
1956184064  C:\Windows\WinSxS\x86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7600.16385_none_421189da2b7fabfc\comctl32.dll
1959067648  C:\Windows\syswow64\SHLWAPI.dll
1974599680  C:\Windows\syswow64\shell32.dll
1969356800  C:\Windows\syswow64\comdlg32.dll
1837432832  C:\Windows\system32\winmm.dll
1963655168  C:\Windows\system32\IMM32.DLL
1968504832  C:\Windows\syswow64\MSCTF.dll
1911881728  C:\Windows\system32\uxtheme.dll
1991966720  C:\Windows\syswow64\ws2_32.dll
1996226560  C:\Windows\syswow64\NSI.dll
1955987456  C:\Windows\system32\dwmapi.dll

Hier fällt auf, das manche DLLs mit der Pfadangabe C:\Windows\system32 gelistet werden, andere aber wiederum mit der Pfadangabe C:\Windows\syswow64! Was ist da los?
Um der Sache auf den Grund zu gehen, klicken wir mal zuerst auf den Button Wintrust.DLL ohne Pfad laden und dann wieder auf unseren Profan.exe Prozess.
So sieht dann die Rückgabe aus:

Code:

Module von 1748, Profan.exe, C:\Program Files (x86)\XProfan9\Profan.exe, 32Bit Prozess
_____________________________________________________________________
4194304  C:\Program Files (x86)\XProfan9\PROFAN.EXE
1996423168  C:\Windows\SysWOW64\ntdll.dll
1973551104  C:\Windows\syswow64\kernel32.dll
1965948928  C:\Windows\syswow64\KERNELBASE.dll
1962606592  C:\Windows\syswow64\user32.dll
1960247296  C:\Windows\syswow64\GDI32.dll
1989738496  C:\Windows\syswow64\LPK.dll
1987510272  C:\Windows\syswow64\USP10.dll
1967783936  C:\Windows\syswow64\msvcrt.dll
1959460864  C:\Windows\syswow64\ADVAPI32.dll
1960116224  C:\Windows\SysWOW64\sechost.dll
1970470912  C:\Windows\syswow64\RPCRT4.dll
1958084608  C:\Windows\syswow64\SspiCli.dll
1958019072  C:\Windows\syswow64\CRYPTBASE.dll
1969881088  C:\Windows\syswow64\oleaut32.dll
1961164800  C:\Windows\syswow64\ole32.dll
1956184064  C:\Windows\WinSxS\x86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7600.16385_none_421189da2b7fabfc\comctl32.dll
1959067648  C:\Windows\syswow64\SHLWAPI.dll
1974599680  C:\Windows\syswow64\shell32.dll
1969356800  C:\Windows\syswow64\comdlg32.dll
1837432832  C:\Windows\system32\winmm.dll
1963655168  C:\Windows\system32\IMM32.DLL
1968504832  C:\Windows\syswow64\MSCTF.dll
1911881728  C:\Windows\system32\uxtheme.dll
1991966720  C:\Windows\syswow64\ws2_32.dll
1996226560  C:\Windows\syswow64\NSI.dll
1955987456  C:\Windows\system32\dwmapi.dll
1967587328  C:\Windows\syswow64\Wintrust.dll
1964048384  C:\Windows\syswow64\CRYPT32.dll
1961099264  C:\Windows\syswow64\MSASN1.dll

KLicken wir danach auf den Button Wintrust.DLL mit Pfad laden, sieht die Rückgabe so aus:

Code:

Module von 1748, Profan.exe, C:\Program Files (x86)\XProfan9\Profan.exe, 32Bit Prozess
_____________________________________________________________________
4194304  C:\Program Files (x86)\XProfan9\PROFAN.EXE
1996423168  C:\Windows\SysWOW64\ntdll.dll
1973551104  C:\Windows\syswow64\kernel32.dll
1965948928  C:\Windows\syswow64\KERNELBASE.dll
1962606592  C:\Windows\syswow64\user32.dll
1960247296  C:\Windows\syswow64\GDI32.dll
1989738496  C:\Windows\syswow64\LPK.dll
1987510272  C:\Windows\syswow64\USP10.dll
1967783936  C:\Windows\syswow64\msvcrt.dll
1959460864  C:\Windows\syswow64\ADVAPI32.dll
1960116224  C:\Windows\SysWOW64\sechost.dll
1970470912  C:\Windows\syswow64\RPCRT4.dll
1958084608  C:\Windows\syswow64\SspiCli.dll
1958019072  C:\Windows\syswow64\CRYPTBASE.dll
1969881088  C:\Windows\syswow64\oleaut32.dll
1961164800  C:\Windows\syswow64\ole32.dll
1956184064  C:\Windows\WinSxS\x86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7600.16385_none_421189da2b7fabfc\comctl32.dll
1959067648  C:\Windows\syswow64\SHLWAPI.dll
1974599680  C:\Windows\syswow64\shell32.dll
1969356800  C:\Windows\syswow64\comdlg32.dll
1837432832  C:\Windows\system32\winmm.dll
1963655168  C:\Windows\system32\IMM32.DLL
1968504832  C:\Windows\syswow64\MSCTF.dll
1911881728  C:\Windows\system32\uxtheme.dll
1991966720  C:\Windows\syswow64\ws2_32.dll
1996226560  C:\Windows\syswow64\NSI.dll
1955987456  C:\Windows\system32\dwmapi.dll
1967587328  C:\Windows\system32\Wintrust.dll
1964048384  C:\Windows\syswow64\CRYPT32.dll
1961099264  C:\Windows\syswow64\MSASN1.dll

Daraus ergibt sich folgende, wichtige Sache:
Die Pfadangaben der gelisteten DLLs sind nicht immer korrekt! Hat der Prozess die DLLs ohne Angabe des Pfades geladen, wird der korrekte Pfad zurückgegeben. Wurde die DLL mit Angabe des Systempfades geladen, wird der nicht korrekte System32 Pfad angezeigt!
Auch das Umwandeln aller System32 Angaben in SysWow64 führt nicht immer zur Ermittlung des richtigen Pfades, denn in seltenen Fällen lädt ein 32Bit Prozess auch DLLs aus dem System32 Verzeichnis!

PS: Wer mit XP 64Bit arbeitet, wird im Code noch auf eine weitere Besonderheit stoßen - dazu kommt aber später noch was.

01.01.2010, 18:09	#1 (Direktlink)
Frabbing Super-Moderator Registriert seit: 05.02.2009 Ort: Westliches NRW Alter: 44 Beiträge: 5.094	XProfan & 64-Bit Hier bitte 64-Bit Themen zu XProfan posten. Sollte der Thread seinen Rahmen sprengen, wird er zu einem eigenen Unterforum umgewandelt. Bislang aber erst einmal testweise in dieser Form. Weitere 64-Bit-Threads 64 Bit - XProfan Dateidialoge unter 64Bit zum korrekten Funktionieren bringen Suche dringend Leute mit 64Bit Betriebsystemen... __________________ Gruß, Frank Webpage http://frabbing.bplaced.net mit Freeware - Tools, Spiele und Grafiken. Geändert von Frabbing (13.08.2011 um 14:03 Uhr)

03.01.2010, 12:52	#2 (Direktlink)
AHT Super-Moderator Registriert seit: 15.02.2009 Beiträge: 10.786	Das Grundproblem Das Grundproblem Das eigentlich Problem, das sich ergibt wenn man 32Bit Programme auf 64Bit Systemen laufen lassen möchte, lässt sich sehr leicht rechnerisch darlegen: Code: 2^32 = 4294967296 Auf einem 32Bit System können also virtuelle Adressen von 0 bis 4294967296 vergeben werden, mehr geht nicht. Davon wird unter NT basierenden Systemen in der Regel die Hälfte für die Nutzung durch Usermode-Programme und ihre DLLs vorgesehen, die andere Hälfte erhält der Kernel mit seinen Treibern. Code: 2^64 = 18446744073709551616 Wie man daraus sieht, können unter 64Bit sehr viel höhere Adressen verwaltet werden. DLLs können in höhere Adressbereiche geladen werden und sie können ihre Variablen in höhere Bereiche schreiben - Bereiche, die ein 32Bit Programm nicht auslesen kann, da der Zahlenbereich dort gar nicht so hoch reicht. Was würde nun passieren, wenn ein 32Bit Programm 64Bit Dlls verwenden würde? Ganz einfach, es würde gewaltig crashen ! Programmierung funktioniert über API - und API ist nichts anderes als das Ansprechen von Funktionen in vom jeweiligen Programm geladenen System-DLLs. Ooops - 64Bit DLLs können von einem 32Bit Programm ja gar nicht verwendet werden! Wie regelt M$ das bloß, das auch 32Bit Programme auf 64Bit laufen? Ganz einfach, M$ liefert ganz locker einen zweiten Satz DLLs für 32Bit mit. Das Problem dabei: Alle Programme laden System-DLLs aus dem Systemverzeichnis (manchmal mit und manchmal ohne Pfadangabe) - und im selben Verzeichnis können sich nicht zwei verschiedene DLLs mit gleichem Namen befinden (einmal für 32Bit und einmal für 64Bit)! 32Bit Programme laufen deshalb in einem Emulator (genannt WOW64), der 32Bit Programmen eine ganz andere Oberfläche vorgaukelt und nebenbei auch Pfade umbiegt. Unter anderem aus diesem "Umbiegen" heraus ergeben sich einige Spezialitäten bei der Programmierung, die man beachten muss, damit ein 32Bit Programm unter 64Bit lauffähig ist und nicht falsch reagiert. Um diese Spezialitäten soll es hier gehen - unter anderem mit Quellcodebeispielen. __________________ ______________ Bitte Schnelltest durchführen: Neuer Virus, ahnungslose User seit Monaten infiziert! Mfg AHT Geändert von AHT (03.01.2010 um 12:57 Uhr)

04.01.2010, 23:48	#4 (Direktlink)
Frabbing Super-Moderator Registriert seit: 05.02.2009 Ort: Westliches NRW Alter: 44 Beiträge: 5.094	Ja, genau. Danach wollte ich schon gefragt haben. __________________ Gruß, Frank Webpage http://frabbing.bplaced.net mit Freeware - Tools, Spiele und Grafiken.

05.01.2010, 15:02	#5 (Direktlink)
AHT Super-Moderator Registriert seit: 15.02.2009 Beiträge: 10.786	Die Umleitung von Systemordnern und ihre Aufhebung Die Umleitung von Systemordnern und ihre Aufhebung Wie ich schon angemerkt habe, biegt der WOW64 Emulator unter 64Bit für die 32Bit Programme unter anderem Pfade um. "Umbiegen" heißt, er leitet sämtliche Zugriffe auf den Ordner System32 ($SYSPATH) im Windows Installationsordner in den Ordner SysWOW64 im Windowsordner ($WINPATH+"\"+"SysWOW64") um. Diese Umleitung besteht auch für die meisten Unterordner von System32, zum Beispiel für den Ordner System32\Drivers. Wenn man sich das sämtliche einmal etwas auf der Zunge zergehen lässt, wird man wohl jetzt schon merken, dass das zu ganz gewaltigen Verwicklungen führen kann, auf die ich später noch eingehen werde. Es muss also eine Möglichkeit vorhanden sein, diese Umleitung bei Bedarf aufzuheben - und diese Möglichkeit gibt es auch. Nötig dazu sind zwei APIs, eine hebt die Umleitung auf, die andere aktiviert sie wieder. Eine Aktivierung bzw. Deaktivierung der Umleitung erfolgt immer nur für den aktuellen Thread, nicht für das ganze Programm. Hier ist der Code dazu: Code: '##################################################################################### '######### Code von AHT ######### '######### Gepostet für http://www.paules-pc-forum.de ######### '##################################################################################### DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress" DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA" Declare Wow64DisableWow64FsRedirection&, OldValue& Declare Wow64EnableWow64FsRedirection& Declare Module$, MHANDLE&, Funktion$ Declare 64Bit& 'Adressen der APIs ermitteln Module$ = "Kernel32.DLL" MHANDLE& = GetModuleHandle(ADDR(Module$)) Funktion$ = "Wow64DisableWow64FsRedirection" Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$)) Funktion$ = "Wow64EnableWow64FsRedirection" Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$)) 'Auf 64Bit testen Funktion$ = "IsWow64Process" MHANDLE& = GetModuleHandle(ADDR(Module$)) IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&)) endif 'Umleitung deaktivieren IF 64Bit& = 1 : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif 'Umleitung aktivieren IF 64Bit& = 1 : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif Bei den Codes zum Deaktivieren und zum Aktivieren der Umleitung fällt einiges an Besonderheiten auf: 1. ) Die APIs werden über Call angesprochen, nicht über External, DEF oder die Header von Profan. Da die Umleitung aufgehoben wird, bevor der Befehl External beendet wurde, bin ich mir nicht sicher, ob beim Ansprechen der API über eine andere Art und Weise als durch Call Profan immer mit der richtigen DLL hantiert. Ich rate deshalb erst mal an, das ebenso zu machen. 2. ) Vor dem Aufruf der API zum Aufheben der Umleitung wird der FastMode auf 1 gesetzt und erst nach der Reaktivierung der Umleitung wieder auf 0. Während die Dateiumleitung sollten keine Messages verarbeitet werden. Würden, während der Zeit, in der die Umleitung deaktiviert ist, Profan Subclassingroutinen aufgerufen werden, würde Profan unter Umständen versuchen, die DLLs aus dem 64Bit Ordner zu laden - das wäre tötlich. Wichtig: Sämtliche API Aufrufe, die erfolgen während die Umleitung deaktiviert ist, müssen über den Call Befehl erfolgen, da sonst versucht wird, falsche DLLs zu laden. Die Adresse für den Call Befehl muss ermittelt werden, bevor die Umleitung deaktiviert wird! Die Umleitung sollte nur solange deaktiviert bleiben, wie dies unbedingt erforderlich ist. Danach sollte sie sofort wieder reaktiviert werden! __________________ ______________ Bitte Schnelltest durchführen: Neuer Virus, ahnungslose User seit Monaten infiziert! Mfg AHT Geändert von AHT (15.04.2012 um 16:50 Uhr)

05.01.2010, 15:23	#6 (Direktlink)
AHT Super-Moderator Registriert seit: 15.02.2009 Beiträge: 10.786	Das Codewort SysNative Das Codewort SysNative Neben der schon beschriebenen Deaktivierung der Umleitung des Dateisystems gibt es eine zweite Möglichkeit, von einem 32Bit Programm aus Zugriff auf den SYSTEM32 ($SYSPATH) Ordner zu erhalten - die Verwendung des Codewortes Sysnative anstatt System32. Das heißt: Für C:\Windows\System32 einfach C:\Windows\Sysnative schreiben - das wars. Wichtig: Bei manchen Sachen ist es unideal, den Zugriffs mittels Codewort zu regeln, manche APIs funktionieren aber scheinbar nur mittels dieses Codewortes und nicht mit deaktivierter Umleitung! Näheres dazu kommt später. __________________ ______________ Bitte Schnelltest durchführen: Neuer Virus, ahnungslose User seit Monaten infiziert! Mfg AHT Geändert von AHT (05.01.2010 um 15:25 Uhr)

08.01.2010, 18:54	#11 (Direktlink)
AHT Super-Moderator Registriert seit: 15.02.2009 Beiträge: 10.786	64Bit Betriebsysteme und das Umbiegen von Umgebungsvariablen für 32Bit Programme 64Bit Betriebsysteme und das Umbiegen von Umgebungsvariablen für 32Bit Programme Neben den Systempfaden biegen 64Bit Betriebsysteme auch einige Pfade von Umgebungsvariablen um -> %ProgramFiles% und %commonprogramfiles%. %ProgramFiles% wird vom Standardpfad C:\Program files auf C:\Program Files (x86) umgebogen, %commonprogramfiles% landet von C:\Program Files\Common Files auf C:\Program Files (x86)\Common Files. Hier ist Code zum Testen: Code: '##################################################################################### '######### Code von AHT ######### '######### Gepostet für http://www.paules-pc-forum.de ######### '##################################################################################### Clearlist Addstring GetEnv$("ProgramFiles") Addstring GetEnv$("CommonProgramFiles") EditBox("Pfade",1) Anhand der hier zu lesenden Dokumentation könnte man denken, dass man unter WOW64 durch Anwendung der API SHGetSpecialFolderLocation mit der CSIDL CSIDL_PROGRAM_FILES an den %ProgramFiles% Ordner für 64Bit Programme kommt - dem ist aber nicht so! *Sowohl CSIDL_PROGRAM_FILES* als auch CSIDL_PROGRAM_FILESX86 verweisen in 32Bit Programmen auf den selben Pfad. Gleiches gilt auch für CSIDL_PROGRAM_FILES_COMMON und CSIDL_PROGRAM_FILES_COMMONX86. __________________ ______________ Bitte Schnelltest durchführen:** Neuer Virus, ahnungslose User seit Monaten infiziert! Mfg AHT Geändert von AHT (08.01.2010 um 18:57 Uhr)

09.01.2010, 19:00	#12 (Direktlink)
AHT Super-Moderator Registriert seit: 15.02.2009 Beiträge: 10.786	Automatische Umleitung von Registryzugriffen für 32Bit Programme unter 64Bit Automatische Umleitung von Registryzugriffen für 32Bit Programme unter 64Bit Neben der Umleitung des Dateisystems werden auch Registryzugriffe für 32Bit Programme unter 64Bit umgeleitet. Aber was bedeutet das genau? Hier mal etwas Code zum Testen: Code: '##################################################################################### '######### Code von AHT ######### '######### Gepostet für http://www.paules-pc-forum.de ######### '##################################################################################### DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress" DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA" Declare Module$, MHANDLE&, Funktion$, Valuename$ Declare 64Bit&, Edit&, Button&, HKEY$, Key$ Module$="Kernel32.DLL" Funktion$="IsWow64Process" MHANDLE&=GetModuleHandle(ADDR(Module$)) IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0 External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&)) endif Windowstyle 31 WindowTitle "Readini$ Test" Window 0, 0 - 640, 440 Edit& = Create("Edit", %HWND, "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools:SharedFilesDir", 20, 20, 500, 30) Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30) While 1 Waitinput IF Clicked(Button&) EnableWindow Button&, 0 EnableWindow Edit&, 0 Key$ = Substr$(Gettext$(Edit&), 1, ":") Valuename$ = Substr$(Gettext$(Edit&), 2, ":") HKEY$ = Substr$(Key$, 1, "\") Key$ = Right$(Key$, int(Len(Key$) - (Len(HKEY$) + 1))) IF HKEY$ = "HKEY_CLASSES_ROOT" HKEY$ = "HKEY_0" elseif HKEY$ = "HKEY_CURRENT_USER" HKEY$ = "HKEY_1" elseif HKEY$ = "HKEY_LOCAL_MACHINE" HKEY$ = "HKEY_2" elseif HKEY$ = "HKEY_USERS" HKEY$ = "HKEY_3" elseif HKEY$ = "HKEY_PERFORMANCE_DATA" HKEY$ = "HKEY_4" elseif HKEY$ = "HKEY_CURRENT_CONFIG" HKEY$ = "HKEY_5" elseif HKEY$ = "HKEY_DYN_DATA" HKEY$ = "HKEY_6" endif CLS Locate 12, 0 Print Readini$(HKEY$,Key$, Valuename$) EnableWindow Button&, 1 EnableWindow Edit&, 1 endif Endwhile end Der Code liefert nach dem Klicken des Testen Buttons als Rückgabe bei mir (Windows7, 64Bit) den Pfad C:\Program Files (X86)\Common Files\Microsoft Shared zurück. Schaut man an gleicher Stelle in die Registry, steht dort aber der Pfad C:\Program Files\Common Files\Microsoft Shared\ . Warum ist das so? Zur Lösung des Rätsels schauen wir einmal mit Regedit in die Registry. Unter HKEY_LOCAL_MACHINE\Software (ein Wert eines Unterschlüssels dieses Keys wird hier ja ausgelesen) finden wir einen Registryschlüssel mit dem Namen Wow6432Node. Als Unterschlüssel dieses Keys finden wir dort so ziemlich alle Schlüssel wieder, die auch unter HKEY_LOCAL_MACHINE\Software vorhanden sind. Öffnen wir nun mit Regedit den Schlüssel *HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Shared Tools. Unter SharedFilesDir* finden wir an dieser Stelle folgendes : Hier steht also das, was eigentlich unter *HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools* stehen sollte! 32Bit Programmen wird also für manche Keys eine ganz andere Registry vorgegaukelt. Für diese Keys werden sämtliche Zugriffe in einen Unterschlüssel mit dem Namen Wow6432Node umgeleitet (das gilt natürlich auch für Schreibzugriffe). So kann es nicht nur dazu kommen, das 32Bit Programme andere Werte auslesen als 64Bit Programme - nein, der auszulesende Key kann für 32Bit Programme in manchen Fällen auch gar nicht existieren! Natürlich gibt es mit der API auch Möglichkeiten, die 64Bit Werte auszulesen und zu bearbeiten - mit den Profanbefehlen Readini$ und Writeini geht das aber nicht! __________________ ______________ Bitte Schnelltest durchführen: Neuer Virus, ahnungslose User seit Monaten infiziert! Mfg AHT

10.01.2010, 12:25	#14 (Direktlink)
AHT Super-Moderator Registriert seit: 15.02.2009 Beiträge: 10.786	Besonderheiten beim Listen von Registryinhalten unter HKEY_LOCAL_MACHINE unter 64Bit Besonderheiten beim Listen von Registryinhalten unter HKEY_LOCAL_MACHINE unter 64Bit Registryschlüssel unter HKEY_LOCAL_MACHINE\Software existieren aufgrund der erwähnten Umleitung von Registryschlüsseln in der Regel auf 64Bit Windowssystemen in doppelter Ausführung - einmal in der 32Bit Version und einmal in der 64Bit Version. Um zum Beispiel zuverlässig alle durch den Registryschlüssel RUN unter HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion gestarteten Programme zu listen, ist es erforderlich, das Listing doppelt durchzuführen - einmal mit dem Flag $100 und einmal ohne diesen Flag. Programme, die dies nicht berücksichtigen, funktionieren unter 64Bit Systemen nicht korrekt. __________________ ______________ Bitte Schnelltest durchführen: Neuer Virus, ahnungslose User seit Monaten infiziert! Mfg AHT

Themen-Optionen
Druckbare Version zeigen Jemanden per E-Mail auf dieses Thema hinweisen
Ansicht
Linear-Darstellung Zur Hybrid-Darstellung wechseln Zur Baum-Darstellung wechseln

Ähnliche Themen
Thema	Autor	Forum	Antworten	Letzter Beitrag
64 Bit - XProfan	RGH	XProfan	15	04.08.2011 06:45
Bug in XProfan X2	Jac de Lad	Anregungen & Bugreports	4	22.05.2011 17:56
XProfan X3	Jac de Lad	Anregungen & Bugreports	7	19.05.2011 23:46
XProfan-Lehrbuch und XProfan-Manager	Dietmar Horn	Helfer & Tools	3	02.01.2010 13:06
XProfan	Frabbing	XProfan-Stammtisch	54	26.03.2009 18:15