1. Artikel
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forum
  • Anmelden
  • Registrieren
  • Suche
Dieses Thema
  • Alles
  • Dieses Thema
  • Dieses Forum
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. Paules-PC-Forum.de
  2. Forum
  3. Programmierung
  4. XProfan

XProfan & 64-Bit

  • Frank A.
  • 1. Januar 2010 um 18:09
  • Geschlossen
  • Frank A.
    Premium-Mitglied
    Reaktionen
    160
    Beiträge
    6.451
    • 1. Januar 2010 um 18:09
    • #1

    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
    https://www.paules-pc-forum.de/forum/xprofan/…it-xprofan.html
    https://www.paules-pc-forum.de/forum/xprofan/…en-bringen.html
    https://www.paules-pc-forum.de/forum/xprofan/…ebsystemen.html

    Gruß, Frank

    Brandneue Games von mir

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 3. Januar 2010 um 12:52
    • #2

    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
    [LEFT]2^32 = 4294967296[/LEFT]


    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 :lol:!

    Programmierung funktioniert über API - und API ist nichts anderes als das Ansprechen von Funktionen in vom jeweiligen Programm geladenen System-DLLs.
    Ooops 8O - 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.

    2 Mal editiert, zuletzt von AxT (19. Dezember 2014 um 14:20)

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 4. Januar 2010 um 23:46
    • #3

    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 [URL]http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
    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
    Alles anzeigen


    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.

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 5. Januar 2010 um 15:02
    • #4

    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 [URL]http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
    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
    Alles anzeigen



    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!

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 5. Januar 2010 um 15:23
    • #5

    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

    Einmal editiert, zuletzt von AxT (23. November 2015 um 19:19)

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 5. Januar 2010 um 17:51
    • #6

    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 [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
    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$ = ""
    Alles anzeigen


    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.
    [Blockierte Grafik: http://s3.postimage.org/1aV0G9.jpg]
    Ist die Checkbox abgehakt und wird dann Testen geklickt, steht dort 1736792 Bytes.
    [Blockierte Grafik: http://s2.postimage.org/1Q4_xA.jpg]

    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$, ...

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 5. Januar 2010 um 18:30
    • #7

    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 [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
    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$ = ""
    Alles anzeigen


    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.
    [Blockierte Grafik: http://s1.postimage.org/1x9ID9.jpg]

    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.
    [Blockierte Grafik: http://s1.postimage.org/1xagy9.jpg]

    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 [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
    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$ = ""
    Alles anzeigen



    [Blockierte Grafik: http://s3.postimage.org/1b04j0.jpg]

    [Blockierte Grafik: http://s4.postimage.org/XHDO9.jpg]

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 6. Januar 2010 um 14:51
    • #8

    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 :lol:.

    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)
      Print %IORESULT
      Print %IORESULT
     endif
    until 0
    Alles anzeigen

    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
    Alles anzeigen

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

    Einmal editiert, zuletzt von AxT (19. Dezember 2014 um 14:22)

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 8. Januar 2010 um 15:50
    • #9

    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 [URL]http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
     
    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
    Alles anzeigen


    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.

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 8. Januar 2010 um 18:54
    • #10

    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 [URL]http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
    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.

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 9. Januar 2010 um 19:00
    • #11

    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 [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
    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
    Alles anzeigen


    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.
    [Blockierte Grafik: http://s4.postimage.org/19TJiS.jpg]
    Schaut man an gleicher Stelle in die Registry, steht dort aber der Pfad C:\Program Files\Common Files\Microsoft Shared\ 8O.
    [Blockierte Grafik: http://s3.postimage.org/1oz51r.jpg]
    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.
    [Blockierte Grafik: http://s3.postimage.org/1oyJA9.jpg]

    Als Unterschlüssel dieses Keys finden wir dort so ziemlich alle Schlüssel wieder, die auch unter HKEY_LOCAL_MACHINE\Software vorhanden sind.
    [Blockierte Grafik: http://s3.postimage.org/1ozIWJ.jpg]

    Öffnen wir nun mit Regedit den Schlüssel HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Shared Tools. Unter SharedFilesDir finden wir an dieser Stelle folgendes :birne::
    [Blockierte Grafik: http://s1.postimage.org/1KhrL9.jpg]
    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!

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 9. Januar 2010 um 21:08
    • #12

    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 [URL]http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
     
    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
    Alles anzeigen


    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!

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 10. Januar 2010 um 12:25
    • #13

    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.

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 15. Januar 2010 um 16:52
    • #14

    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 [URL]http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
    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
    Alles anzeigen


    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
    Alles anzeigen


    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
    [B]1967587328  C:\Windows\syswow64\Wintrust.dll[/B]
    1964048384  C:\Windows\syswow64\CRYPT32.dll
    1961099264  C:\Windows\syswow64\MSASN1.dll
    Alles anzeigen



    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
    Alles anzeigen



    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.

    Einmal editiert, zuletzt von AxT (19. Dezember 2014 um 14:32)

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 15. Januar 2010 um 19:38
    • #15

    GetModuleFileNameEx unter 64Bit mit 32Bit Programmen



    Unter 32Bit konnte man die API GetModuleFileNameEx noch recht gut dazu benutzen, das Prozesserzeugende Modul einer Anwendung herauszubekommen. Unter 64Bit hat die API endgültig ausgespielt, denn diese API kann das Prozesserzeugende Modul von 64Bit Programmen von 32Bit Programmen aus nicht mehr ermitteln.
    Der Dateiname des Prozesserzeugenden Moduls lässt sich ab Vista aber sehr gut mit der API QueryFullProcessImageName herausbekommen.
    Unter XP 64Bit wird das ganze schon etwas schwieriger - hier muss zuerst der native Pfad über GetProcessImageFileName ermittelt und der Pfad dann umständlich (und unsicher) mit dem Hilfsmittel QueryDosDevice umgewandelt werden.

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 15. Januar 2010 um 20:54
    • #16

    Warum können 32Bit Programme keine 64Bit Moduldaten auslesen?



    Neben GetModuleFileNameEx und Module32First schlagen auch noch andere APIs fehl, wenn man versucht in 64Bit Prozessen von 32Bit Prozessen aus DLLs auszulesen. Aber warum ist das so?

    Informationen über geladene Module befinden sich im virtuellen Speicherbereich des Prozesses, der die Module geladen hat - und zwar in der Struktur PEB_LDR_DATA. Wo sich diese Struktur befindet wird in einer weiteren Systemstruktur gespeichert - dem PEB.
    Um an die Adresse des PEBs für den jeweiligen Prozess zu kommen, nutzt Windows intern eine native API -> NtQueryInformationProcess.
    Da der virtuelle Adressbereich eines 64Bit Prozesses wesentlich größer ist als der eines 32Bit Prozesses kann sich der PEB in Speicherbereichen befinden (oder auf diese verweisen), die von einem 32Bit Prozess gar nicht ausgelesen werden können. Windows regelt das intern so, dass es für alle 64Bit Prozesse, die von einem 32Bit Prozess mittels NtQueryInformationProcess beschossen werden, einen PEB von 0 zurückgiebt.

    Wichtig: Demnach schlagen alle APIs für 64Bit Prozesse fehl, die intern die Adressse des PEBs benötigen, wenn sie von einem 32Bit Prozess ausgeführt werden!

    Hier noch Code zum Testen:

    Code
    '#####################################################################################
    '#########                          Code von AHT                             #########
    '#########      Gepostet für [URL]http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
    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"
    Def NtQueryInformationProcess(5) !"NTDLL","NtQueryInformationProcess"
     
    Declare Listbox&, Button&, Wintrust_DLL&
    Declare Entry#, err&, handle&, PID$, ProcessName$, PHandle&, Filename#
    Declare TOKEN_PRIVILEGES#, LUID#, Fehler&, 64Bit&, MODULE$, Funktion$
    Declare MHANDLE&, Size&, 64Bit$, 64Bit_test&
    Declare NtFehler&, P_Info#, Read&, PEB&
     
    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
    
    
    Set_Privilege_Status("SeDebugPrivilege",$2)
    ClearList
    FillProcessList
    EditBox("Prozesse",1)
    
    
    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
             PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
             IF PHandle& > 0
              DIM P_Info#,24
              NtFehler& = NtQueryInformationProcess(PHandle&, 0, P_Info#, 24, ADDR(Read&))
              PEB& = Long(P_Info#, 4)
              Dispose P_Info#
              CloseHandle(PHandle&)
             endif
             ADDSTRING PID$ + ", " + ProcessName$ + ", " + String$(Filename#,0)+", "+64Bit$+", "+"PEB="+Str$(PEB&)
             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
                   PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
                   IF PHandle& > 0
                    DIM P_Info#,24
                    NtFehler& = NtQueryInformationProcess(PHandle&, 0, P_Info#, 24, ADDR(Read&))
                    PEB& = Long(P_Info#, 4)
                    Dispose P_Info#
                    CloseHandle(PHandle&)
                   endif
                   ADDSTRING PID$ + ", " + ProcessName$ + ", " + String$(Filename#,0)+", "+64Bit$+", "+"PEB="+Str$(PEB&)
                EndIf
             Until err& = 0
             CloseHandle(handle&)
          else
           clear 64Bit$
          EndIf
       EndIf
       Dispose Filename#
       Dispose Entry#
       return
    EndProc
    Alles anzeigen
  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 16. Januar 2010 um 07:28
    • #17

    Speicher eines 64Bit Programms mit einem 32Bit Programm scannen



    Natürlich ist es auch möglich, den virtuellen Speicher eines 64Bit Prozesses mit einem 32Bit Prozess zu scannen und auszulesen - aber natürlich nur die unteren 4GB.
    Unter 32Bit Betriebsystemen bestand hier die Möglichkeit, zum Scannen des Speichers die API VirtualQueryEx in einer Schleife mit sich erhöhenden Werten so lange aufzurufen, bis die API 0 zurückgab - dann war der Speicher komplett durchsucht. Auf 64Bit Prozesse angewendet liefert die API aber normalerweise nie 0 zurück, da hier die kompletten unteren 4GB des Prozesses ja dem Usermode angehören (für 32Bit Prozesses sind nur 2GB auslesbar, die 2GB darüber gehören dem Kernel).
    Eine Rückgabe von 0 für VirtualQueryEx darf also nicht als alleiniges Kriterium dafür hergenommen werden, den Scanvorgang abzubrechen (man fängt sich sonst in einer Endlosschleife) - es muss auch überprüft werden, ob die gesammten 4GB bereits durchsucht worden sind.

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 25. Januar 2010 um 13:16
    • #18

    32Bit Programme und die Dateidialoge auf 64Bit Betriebsystem



    Auch das Browsen in den Dateidialogen der COMDLG32.DLL oder der SHELL32.DLL läuft unter 64Bit in einem 32Bit Programm anders ab, als auf einem 32Bit Betriebsystem.

    • Der Profandialog ChooseDir$ ( = SHBrowseForFolder) zeigt zum Beispiel beim Wechseln in den SYSTEM32 Ordner nicht die Unterordner des SYSTEM32 Ordners an, sondern die Unterordner von SYSWOW64.
    • Die LoadFile$ ( = GetOpenFileName) und SaveFile$ ( = GetSaveFileName) Dialoge zeigen nicht die Dateien im System32 Ordner und dessen Unterordnern an, sondern die Dateien im Ordner SYSWOW64 und dessen Unterordnern. Hier mal ein paar Screenshots, die dieses Problem verdeutlichen:

      a) Der LodfileDialog - der Ordner %SYSTEMROOT%\System32\Drivers ist geöffnet.
      [Blockierte Grafik: http://s2.postimage.org/Pjvii.jpg]
      b) Der gleich Ordner ist im WindowsExplorer geöffnet, hier aber mit anderem Inhalt:
      [Blockierte Grafik: http://s4.postimage.org/1Vn8ur.jpg]

      c) Hier der WindowsExplorer mit geöffnetem C:\Windows\SYSWOW64\Drivers Ordner:
      [Blockierte Grafik: http://s2.postimage.org/Pla3i.jpg]

    Wichtig: Eine Aufhebung der Dateiumleitung vor dem Aufrufen der Dialoge führt dazu, das der entsprechende Dialog gar nicht mehr angezeigt wird! Eine Aufhebung der Umleitung für diese Dialoge ist scheinbar nicht möglich!

    Zu welchen Problemen kann es für den User kommen, wenn Common Dialogs von 32Bit Programmen verwendet werden, die unter 64Bit laufen:

    • Der User kann eine spezielle Datei aus dem System32 Ordner und dessen Unterordnern nur auswählen, wenn diese Datei auch im SysWOW64 Ordner vorhanden ist, ansonsten wird sie nicht angezeigt. Besonders auffällig wird das im Ordner C:\Windows\System32\Drivers, denn hier zeigt der Dialog kaum eine Datei an.
    • Will der User einen Unterordner des System32 Ordners auswählen, kann er ihn nur auswählen, wenn er auch als Unterordner im SysWOW64 Ordner vorhanden ist - ansonsten wird er nicht angezeigt.

    Anmerkung zur Rückgabe der Dialoge:
    Wer die angesprochenen Dialoge unter Vista bereits einmal genutzt hat wird bemerkt haben, dass die Dialoge die "Displaynames" bei der Rückgabe in ihre wirklichen Pfade umwandeln - aus dem ausgewählten Ordner C:\Benutzer wird zum Beispiel C:\Users (so heißt er im Dateisystem ab Vista).
    Bei den durch die automatische Umleitung geänderten Ordnername ist das natürlich nicht so. Wählt der User zum Beispiel die Datei C:\Windows\System32\atl.dll aus, so steht nicht in der Rückgabe des Dialoges C:\Windows\SysWOW64\atl.dll (das ist ja die eigentlich ausgewählte Datei), sondern (wie angeklickt) C:\Windows\System32\atl.dll.

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 27. Januar 2010 um 15:54
    • #19

    Die Message LB_DIR unter WOW64 versenden



    Auch das Senden der Message LB_DIR ist von der automatischen Umleitung des Dateisystems betroffen, wenn man sie unter 64Bit Systemen von einem 32Bit Programm aus sendet. Will man zum Beispiel mit LB_DIR den Inhalt des Ordners System32 listen lassen, wird auch hier der Inhalt des Ordners SysWOW64 angezeigt. Besonders deutlich wird das beim Ordner C:\Windows\System32\Drivers. Hier ist Code dazu:

    Code
    '#####################################################################################
    '#########                          Code von AHT                             #########
    '#########      Gepostet für [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
     
    DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
     
    Declare ListBox&, FileName$, Checkbox&, Button&
    Declare Wow64EnableWow64FsRedirection&
    Declare Module$, MHANDLE&, Funktion$
    Declare 64Bit&
    Declare Wow64DisableWow64FsRedirection&, OldValue&
     
    Windowstyle 31 + 512
    WindowTitle "LB_DIR Test"
    Window 0, 0 - 640, 440
    Usermessages $10
     
    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
     
    FileName$ = $SYSPATH+"\"+"Drivers\"+"*.*"
    Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 20, 500, 30)
    Button& = Create("Button", %HWND, FileName$+" auslesen", 20, 60, 500, 30)
    Listbox& = Create("ListBox", %HWND, "", 20, 100, 500, 260)
     
    While %Umessage <> $10
     Waitinput
     IF Clicked(Button&)
      EnableWindow Checkbox&, 0
      EnableWindow Button&, 0
      SendMessage(Listbox&, $184, 0, 0) 'Listbox löschen
      'Umleitung deaktivieren
      IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
      SendMessage(Listbox&, $18D, $20 | $2 | $1 | $10, addr(Filename$)) 'LB_DIR senden
      'Umleitung aktivieren
      IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, addr(OldValue&)) : Set("FastMode", 0) : endif
      EnableWindow Checkbox&, 1
      EnableWindow Button&, 1
     endif
    EndWhile
    Alles anzeigen



    Um hier den Inhalt des richtigen Ordners zu erhalten, ist vor dem Aufruf von Sendmessage mit LB_DIR die Umleitung zu deaktivieren und danach sofort wieder zu aktivieren.

    [Blockierte Grafik: http://s2.postimage.org/TPdG0.jpg]

    [Blockierte Grafik: http://s2.postimage.org/TPiFi.jpg]

  • AxT
    Premium-Mitglied
    Reaktionen
    2.978
    Beiträge
    33.384
    • 30. Januar 2010 um 22:17
    • #20

    Profans AddFiles unter 64Bit



    Auch der Profanbefehl Addfiles landet aufgrund der der Umleitung des Dateisystems unter Umständen im falschen Verzeichnis.
    Hier auch Code dazu:

    Code
    '#####################################################################################
    '#########                          Code von AHT                             #########
    '#########      Gepostet für [URL]http://www.paules-pc-forum.de[/URL]                   #########
    '#####################################################################################
    DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
     
    Declare FileName$, Checkbox&, Button&, Edit&
    Declare Wow64EnableWow64FsRedirection&
    Declare Module$, MHANDLE&, Funktion$
    Declare 64Bit&
    Declare Wow64DisableWow64FsRedirection&, OldValue&
     
    Windowstyle 31 + 512
    WindowTitle "AddFiles Test"
    Window 0, 0 - 640, 440
    Usermessages $10
     
    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
     
    FileName$ = $SYSPATH+"\"+"Drivers\"+"*.sys"
    Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
    Button& = Create("Button", %HWND, "auslesen", 20, 60, 500, 30)
    Edit& = Create("Edit", %HWND, FileName$, 20, 20, 500, 30)
     
    While %Umessage <> $10
     Waitinput
     IF Clicked(Button&)
      EnableWindow Checkbox&, 0
      EnableWindow Button&, 0
      clearlist
      'Umleitung deaktivieren
      IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
      Addfiles GetText$(Edit&)
      'Umleitung aktivieren
      IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
      EnableWindow Checkbox&, 1
      EnableWindow Button&, 1
      EditBox("Dateien",1)
     endif
    EndWhile
    Alles anzeigen

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!

Benutzerkonto erstellen Anmelden

Windows 11

  1. Datenschutzerklärung
  2. Impressum
Community-Software: WoltLab Suite™