Angepinnt XProfan & 64-Bit

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

  • XProfan & 64-Bit

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

    Weitere 64-Bit-Threads
    paules-pc-forum.de/forum/xprofan/138034-64-bit-xprofan.html
    paules-pc-forum.de/forum/xprof…unktionieren-bringen.html
    paules-pc-forum.de/forum/xprof…4bit-betriebsystemen.html
    Gruß, Frank
  • Das Grundproblem

    Das Grundproblem


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

    Quellcode

    1. [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.

    Quellcode

    1. 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.
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von AHT ()

  • Auf 64Bit System testen

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT nach einem Beispiel von Andreas Miethe #########
    3. '######### Gepostet für [URL]http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare Module$, MHANDLE&, Funktion$
    8. Declare 64Bit&
    9. Module$="Kernel32.DLL"
    10. Funktion$="IsWow64Process"
    11. MHANDLE&=GetModuleHandle(ADDR(Module$))
    12. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    13. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    14. endif
    15. IF 64Bit&=1
    16. Print "64Bit System"
    17. else
    18. Print "32Bit System"
    19. endif
    20. 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.
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Die Umleitung von Systemordnern und ihre Aufhebung

    Die Umleitung von Systemordnern und ihre Aufhebung


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

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL]http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare Wow64DisableWow64FsRedirection&, OldValue&
    8. Declare Wow64EnableWow64FsRedirection&
    9. Declare Module$, MHANDLE&, Funktion$
    10. Declare 64Bit&
    11. 'Adressen der APIs ermitteln
    12. Module$ = "Kernel32.DLL"
    13. MHANDLE& = GetModuleHandle(ADDR(Module$))
    14. Funktion$ = "Wow64DisableWow64FsRedirection"
    15. Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    16. Funktion$ = "Wow64EnableWow64FsRedirection"
    17. Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    18. 'Auf 64Bit testen
    19. Funktion$ = "IsWow64Process"
    20. MHANDLE& = GetModuleHandle(ADDR(Module$))
    21. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    22. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    23. endif
    24. 'Umleitung deaktivieren
    25. IF 64Bit& = 1 : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    26. 'Umleitung aktivieren
    27. 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!
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Das Codewort SysNative

    Das Codewort SysNative


    Neben der schon beschriebenen Deaktivierung der Umleitung des Dateisystems gibt es eine zweite Möglichkeit, von einem 32Bit Programm aus Zugriff auf den SYSTEM32 ($SYSPATH) Ordner zu erhalten - die Verwendung des Codewortes Sysnative anstatt System32.
    Das heißt: Für C:\Windows\System32 einfach C:\Windows\Sysnative schreiben - das wars.
    Wichtig: Bei manchen Sachen ist es unideal, den Zugriffs mittels Codewort zu regeln, manche APIs funktionieren aber scheinbar nur mittels dieses Codewortes und nicht mit deaktivierter Umleitung! Näheres dazu kommt später
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von AHT ()

  • Der Profan 32Bit Befehl FileSize auf 64Bit Systemen

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare File$, Edit&, Checkbox&, Button&, Wow64DisableWow64FsRedirection&, OldValue&
    8. Declare Wow64EnableWow64FsRedirection&
    9. Declare Module$, MHANDLE&, Funktion$
    10. Declare 64Bit&
    11. Module$ = "Kernel32.DLL"
    12. MHANDLE& = GetModuleHandle(ADDR(Module$))
    13. Funktion$ = "Wow64DisableWow64FsRedirection"
    14. Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    15. Funktion$ = "Wow64EnableWow64FsRedirection"
    16. Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    17. Funktion$ = "IsWow64Process"
    18. MHANDLE& = GetModuleHandle(ADDR(Module$))
    19. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    20. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    21. endif
    22. Windowstyle 31
    23. WindowTitle "FileSize Test"
    24. Window 0, 0 - 640, 440
    25. Decimals 0
    26. Edit& = Create("Edit", %HWND, "C:\Windows\System32\NTDLL.DLL", 20, 20, 500, 30)
    27. Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
    28. Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
    29. Repeat
    30. Waitinput
    31. IF Clicked(Button&)
    32. EnableWindow Checkbox&, 0
    33. EnableWindow Button&, 0
    34. Locate 12, 0
    35. File$ = Gettext$(Edit&)
    36. IF File$ <> ""
    37. 'Umleitung deaktivieren
    38. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    39. IF FileExists(File$)
    40. Print "Größe von " + File$ + ": " + Str$(FileSize(File$))+" Bytes "
    41. else
    42. Print File$ + " existiert nicht!"+" "
    43. endif
    44. 'Umleitung aktivieren
    45. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
    46. endif
    47. EnableWindow Checkbox&, 1
    48. EnableWindow Button&, 1
    49. Else
    50. File$ = " "
    51. endif
    52. 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$, ...
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Die Profan 32Bit Befehle DirExists und FileExists auf 64Bit Systemen

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare Dir$, Edit&, Button&, Checkbox&, Wow64DisableWow64FsRedirection&, OldValue&
    8. Declare Wow64EnableWow64FsRedirection&
    9. Declare Module$, MHANDLE&, Funktion$
    10. Declare 64Bit&
    11. Module$ = "Kernel32.DLL"
    12. MHANDLE& = GetModuleHandle(ADDR(Module$))
    13. Funktion$ = "Wow64DisableWow64FsRedirection"
    14. Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    15. Funktion$ = "Wow64EnableWow64FsRedirection"
    16. Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    17. Funktion$ = "IsWow64Process"
    18. MHANDLE& = GetModuleHandle(ADDR(Module$))
    19. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    20. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    21. endif
    22. Windowstyle 31
    23. WindowTitle "DirExists Test"
    24. Window 0, 0 - 640, 440
    25. Edit& = Create("Edit", %HWND, "C:\Windows\System32\Boot", 20, 20, 500, 30)
    26. Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
    27. Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
    28. Repeat
    29. Waitinput
    30. IF Clicked(Button&)
    31. EnableWindow Checkbox&, 0
    32. EnableWindow Button&, 0
    33. CLS
    34. Locate 12, 0
    35. Dir$ = Gettext$(Edit&)
    36. IF Dir$ <> ""
    37. 'Umleitung deaktivieren
    38. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    39. IF DirExists(Dir$)
    40. Print Dir$ + " existiert!"
    41. else
    42. Print Dir$ + " existiert nicht!"
    43. endif
    44. 'Umleitung aktivieren
    45. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
    46. EnableWindow Checkbox&, 1
    47. EnableWindow Button&, 1
    48. endif
    49. Else
    50. Dir$ = " "
    51. endif
    52. 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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare File$, Edit&, Checkbox&, Button&, Wow64DisableWow64FsRedirection&, OldValue&
    8. Declare Wow64EnableWow64FsRedirection&
    9. Declare Module$, MHANDLE&, Funktion$
    10. Declare 64Bit&
    11. Module$ = "Kernel32.DLL"
    12. MHANDLE& = GetModuleHandle(ADDR(Module$))
    13. Funktion$ = "Wow64DisableWow64FsRedirection"
    14. Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    15. Funktion$ = "Wow64EnableWow64FsRedirection"
    16. Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    17. Funktion$ = "IsWow64Process"
    18. MHANDLE& = GetModuleHandle(ADDR(Module$))
    19. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    20. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    21. endif
    22. Windowstyle 31
    23. WindowTitle "FileExists Test"
    24. Window 0, 0 - 640, 440
    25. Edit& = Create("Edit", %HWND, "C:\Windows\System32\Drivers\ACPI.SYS", 20, 20, 500, 30)
    26. Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
    27. Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
    28. Repeat
    29. Waitinput
    30. IF Clicked(Button&)
    31. EnableWindow Checkbox&, 0
    32. EnableWindow Button&, 0
    33. CLS
    34. Locate 12, 0
    35. File$ = Gettext$(Edit&)
    36. IF File$ <> ""
    37. 'Umleitung deaktivieren
    38. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    39. IF FileExists(File$)
    40. Print File$ + " existiert!"
    41. else
    42. Print File$ + " existiert nicht!"
    43. endif
    44. 'Umleitung aktivieren
    45. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
    46. endif
    47. EnableWindow Checkbox&, 1
    48. EnableWindow Button&, 1
    49. Else
    50. File$ = " "
    51. endif
    52. until File$ = ""
    Alles anzeigen


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

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

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Der Profan 32Bit Befehl FindFirst$ auf 64Bit Systemen

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

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für http://www.paules-pc-forum.de #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare File$, Edit&, Button&, Checkbox&, Wow64DisableWow64FsRedirection&, OldValue&
    8. Declare Wow64EnableWow64FsRedirection&
    9. Declare Module$, MHANDLE&, Funktion$, Dir$
    10. Declare 64Bit&
    11. Decimals 0
    12. Module$ = "Kernel32.DLL"
    13. MHANDLE& = GetModuleHandle(ADDR(Module$))
    14. Funktion$ = "Wow64DisableWow64FsRedirection"
    15. Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    16. Funktion$ = "Wow64EnableWow64FsRedirection"
    17. Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    18. Funktion$ = "IsWow64Process"
    19. MHANDLE& = GetModuleHandle(ADDR(Module$))
    20. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    21. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    22. endif
    23. Windowstyle 31
    24. WindowTitle "FindFirst$ Test"
    25. Window 0, 0 - 640, 440
    26. Edit& = Create("Edit", %HWND, "C:\Windows\System32\Drivers", 20, 20, 500, 30)
    27. Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
    28. Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
    29. Repeat
    30. Waitinput
    31. IF Clicked(Button&)
    32. EnableWindow Checkbox&, 0
    33. EnableWindow Button&, 0
    34. ClearList
    35. Dir$ = Gettext$(Edit&)
    36. 'Umleitung deaktivieren
    37. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    38. File$ = FindFirst$(Dir$ + "" + "*.*")
    39. 'Umleitung aktivieren
    40. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
    41. While File$<>""
    42. Locate 12, 0
    43. Print Dir$ + "" + File$ + " "
    44. 'Umleitung deaktivieren
    45. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    46. IF (FileExists(Dir$ + "" + File$) = 1) or (DirExists(Dir$ + "" + File$) = 1)
    47. Assign #1, Dir$ + "" + File$
    48. IF DirExists(Dir$ + "" + File$) = 1
    49. Addstring Dir$ + "" + File$ + ": Geändert-> " + GetFDate$(#1)
    50. elseif (FileExists(Dir$ + "" + File$) = 1)
    51. Addstring Dir$ + "" + File$ + ": Geändert-> " + GetFDate$(#1) + ", Größe -> " + Str$(FileSize(Dir$ + "" + File$)) + " Bytes"
    52. endif
    53. endif
    54. 'Umleitung aktivieren
    55. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
    56. File$ = FindNext$()
    57. EndWhile
    58. EnableWindow Checkbox&, 1
    59. EnableWindow Button&, 1
    60. Editbox("Dateien in " + Dir$, 1)
    61. Print %IORESULT
    62. Print %IORESULT
    63. endif
    64. until 0
    Alles anzeigen
    Ist die Umleitung noch aktiviert, liefert bei mir der Code folgende Rückmeldung:

    Quellcode

    1. C:\Windows\System32\Drivers\gm.dls: Geändert-> 20090610, Größe -> 3440660 Bytes
    2. C:\Windows\System32\Drivers\gmreadme.txt: Geändert-> 20090610, Größe -> 646 Bytes
    3. C:\Windows\System32\Drivers\ssmdrv.sys: Geändert-> 20090511, Größe -> 28520 Bytes
    4. C:\Windows\System32\Drivers\wimmount.sys: Geändert-> 20090714, Größe -> 19008 Bytes
    Ist die Umleitung deaktiviert, listet der Code folgende Dateien:

    Quellcode

    1. C:\Windows\System32\Drivers\1394bus.sys: Geändert-> 20090714, Größe -> 68096 Bytes
    2. C:\Windows\System32\Drivers\1394ohci.sys: Geändert-> 20090714, Größe -> 227840 Bytes
    3. C:\Windows\System32\Drivers\acpi.sys: Geändert-> 20090714, Größe -> 334416 Bytes
    4. C:\Windows\System32\Drivers\acpipmi.sys: Geändert-> 20090714, Größe -> 12288 Bytes
    5. C:\Windows\System32\Drivers\adp94xx.sys: Geändert-> 20090714, Größe -> 491088 Bytes
    6. C:\Windows\System32\Drivers\adpahci.sys: Geändert-> 20090714, Größe -> 339536 Bytes
    7. C:\Windows\System32\Drivers\adpu320.sys: Geändert-> 20090714, Größe -> 182864 Bytes
    8. C:\Windows\System32\Drivers\afd.sys: Geändert-> 20090714, Größe -> 500224 Bytes
    9. C:\Windows\System32\Drivers\agilevpn.sys: Geändert-> 20090714, Größe -> 60416 Bytes
    10. C:\Windows\System32\Drivers\AGP440.sys: Geändert-> 20090714, Größe -> 61008 Bytes
    11. C:\Windows\System32\Drivers\aliide.sys: Geändert-> 20090714, Größe -> 15440 Bytes
    12. C:\Windows\System32\Drivers\amdide.sys: Geändert-> 20090714, Größe -> 15440 Bytes
    13. C:\Windows\System32\Drivers\amdk8.sys: Geändert-> 20090714, Größe -> 64512 Bytes
    14. C:\Windows\System32\Drivers\amdppm.sys: Geändert-> 20090714, Größe -> 60928 Bytes
    15. C:\Windows\System32\Drivers\amdsata.sys: Geändert-> 20090714, Größe -> 106576 Bytes
    16. C:\Windows\System32\Drivers\amdsbs.sys: Geändert-> 20090714, Größe -> 194128 Bytes
    17. C:\Windows\System32\Drivers\amdxata.sys: Geändert-> 20090714, Größe -> 28752 Bytes
    18. C:\Windows\System32\Drivers\appid.sys: Geändert-> 20090714, Größe -> 61440 Bytes
    19. C:\Windows\System32\Drivers\arc.sys: Geändert-> 20090714, Größe -> 87632 Bytes
    20. C:\Windows\System32\Drivers\arcsas.sys: Geändert-> 20090714, Größe -> 97856 Bytes
    21. C:\Windows\System32\Drivers\asyncmac.sys: Geändert-> 20090714, Größe -> 23040 Bytes
    22. C:\Windows\System32\Drivers\atapi.sys: Geändert-> 20090714, Größe -> 24128 Bytes
    23. C:\Windows\System32\Drivers\ataport.sys: Geändert-> 20090714, Größe -> 155728 Bytes
    24. C:\Windows\System32\Drivers\athrx.sys: Geändert-> 20090620, Größe -> 1394688 Bytes
    25. C:\Windows\System32\Drivers\avgntflt.sys: Geändert-> 20091125, Größe -> 74880 Bytes
    26. C:\Windows\System32\Drivers\b57nd60a.sys: Geändert-> 20090610, Größe -> 270848 Bytes
    27. C:\Windows\System32\Drivers\battc.sys: Geändert-> 20090714, Größe -> 28240 Bytes
    28. C:\Windows\System32\Drivers\beep.sys: Geändert-> 20090714, Größe -> 6656 Bytes
    29. C:\Windows\System32\Drivers\blbdrive.sys: Geändert-> 20090714, Größe -> 45056 Bytes
    30. C:\Windows\System32\Drivers\bowser.sys: Geändert-> 20090714, Größe -> 90624 Bytes
    31. C:\Windows\System32\Drivers\BrFiltLo.sys: Geändert-> 20090610, Größe -> 18432 Bytes
    32. C:\Windows\System32\Drivers\BrFiltUp.sys: Geändert-> 20090610, Größe -> 8704 Bytes
    33. C:\Windows\System32\Drivers\bridge.sys: Geändert-> 20090714, Größe -> 95232 Bytes
    34. C:\Windows\System32\Drivers\BrSerId.sys: Geändert-> 20090714, Größe -> 286720 Bytes
    35. C:\Windows\System32\Drivers\BrSerWdm.sys: Geändert-> 20090610, Größe -> 47104 Bytes
    36. C:\Windows\System32\Drivers\BrUsbMdm.sys: Geändert-> 20090610, Größe -> 14976 Bytes
    37. C:\Windows\System32\Drivers\BrUsbSer.sys: Geändert-> 20090610, Größe -> 14720 Bytes
    38. C:\Windows\System32\Drivers\bthmodem.sys: Geändert-> 20090714, Größe -> 72192 Bytes
    39. C:\Windows\System32\Drivers\bxvbda.sys: Geändert-> 20090610, Größe -> 468480 Bytes
    40. C:\Windows\System32\Drivers\cdfs.sys: Geändert-> 20090714, Größe -> 92160 Bytes
    41. C:\Windows\System32\Drivers\cdrom.sys: Geändert-> 20090714, Größe -> 147456 Bytes
    42. C:\Windows\System32\Drivers\circlass.sys: Geändert-> 20090714, Größe -> 45568 Bytes
    43. C:\Windows\System32\Drivers\Classpnp.sys: Geändert-> 20090714, Größe -> 178752 Bytes
    44. C:\Windows\System32\Drivers\CmBatt.sys: Geändert-> 20090714, Größe -> 17664 Bytes
    45. C:\Windows\System32\Drivers\cmdide.sys: Geändert-> 20090714, Größe -> 17488 Bytes
    46. C:\Windows\System32\Drivers\cng.sys: Geändert-> 20090714, Größe -> 460504 Bytes
    47. C:\Windows\System32\Drivers\compbatt.sys: Geändert-> 20090714, Größe -> 21584 Bytes
    48. C:\Windows\System32\Drivers\CompositeBus.sys: Geändert-> 20090714, Größe -> 38912 Bytes
    49. C:\Windows\System32\Drivers\CPQBttn64.sys: Geändert-> 20090420, Größe -> 11264 Bytes
    50. C:\Windows\System32\Drivers\crashdmp.sys: Geändert-> 20090714, Größe -> 39504 Bytes
    51. C:\Windows\System32\Drivers\crcdisk.sys: Geändert-> 20090714, Größe -> 24144 Bytes
    52. C:\Windows\System32\Drivers\dfsc.sys: Geändert-> 20090714, Größe -> 102400 Bytes
    53. C:\Windows\System32\Drivers\discache.sys: Geändert-> 20090714, Größe -> 40448 Bytes
    54. C:\Windows\System32\Drivers\disk.sys: Geändert-> 20090714, Größe -> 73280 Bytes
    55. C:\Windows\System32\Drivers\Diskdump.sys: Geändert-> 20090714, Größe -> 27216 Bytes
    56. C:\Windows\System32\Drivers\drmk.sys: Geändert-> 20090714, Größe -> 116224 Bytes
    57. C:\Windows\System32\Drivers\drmkaud.sys: Geändert-> 20090714, Größe -> 5632 Bytes
    58. C:\Windows\System32\Drivers\Dumpata.sys: Geändert-> 20090714, Größe -> 28736 Bytes
    59. C:\Windows\System32\Drivers\dumpfve.sys: Geändert-> 20090714, Größe -> 55128 Bytes
    60. C:\Windows\System32\Drivers\dxapi.sys: Geändert-> 20090714, Größe -> 16896 Bytes
    61. C:\Windows\System32\Drivers\dxg.sys: Geändert-> 20090714, Größe -> 98816 Bytes
    62. C:\Windows\System32\Drivers\dxgkrnl.sys: Geändert-> 20091002, Größe -> 982600 Bytes
    63. C:\Windows\System32\Drivers\dxgmms1.sys: Geändert-> 20090714, Größe -> 258048 Bytes
    64. C:\Windows\System32\Drivers\elxstor.sys: Geändert-> 20090714, Größe -> 530496 Bytes
    65. C:\Windows\System32\Drivers\errdev.sys: Geändert-> 20090714, Größe -> 9728 Bytes
    66. C:\Windows\System32\Drivers\evbda.sys: Geändert-> 20090610, Größe -> 3286016 Bytes
    67. C:\Windows\System32\Drivers\exfat.sys: Geändert-> 20090714, Größe -> 195072 Bytes
    68. C:\Windows\System32\Drivers\fastfat.sys: Geändert-> 20090714, Größe -> 204800 Bytes
    69. C:\Windows\System32\Drivers\fdc.sys: Geändert-> 20090714, Größe -> 29696 Bytes
    70. C:\Windows\System32\Drivers\fileinfo.sys: Geändert-> 20090714, Größe -> 70224 Bytes
    71. C:\Windows\System32\Drivers\filetrace.sys: Geändert-> 20090714, Größe -> 34304 Bytes
    72. C:\Windows\System32\Drivers\flpydisk.sys: Geändert-> 20090714, Größe -> 24576 Bytes
    73. C:\Windows\System32\Drivers\fltMgr.sys: Geändert-> 20090714, Größe -> 290368 Bytes
    74. C:\Windows\System32\Drivers\fsdepends.sys: Geändert-> 20090714, Größe -> 55376 Bytes
    75. C:\Windows\System32\Drivers\fs_rec.sys: Geändert-> 20090714, Größe -> 23104 Bytes
    76. C:\Windows\System32\Drivers\fvevol.sys: Geändert-> 20090714, Größe -> 223448 Bytes
    77. C:\Windows\System32\Drivers\FWPKCLNT.SYS: Geändert-> 20090714, Größe -> 288336 Bytes
    78. C:\Windows\System32\Drivers\GAGP30KX.SYS: Geändert-> 20090714, Größe -> 65088 Bytes
    79. C:\Windows\System32\Drivers\gm.dls: Geändert-> 20090610, Größe -> 3440660 Bytes
    80. C:\Windows\System32\Drivers\gmreadme.txt: Geändert-> 20090610, Größe -> 646 Bytes
    81. C:\Windows\System32\Drivers\hcw85cir.sys: Geändert-> 20090610, Größe -> 31232 Bytes
    82. C:\Windows\System32\Drivers\hdaudbus.sys: Geändert-> 20090714, Größe -> 122368 Bytes
    83. C:\Windows\System32\Drivers\HdAudio.sys: Geändert-> 20090714, Größe -> 350208 Bytes
    84. C:\Windows\System32\Drivers\hidbatt.sys: Geändert-> 20090714, Größe -> 26624 Bytes
    85. C:\Windows\System32\Drivers\hidbth.sys: Geändert-> 20090714, Größe -> 100864 Bytes
    86. C:\Windows\System32\Drivers\hidclass.sys: Geändert-> 20090714, Größe -> 76288 Bytes
    87. C:\Windows\System32\Drivers\hidir.sys: Geändert-> 20090714, Größe -> 46592 Bytes
    88. C:\Windows\System32\Drivers\hidparse.sys: Geändert-> 20090714, Größe -> 32896 Bytes
    89. C:\Windows\System32\Drivers\hidusb.sys: Geändert-> 20090714, Größe -> 30208 Bytes
    90. C:\Windows\System32\Drivers\HpSAMD.sys: Geändert-> 20090714, Größe -> 77888 Bytes
    91. C:\Windows\System32\Drivers\http.sys: Geändert-> 20090714, Größe -> 751616 Bytes
    92. C:\Windows\System32\Drivers\hwpolicy.sys: Geändert-> 20090714, Größe -> 14416 Bytes
    93. C:\Windows\System32\Drivers\i8042prt.sys: Geändert-> 20090714, Größe -> 105472 Bytes
    94. C:\Windows\System32\Drivers\iaStorV.sys: Geändert-> 20090714, Größe -> 410688 Bytes
    95. C:\Windows\System32\Drivers\iirsp.sys: Geändert-> 20090714, Größe -> 44112 Bytes
    96. C:\Windows\System32\Drivers\intelide.sys: Geändert-> 20090714, Größe -> 16960 Bytes
    97. C:\Windows\System32\Drivers\intelppm.sys: Geändert-> 20090714, Größe -> 62464 Bytes
    98. C:\Windows\System32\Drivers\ipfltdrv.sys: Geändert-> 20090714, Größe -> 82944 Bytes
    99. C:\Windows\System32\Drivers\IPMIDrv.sys: Geändert-> 20090714, Größe -> 78848 Bytes
    100. C:\Windows\System32\Drivers\ipnat.sys: Geändert-> 20090714, Größe -> 116224 Bytes
    101. C:\Windows\System32\Drivers\irda.sys: Geändert-> 20090714, Größe -> 120320 Bytes
    102. C:\Windows\System32\Drivers\irenum.sys: Geändert-> 20090714, Größe -> 17920 Bytes
    103. C:\Windows\System32\Drivers\isapnp.sys: Geändert-> 20090714, Größe -> 20544 Bytes
    104. C:\Windows\System32\Drivers\kbdclass.sys: Geändert-> 20090714, Größe -> 50768 Bytes
    105. C:\Windows\System32\Drivers\kbdhid.sys: Geändert-> 20090714, Größe -> 33280 Bytes
    106. C:\Windows\System32\Drivers\ks.sys: Geändert-> 20090714, Größe -> 243200 Bytes
    107. C:\Windows\System32\Drivers\ksecdd.sys: Geändert-> 20090714, Größe -> 95312 Bytes
    108. C:\Windows\System32\Drivers\ksecpkg.sys: Geändert-> 20090714, Größe -> 153152 Bytes
    109. C:\Windows\System32\Drivers\ksthunk.sys: Geändert-> 20090714, Größe -> 20992 Bytes
    110. C:\Windows\System32\Drivers\lltdio.sys: Geändert-> 20090714, Größe -> 60928 Bytes
    111. C:\Windows\System32\Drivers\lsi_fc.sys: Geändert-> 20090714, Größe -> 114752 Bytes
    112. C:\Windows\System32\Drivers\lsi_sas.sys: Geändert-> 20090714, Größe -> 106560 Bytes
    113. C:\Windows\System32\Drivers\lsi_sas2.sys: Geändert-> 20090714, Größe -> 65600 Bytes
    114. C:\Windows\System32\Drivers\lsi_scsi.sys: Geändert-> 20090714, Größe -> 115776 Bytes
    115. C:\Windows\System32\Drivers\luafv.sys: Geändert-> 20090714, Größe -> 113152 Bytes
    116. C:\Windows\System32\Drivers\mcd.sys: Geändert-> 20090714, Größe -> 22016 Bytes
    117. C:\Windows\System32\Drivers\megasas.sys: Geändert-> 20090714, Größe -> 35392 Bytes
    118. C:\Windows\System32\Drivers\MegaSR.sys: Geändert-> 20090714, Größe -> 284736 Bytes
    119. C:\Windows\System32\Drivers\modem.sys: Geändert-> 20090714, Größe -> 40448 Bytes
    120. C:\Windows\System32\Drivers\monitor.sys: Geändert-> 20090714, Größe -> 30208 Bytes
    121. C:\Windows\System32\Drivers\mouclass.sys: Geändert-> 20090714, Größe -> 49216 Bytes
    122. C:\Windows\System32\Drivers\mouhid.sys: Geändert-> 20090714, Größe -> 31232 Bytes
    123. C:\Windows\System32\Drivers\mountmgr.sys: Geändert-> 20090714, Größe -> 94784 Bytes
    124. C:\Windows\System32\Drivers\mpio.sys: Geändert-> 20090714, Größe -> 155216 Bytes
    125. C:\Windows\System32\Drivers\mpsdrv.sys: Geändert-> 20090714, Größe -> 77312 Bytes
    126. C:\Windows\System32\Drivers\mrxdav.sys: Geändert-> 20090714, Größe -> 140800 Bytes
    127. C:\Windows\System32\Drivers\mrxsmb.sys: Geändert-> 20090714, Größe -> 157184 Bytes
    128. C:\Windows\System32\Drivers\mrxsmb10.sys: Geändert-> 20090714, Größe -> 285696 Bytes
    129. C:\Windows\System32\Drivers\mrxsmb20.sys: Geändert-> 20090714, Größe -> 125952 Bytes
    130. C:\Windows\System32\Drivers\msahci.sys: Geändert-> 20090714, Größe -> 30272 Bytes
    131. C:\Windows\System32\Drivers\msdsm.sys: Geändert-> 20090714, Größe -> 140352 Bytes
    132. C:\Windows\System32\Drivers\msfs.sys: Geändert-> 20090714, Größe -> 26112 Bytes
    133. C:\Windows\System32\Drivers\MsftWdf_Kernel_01009_Inbox_Critical.Wdf: Geändert-> 20090610, Größe -> 3 Bytes
    134. C:\Windows\System32\Drivers\mshidkmdf.sys: Geändert-> 20090714, Größe -> 8192 Bytes
    135. C:\Windows\System32\Drivers\msisadrv.sys: Geändert-> 20090714, Größe -> 15424 Bytes
    136. C:\Windows\System32\Drivers\msiscsi.sys: Geändert-> 20090714, Größe -> 224832 Bytes
    137. C:\Windows\System32\Drivers\mskssrv.sys: Geändert-> 20090714, Größe -> 11136 Bytes
    138. C:\Windows\System32\Drivers\mspclock.sys: Geändert-> 20090714, Größe -> 7168 Bytes
    139. C:\Windows\System32\Drivers\mspqm.sys: Geändert-> 20090714, Größe -> 6784 Bytes
    140. C:\Windows\System32\Drivers\msrpc.sys: Geändert-> 20090714, Größe -> 367168 Bytes
    141. C:\Windows\System32\Drivers\mssmbios.sys: Geändert-> 20090714, Größe -> 32320 Bytes
    142. C:\Windows\System32\Drivers\mstee.sys: Geändert-> 20090714, Größe -> 8064 Bytes
    143. C:\Windows\System32\Drivers\MTConfig.sys: Geändert-> 20090714, Größe -> 15360 Bytes
    144. C:\Windows\System32\Drivers\mup.sys: Geändert-> 20090714, Größe -> 60496 Bytes
    145. C:\Windows\System32\Drivers\ndis.sys: Geändert-> 20090714, Größe -> 947776 Bytes
    146. C:\Windows\System32\Drivers\ndiscap.sys: Geändert-> 20090714, Größe -> 35328 Bytes
    147. C:\Windows\System32\Drivers\ndistapi.sys: Geändert-> 20090714, Größe -> 24064 Bytes
    148. C:\Windows\System32\Drivers\ndisuio.sys: Geändert-> 20090714, Größe -> 56320 Bytes
    149. C:\Windows\System32\Drivers\ndiswan.sys: Geändert-> 20090714, Größe -> 164352 Bytes
    150. C:\Windows\System32\Drivers\ndproxy.sys: Geändert-> 20090714, Größe -> 57856 Bytes
    151. C:\Windows\System32\Drivers\netbios.sys: Geändert-> 20090714, Größe -> 44544 Bytes
    152. C:\Windows\System32\Drivers\netbt.sys: Geändert-> 20090714, Größe -> 259072 Bytes
    153. C:\Windows\System32\Drivers\netio.sys: Geändert-> 20090714, Größe -> 374864 Bytes
    154. C:\Windows\System32\Drivers\nfrd960.sys: Geändert-> 20090714, Größe -> 51264 Bytes
    155. C:\Windows\System32\Drivers\npfs.sys: Geändert-> 20090714, Größe -> 44032 Bytes
    156. C:\Windows\System32\Drivers\nsiproxy.sys: Geändert-> 20090714, Größe -> 24576 Bytes
    157. C:\Windows\System32\Drivers\ntfs.sys: Geändert-> 20090714, Größe -> 1659984 Bytes
    158. C:\Windows\System32\Drivers\null.sys: Geändert-> 20090714, Größe -> 6144 Bytes
    159. C:\Windows\System32\Drivers\nvlddmkm.sys: Geändert-> 20090306, Größe -> 9677600 Bytes
    160. C:\Windows\System32\Drivers\nvm62x64.sys: Geändert-> 20090610, Größe -> 408960 Bytes
    161. C:\Windows\System32\Drivers\nvraid.sys: Geändert-> 20090714, Größe -> 149056 Bytes
    162. C:\Windows\System32\Drivers\nvstor.sys: Geändert-> 20090714, Größe -> 167488 Bytes
    163. C:\Windows\System32\Drivers\NV_AGP.SYS: Geändert-> 20090714, Größe -> 122960 Bytes
    164. C:\Windows\System32\Drivers\nwifi.sys: Geändert-> 20090714, Größe -> 318976 Bytes
    165. C:\Windows\System32\Drivers\ohci1394.sys: Geändert-> 20090714, Größe -> 72832 Bytes
    166. C:\Windows\System32\Drivers\pacer.sys: Geändert-> 20090714, Größe -> 131584 Bytes
    167. C:\Windows\System32\Drivers\parport.sys: Geändert-> 20090714, Größe -> 97280 Bytes
    168. C:\Windows\System32\Drivers\partmgr.sys: Geändert-> 20090714, Größe -> 75840 Bytes
    169. C:\Windows\System32\Drivers\pci.sys: Geändert-> 20090714, Größe -> 183872 Bytes
    170. C:\Windows\System32\Drivers\pciide.sys: Geändert-> 20090714, Größe -> 12352 Bytes
    171. C:\Windows\System32\Drivers\pciidex.sys: Geändert-> 20090714, Größe -> 48720 Bytes
    172. C:\Windows\System32\Drivers\pcmcia.sys: Geändert-> 20090714, Größe -> 220752 Bytes
    173. C:\Windows\System32\Drivers\pcw.sys: Geändert-> 20090714, Größe -> 50768 Bytes
    174. C:\Windows\System32\Drivers\PEAuth.sys: Geändert-> 20090714, Größe -> 651264 Bytes
    175. C:\Windows\System32\Drivers\portcls.sys: Geändert-> 20090714, Größe -> 230400 Bytes
    176. C:\Windows\System32\Drivers\processr.sys: Geändert-> 20090714, Größe -> 60416 Bytes
    177. C:\Windows\System32\Drivers\ql2300.sys: Geändert-> 20090714, Größe -> 1524816 Bytes
    178. C:\Windows\System32\Drivers\ql40xx.sys: Geändert-> 20090714, Größe -> 128592 Bytes
    179. C:\Windows\System32\Drivers\qwavedrv.sys: Geändert-> 20090714, Größe -> 46592 Bytes
    180. C:\Windows\System32\Drivers\rasacd.sys: Geändert-> 20090714, Größe -> 14848 Bytes
    181. C:\Windows\System32\Drivers\rasl2tp.sys: Geändert-> 20090714, Größe -> 130048 Bytes
    182. C:\Windows\System32\Drivers\raspppoe.sys: Geändert-> 20090714, Größe -> 92672 Bytes
    183. C:\Windows\System32\Drivers\raspptp.sys: Geändert-> 20090714, Größe -> 111616 Bytes
    184. C:\Windows\System32\Drivers\rassstp.sys: Geändert-> 20090714, Größe -> 83968 Bytes
    185. C:\Windows\System32\Drivers\rdbss.sys: Geändert-> 20090714, Größe -> 309248 Bytes
    186. C:\Windows\System32\Drivers\rdpbus.sys: Geändert-> 20090714, Größe -> 24064 Bytes
    187. C:\Windows\System32\Drivers\RDPCDD.sys: Geändert-> 20090714, Größe -> 7680 Bytes
    188. C:\Windows\System32\Drivers\RDPENCDD.sys: Geändert-> 20090714, Größe -> 7680 Bytes
    189. C:\Windows\System32\Drivers\RDPREFMP.sys: Geändert-> 20090714, Größe -> 8192 Bytes
    190. C:\Windows\System32\Drivers\rdpwd.sys: Geändert-> 20090714, Größe -> 204800 Bytes
    191. C:\Windows\System32\Drivers\rdyboost.sys: Geändert-> 20090714, Größe -> 214096 Bytes
    192. C:\Windows\System32\Drivers\rmcast.sys: Geändert-> 20090714, Größe -> 145920 Bytes
    193. C:\Windows\System32\Drivers\RNDISMP.sys: Geändert-> 20090714, Größe -> 41472 Bytes
    194. C:\Windows\System32\Drivers\rootmdm.sys: Geändert-> 20090714, Größe -> 11264 Bytes
    195. C:\Windows\System32\Drivers\rspndr.sys: Geändert-> 20090714, Größe -> 76800 Bytes
    196. C:\Windows\System32\Drivers\sbp2port.sys: Geändert-> 20090714, Größe -> 104016 Bytes
    197. C:\Windows\System32\Drivers\scfilter.sys: Geändert-> 20090714, Größe -> 29696 Bytes
    198. C:\Windows\System32\Drivers\scsiport.sys: Geändert-> 20090714, Größe -> 171600 Bytes
    199. C:\Windows\System32\Drivers\secdrv.sys: Geändert-> 20090610, Größe -> 23040 Bytes
    200. C:\Windows\System32\Drivers\serenum.sys: Geändert-> 20090714, Größe -> 23552 Bytes
    201. C:\Windows\System32\Drivers\serial.sys: Geändert-> 20090714, Größe -> 94208 Bytes
    202. C:\Windows\System32\Drivers\sermouse.sys: Geändert-> 20090714, Größe -> 26624 Bytes
    203. C:\Windows\System32\Drivers\sffdisk.sys: Geändert-> 20090714, Größe -> 14336 Bytes
    204. C:\Windows\System32\Drivers\sffp_mmc.sys: Geändert-> 20090714, Größe -> 13824 Bytes
    205. C:\Windows\System32\Drivers\sffp_sd.sys: Geändert-> 20090714, Größe -> 14336 Bytes
    206. C:\Windows\System32\Drivers\sfloppy.sys: Geändert-> 20090714, Größe -> 16896 Bytes
    207. C:\Windows\System32\Drivers\sisraid2.sys: Geändert-> 20090714, Größe -> 43584 Bytes
    208. C:\Windows\System32\Drivers\sisraid4.sys: Geändert-> 20090714, Größe -> 80464 Bytes
    209. C:\Windows\System32\Drivers\smb.sys: Geändert-> 20090714, Größe -> 93184 Bytes
    210. C:\Windows\System32\Drivers\smclib.sys: Geändert-> 20090714, Größe -> 20992 Bytes
    211. C:\Windows\System32\Drivers\spldr.sys: Geändert-> 20090714, Größe -> 19008 Bytes
    212. C:\Windows\System32\Drivers\spsys.sys: Geändert-> 20090610, Größe -> 426496 Bytes
    213. C:\Windows\System32\Drivers\srv.sys: Geändert-> 20090714, Größe -> 465408 Bytes
    214. C:\Windows\System32\Drivers\srv2.sys: Geändert-> 20090714, Größe -> 407040 Bytes
    215. C:\Windows\System32\Drivers\srvnet.sys: Geändert-> 20090714, Größe -> 162816 Bytes
    216. C:\Windows\System32\Drivers\stexstor.sys: Geändert-> 20090714, Größe -> 24656 Bytes
    217. C:\Windows\System32\Drivers\storport.sys: Geändert-> 20090714, Größe -> 185936 Bytes
    218. C:\Windows\System32\Drivers\stream.sys: Geändert-> 20090714, Größe -> 68864 Bytes
    219. C:\Windows\System32\Drivers\swenum.sys: Geändert-> 20090714, Größe -> 12496 Bytes
    220. C:\Windows\System32\Drivers\tape.sys: Geändert-> 20090714, Größe -> 29184 Bytes
    221. C:\Windows\System32\Drivers\tcpip.sys: Geändert-> 20090714, Größe -> 1898576 Bytes
    222. C:\Windows\System32\Drivers\tcpipreg.sys: Geändert-> 20090714, Größe -> 44544 Bytes
    223. C:\Windows\System32\Drivers\tdi.sys: Geändert-> 20090714, Größe -> 26624 Bytes
    224. C:\Windows\System32\Drivers\tdpipe.sys: Geändert-> 20090714, Größe -> 15872 Bytes
    225. C:\Windows\System32\Drivers\tdtcp.sys: Geändert-> 20090714, Größe -> 23552 Bytes
    226. C:\Windows\System32\Drivers\tdx.sys: Geändert-> 20090714, Größe -> 99840 Bytes
    227. C:\Windows\System32\Drivers\termdd.sys: Geändert-> 20090714, Größe -> 62544 Bytes
    228. C:\Windows\System32\Drivers\tssecsrv.sys: Geändert-> 20090714, Größe -> 38400 Bytes
    229. C:\Windows\System32\Drivers\tunnel.sys: Geändert-> 20090714, Größe -> 125440 Bytes
    230. C:\Windows\System32\Drivers\UAGP35.SYS: Geändert-> 20090714, Größe -> 64080 Bytes
    231. C:\Windows\System32\Drivers\udfs.sys: Geändert-> 20090714, Größe -> 327168 Bytes
    232. C:\Windows\System32\Drivers\ULIAGPKX.SYS: Geändert-> 20090714, Größe -> 64592 Bytes
    233. C:\Windows\System32\Drivers\umbus.sys: Geändert-> 20090714, Größe -> 48640 Bytes
    234. C:\Windows\System32\Drivers\umpass.sys: Geändert-> 20090714, Größe -> 9728 Bytes
    235. C:\Windows\System32\Drivers\usb8023.sys: Geändert-> 20090714, Größe -> 19968 Bytes
    236. C:\Windows\System32\Drivers\USBCAMD2.sys: Geändert-> 20090714, Größe -> 32896 Bytes
    237. C:\Windows\System32\Drivers\usbccgp.sys: Geändert-> 20090714, Größe -> 98816 Bytes
    238. C:\Windows\System32\Drivers\usbcir.sys: Geändert-> 20090714, Größe -> 100352 Bytes
    239. C:\Windows\System32\Drivers\usbd.sys: Geändert-> 20090714, Größe -> 7936 Bytes
    240. C:\Windows\System32\Drivers\usbehci.sys: Geändert-> 20090714, Größe -> 51200 Bytes
    241. C:\Windows\System32\Drivers\usbhub.sys: Geändert-> 20090714, Größe -> 343040 Bytes
    242. C:\Windows\System32\Drivers\usbohci.sys: Geändert-> 20090714, Größe -> 25600 Bytes
    243. C:\Windows\System32\Drivers\usbport.sys: Geändert-> 20090714, Größe -> 324608 Bytes
    244. C:\Windows\System32\Drivers\usbprint.sys: Geändert-> 20090714, Größe -> 25088 Bytes
    245. C:\Windows\System32\Drivers\usbrpm.sys: Geändert-> 20090714, Größe -> 31744 Bytes
    246. C:\Windows\System32\Drivers\USBSTOR.SYS: Geändert-> 20090714, Größe -> 89600 Bytes
    247. C:\Windows\System32\Drivers\usbuhci.sys: Geändert-> 20090714, Größe -> 30720 Bytes
    248. C:\Windows\System32\Drivers\usbvideo.sys: Geändert-> 20090714, Größe -> 184576 Bytes
    249. C:\Windows\System32\Drivers\vdrvroot.sys: Geändert-> 20090714, Größe -> 36432 Bytes
    250. C:\Windows\System32\Drivers\vga.sys: Geändert-> 20090714, Größe -> 29184 Bytes
    251. C:\Windows\System32\Drivers\vgapnp.sys: Geändert-> 20090714, Größe -> 29184 Bytes
    252. C:\Windows\System32\Drivers\vhdmp.sys: Geändert-> 20090714, Größe -> 217680 Bytes
    253. C:\Windows\System32\Drivers\viaide.sys: Geändert-> 20090714, Größe -> 17488 Bytes
    254. C:\Windows\System32\Drivers\videoprt.sys: Geändert-> 20090714, Größe -> 129024 Bytes
    255. C:\Windows\System32\Drivers\volmgr.sys: Geändert-> 20090714, Größe -> 71760 Bytes
    256. C:\Windows\System32\Drivers\volmgrx.sys: Geändert-> 20090714, Größe -> 363584 Bytes
    257. C:\Windows\System32\Drivers\volsnap.sys: Geändert-> 20090714, Größe -> 294992 Bytes
    258. C:\Windows\System32\Drivers\vsmraid.sys: Geändert-> 20090714, Größe -> 161872 Bytes
    259. C:\Windows\System32\Drivers\VSTAZL6.SYS: Geändert-> 20090610, Größe -> 292864 Bytes
    260. C:\Windows\System32\Drivers\VSTCNXT6.SYS: Geändert-> 20090610, Größe -> 740864 Bytes
    261. C:\Windows\System32\Drivers\VSTDPV6.SYS: Geändert-> 20090610, Größe -> 1485312 Bytes
    262. C:\Windows\System32\Drivers\VSTProf.cty: Geändert-> 20090610, Größe -> 146036 Bytes
    263. C:\Windows\System32\Drivers\vwifibus.sys: Geändert-> 20090714, Größe -> 24576 Bytes
    264. C:\Windows\System32\Drivers\vwififlt.sys: Geändert-> 20090714, Größe -> 59904 Bytes
    265. C:\Windows\System32\Drivers\vwifimp.sys: Geändert-> 20090714, Größe -> 17920 Bytes
    266. C:\Windows\System32\Drivers\wacompen.sys: Geändert-> 20090714, Größe -> 27776 Bytes
    267. C:\Windows\System32\Drivers\wanarp.sys: Geändert-> 20090714, Größe -> 88576 Bytes
    268. C:\Windows\System32\Drivers\watchdog.sys: Geändert-> 20090714, Größe -> 42496 Bytes
    269. C:\Windows\System32\Drivers\wd.sys: Geändert-> 20090714, Größe -> 21056 Bytes
    270. C:\Windows\System32\Drivers\Wdf01000.sys: Geändert-> 20090714, Größe -> 654928 Bytes
    271. C:\Windows\System32\Drivers\WdfLdr.sys: Geändert-> 20090714, Größe -> 42064 Bytes
    272. C:\Windows\System32\Drivers\wfplwf.sys: Geändert-> 20090714, Größe -> 12800 Bytes
    273. C:\Windows\System32\Drivers\wimmount.sys: Geändert-> 20090714, Größe -> 22096 Bytes
    274. C:\Windows\System32\Drivers\wmiacpi.sys: Geändert-> 20090714, Größe -> 14336 Bytes
    275. C:\Windows\System32\Drivers\wmilib.sys: Geändert-> 20090714, Größe -> 16464 Bytes
    276. C:\Windows\System32\Drivers\ws2ifsl.sys: Geändert-> 20090714, Größe -> 21504 Bytes
    277. C:\Windows\System32\Drivers\WUDFPf.sys: Geändert-> 20090714, Größe -> 112128 Bytes
    278. 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!
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von AHT ()

  • Welche APIs sind von der Umleitung des Dateisystems betroffen?

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL]http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. Def GetFileVersionInfoSize(2) !"VERSION", "GetFileVersionInfoSizeA"
    6. DEf VerQueryValue(4) !"VERSION", "VerQueryValueA"
    7. Def GetFileVersionInfo(4) !"VERSION", "GetFileVersionInfoA"
    8. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    9. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    10. Declare FEHLER&, FILE$, Zero&, Info_Size&, FileInfoSize&, MODULEINFO#, FILE_VER_INFO&, FILE_VER_INFO#
    11. Declare VERSION$, Ver_Value$
    12. Declare Edit&, Button&, Checkbox&, Wow64DisableWow64FsRedirection&, OldValue&
    13. Declare Wow64EnableWow64FsRedirection&, version&
    14. Declare Module$, MHANDLE&, Funktion$
    15. Declare 64Bit&, GetFileVersionInfoSizeA&
    16. Declare GetFileVersionInfoA&, FILE_FEHLER&
    17. version&=UseDLL("version.dll")
    18. Funktion$ = "GetFileVersionInfoSizeA"
    19. GetFileVersionInfoSizeA& = GetProcAddress(version&, ADDR(FUNKTION$))
    20. Funktion$ = "GetFileVersionInfoA"
    21. GetFileVersionInfoA& = GetProcAddress(version&, ADDR(FUNKTION$))
    22. Module$ = "Kernel32.DLL"
    23. MHANDLE& = GetModuleHandle(ADDR(Module$))
    24. Funktion$ = "Wow64DisableWow64FsRedirection"
    25. Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    26. Funktion$ = "Wow64EnableWow64FsRedirection"
    27. Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    28. Funktion$ = "IsWow64Process"
    29. MHANDLE& = GetModuleHandle(ADDR(Module$))
    30. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    31. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    32. endif
    33. Windowstyle 31 + 512
    34. WindowTitle "Resourcen Test"
    35. Window 0, 0 - 640, 440
    36. Usermessages $10
    37. Edit& = Create("Edit", %HWND, "C:\Windows\System32\Drivers\ACPI.SYS", 20, 20, 500, 30)
    38. Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
    39. Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
    40. While %Umessage <> $10
    41. Waitinput
    42. IF Clicked(Button&)
    43. EnableWindow Checkbox&, 0
    44. EnableWindow Button&, 0
    45. CLS
    46. Locate 12, 0
    47. File$ = Gettext$(Edit&)
    48. IF File$ <> ""
    49. CLS
    50. Locate 12, 0
    51. Print "Versionsnummer der Datei: "
    52. Print GetFileVersion(File$)
    53. endif
    54. EnableWindow Checkbox&, 1
    55. EnableWindow Button&, 1
    56. endif
    57. EndWhile
    58. Freedll version&
    59. End
    60. Proc GetFileVersion
    61. Parameters File2$
    62. Clear Version$
    63. 'Umleitung deaktivieren
    64. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    65. FileInfoSize& = Call(GetFileVersionInfoSizeA&, ADDR(File2$), ADDR(Zero&))
    66. IF FileInfoSize& > 0
    67. DIM MODULEINFO#, FileInfoSize&
    68. FILE_FEHLER& = Call(GetFileVersionInfoA&, ADDR(File2$), 0, FileInfoSize&, MODULEINFO#)
    69. 'Umleitung aktivieren
    70. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
    71. Ver_Value$ = "\\"
    72. FEHLER& = VerQueryValue(MODULEINFO#, ADDR(Ver_Value$), ADDR(FILE_VER_INFO&), ADDR(Zero&))
    73. If FEHLER& = 1
    74. If Zero& = 0
    75. Zero& = 4
    76. endif
    77. DIM FILE_VER_INFO#, Zero&
    78. Clear FILE_VER_INFO#
    79. FILE_VER_INFO# = FILE_VER_INFO&
    80. VERSION$ = STR$(Word(FILE_VER_INFO#, 10)) + ", "
    81. VERSION$ = Version$ + STR$(Word(FILE_VER_INFO#, 8)) + ", "
    82. VERSION$ = Version$ + STR$(Word(FILE_VER_INFO#, 14)) + ", "
    83. VERSION$ = Version$ + STR$(Word(FILE_VER_INFO#, 12))
    84. Dispose FILE_VER_INFO#
    85. endif
    86. Dispose MODULEINFO#
    87. endif
    88. 'Umleitung aktivieren
    89. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
    90. Return Version$
    91. 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.
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • 64Bit Betriebsysteme und das Umbiegen von Umgebungsvariablen für 32Bit Programme

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


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

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL]http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. Clearlist
    6. Addstring GetEnv$("ProgramFiles")
    7. Addstring GetEnv$("CommonProgramFiles")
    8. 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.
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Automatische Umleitung von Registryzugriffen für 32Bit Programme unter 64Bit

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


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

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare Module$, MHANDLE&, Funktion$, Valuename$
    8. Declare 64Bit&, Edit&, Button&, HKEY$, Key$
    9. Module$="Kernel32.DLL"
    10. Funktion$="IsWow64Process"
    11. MHANDLE&=GetModuleHandle(ADDR(Module$))
    12. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    13. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    14. endif
    15. Windowstyle 31
    16. WindowTitle "Readini$ Test"
    17. Window 0, 0 - 640, 440
    18. Edit& = Create("Edit", %HWND, "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools:SharedFilesDir", 20, 20, 500, 30)
    19. Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
    20. While 1
    21. Waitinput
    22. IF Clicked(Button&)
    23. EnableWindow Button&, 0
    24. EnableWindow Edit&, 0
    25. Key$ = Substr$(Gettext$(Edit&), 1, ":")
    26. Valuename$ = Substr$(Gettext$(Edit&), 2, ":")
    27. HKEY$ = Substr$(Key$, 1, "\")
    28. Key$ = Right$(Key$, int(Len(Key$) - (Len(HKEY$) + 1)))
    29. IF HKEY$ = "HKEY_CLASSES_ROOT"
    30. HKEY$ = "HKEY_0"
    31. elseif HKEY$ = "HKEY_CURRENT_USER"
    32. HKEY$ = "HKEY_1"
    33. elseif HKEY$ = "HKEY_LOCAL_MACHINE"
    34. HKEY$ = "HKEY_2"
    35. elseif HKEY$ = "HKEY_USERS"
    36. HKEY$ = "HKEY_3"
    37. elseif HKEY$ = "HKEY_PERFORMANCE_DATA"
    38. HKEY$ = "HKEY_4"
    39. elseif HKEY$ = "HKEY_CURRENT_CONFIG"
    40. HKEY$ = "HKEY_5"
    41. elseif HKEY$ = "HKEY_DYN_DATA"
    42. HKEY$ = "HKEY_6"
    43. endif
    44. CLS
    45. Locate 12, 0
    46. Print Readini$(HKEY$,Key$, Valuename$)
    47. EnableWindow Button&, 1
    48. EnableWindow Edit&, 1
    49. endif
    50. Endwhile
    51. 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!
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Mit Profan 32Bit Programmen die 64Bit Registry auslesen

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL]http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Def RegOpenKeyEx(5) !"ADVAPI32","RegOpenKeyExA"
    8. Def RegCloseKey(1) !"ADVAPI32","RegCloseKey"
    9. Def RegQueryValueEx(6) !"ADVAPI32","RegQueryValueExA"
    10. Declare Module$, MHANDLE&, Funktion$, Valuename$
    11. Declare Edit&, Checkbox&, Button&, HKEY&, Key$, HKEY$
    12. Declare Wert3#
    13. Declare 64Bit&, KEY_WOW64_64KEY&
    14. Module$="Kernel32.DLL"
    15. Funktion$="IsWow64Process"
    16. MHANDLE&=GetModuleHandle(ADDR(Module$))
    17. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    18. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    19. endif
    20. Windowstyle 31
    21. WindowTitle "Readini$ Test"
    22. Window 0, 0 - 640, 440
    23. Edit& = Create("Edit", %HWND, "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools:SharedFilesDir", 20, 20, 500, 30)
    24. Button& = Create("Button", %HWND, "Testen", 20, 60, 500, 30)
    25. Checkbox& = Create("CheckBox", %HWND, "Registryumleitung deaktivieren", 20, 100, 500, 30)
    26. While 1
    27. Waitinput
    28. IF Clicked(Button&)
    29. EnableWindow Button&, 0
    30. EnableWindow Edit&, 0
    31. EnableWindow Checkbox&, 0
    32. IF (GetCheck(Checkbox&)) and (64Bit&=1)
    33. KEY_WOW64_64KEY& = $100 'Registryumleitung deaktivieren
    34. else
    35. KEY_WOW64_64KEY& = $0 'Registryumleitung aktivieren
    36. endif
    37. Key$ = Substr$(Gettext$(Edit&), 1, ":")
    38. Valuename$ = Substr$(Gettext$(Edit&), 2, ":")
    39. HKEY$ = Substr$(Key$, 1, "\")
    40. Key$ = Right$(Key$, int(Len(Key$) - (Len(HKEY$) + 1)))
    41. IF HKEY$ = "HKEY_CLASSES_ROOT"
    42. HKEY& = $80000000
    43. elseif HKEY$ = "HKEY_CURRENT_USER"
    44. HKEY& = $80000001
    45. elseif HKEY$ = "HKEY_LOCAL_MACHINE"
    46. HKEY& = $80000002
    47. elseif HKEY$ = "HKEY_USERS"
    48. HKEY& = $80000003
    49. elseif HKEY$ = "HKEY_PERFORMANCE_DATA"
    50. HKEY& = $80000004
    51. elseif HKEY$ = "HKEY_CURRENT_CONFIG"
    52. HKEY& = $80000005
    53. elseif HKEY$ = "HKEY_DYN_DATA"
    54. HKEY& = $80000006
    55. endif
    56. CLS
    57. Locate 12, 0
    58. Print ReadKey(HKEY&,Key$, Valuename$)
    59. EnableWindow Button&, 1
    60. EnableWindow Edit&, 1
    61. EnableWindow Checkbox&, 1
    62. endif
    63. Endwhile
    64. end
    65. 'Registrywert auslesen
    66. Proc ReadKey
    67. Parameters O_Key&, R_KEY$, R_WERT$
    68. Declare Wert3$, RegHandle3&, RegError6&, RegSize3&
    69. Declare RegError7&, RegSize4&, Type3&
    70. Clear Wert3$, RegError7&
    71. RegError6& = Regopenkeyex(O_Key&, addr(R_KEY$), 0, $1 | KEY_WOW64_64KEY&, addr(RegHandle3&))
    72. IF RegError6& = 0
    73. DIM Wert3#, 1
    74. RegSize3& = 1
    75. RegError7& = Regqueryvalueex(RegHandle3&, addr(R_WERT$), 0, addr(Type3&), Wert3#, addr(RegSize3&)) 'Hier erhalte ich einen Wert!!!
    76. Dispose Wert3#
    77. DIM Wert3#, RegSize3&+1
    78. RegSize4& = RegSize3&
    79. RegError7& = Regqueryvalueex(RegHandle3&, addr(R_WERT$), 0, addr(Type3&), Wert3#, addr(RegSize4&)) 'Hier erhalte ich einen Wert!!!
    80. Wert3$ = String$(Wert3#, 0)
    81. Dispose Wert3#
    82. Regclosekey(RegHandle3&)
    83. endif
    84. Return Wert3$
    85. 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!
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Besonderheiten beim Listen von Registryinhalten unter HKEY_LOCAL_MACHINE unter 64Bit

    Besonderheiten beim Listen von Registryinhalten unter HKEY_LOCAL_MACHINE unter 64Bit


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

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Mit 32Bit Programmen unter 64Bit Module (DLLs) listen

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL]http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. Def GetModuleFileNameEx(4) !"Psapi", "GetModuleFileNameExA"
    6. Def CreateToolhelp32Snapshot(2) !"Kernel32", "CreateToolhelp32Snapshot"
    7. Def Process32First(2) !"Kernel32", "Process32First"
    8. Def Process32Next(2) !"Kernel32", "Process32Next"
    9. Def CloseHandle(1) !"Kernel32", "CloseHandle"
    10. Def GetCurrentProcessID(0) !"Kernel32", "GetCurrentProcessId"
    11. Def OpenProcess(3) !"Kernel32", "OpenProcess"
    12. DEF LookupPrivilegeValue(3) !"advapi32","LookupPrivilegeValueA"
    13. DEF AdjustTokenPrivileges(6) !"advapi32","AdjustTokenPrivileges"
    14. DEF OpenProcessToken(3) !"advapi32","OpenProcessToken"
    15. DEF GetCurrentProcess(0) !"KERNEL32","GetCurrentProcess"
    16. DEF CopyMemory(3) !"kernel32","RtlMoveMemory"
    17. DEF GetModuleHandle(1) !"KERNEL32","GetModuleHandleA"
    18. DEF GetProcAddress(2) !"KERNEL32","GetProcAddress"
    19. Def QueryFullProcessImageName(4) !"Kernel32", "QueryFullProcessImageNameA"
    20. DEF CheckTokenMembership(3) !"advapi32","CheckTokenMembership"
    21. Def Module32First(2) !"Kernel32", "Module32First"
    22. Def Module32Next(2) !"Kernel32", "Module32Next"
    23. Declare Listbox&, Button&, Wintrust_DLL&
    24. Declare Entry#, err&, handle&, PID$, ProcessName$, PHandle&, Filename#
    25. Declare TOKEN_PRIVILEGES#, LUID#, Fehler&, 64Bit&, MODULE$, Funktion$
    26. Declare MHANDLE&, Size&, Member&, SID#, 64Bit$, 64Bit_test&, Old_LB_String$
    27. Declare New_LB_String$, PR_ID&, DLL_LADEN_mit_Pfad&, DLL_LADEN_ohne_Pfad&
    28. Struct PROCESSENTRY32 = dwSize&, \
    29. cntUsage&, \
    30. th32ProcessID&, \
    31. th32DefaultHeapID&, \
    32. th32ModuleID&, \
    33. Threads&, \
    34. th32ParentProcessID&, \
    35. pcPriClassBase&, \
    36. dwFlags&, \
    37. szExeFile$(260)
    38. Struct MODULEENTRY32 = dwsize&, th32ModuleID&,th32ProcessID&, GlblcntUsage&,ProccntUsage&, modBaseAddr&, modBaseSize&, hModule&, szModule$(255), szExePath$(260)
    39. Clear 64Bit&
    40. MODULE$ = "Kernel32.DLL"
    41. Funktion$ = "IsWow64Process"
    42. MHANDLE& = GetModuleHandle(ADDR(Module$))
    43. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$)) <> 0
    44. External("Kernel32.dll", "IsWow64Process", GetCurrentProcess(), Addr(64Bit&))
    45. endif
    46. WindowStyle 31+512
    47. WindowTitle "64Bit Test Module listen"
    48. Window 0,0-%MAXX-20,440
    49. UserMessages $10
    50. DLL_LADEN_ohne_Pfad& = Create("Button", %HWND, "Wintrust.DLL ohne Pfad laden", 20, 20, 220, 30)
    51. DLL_LADEN_mit_Pfad& = Create("Button", %HWND, "Wintrust.DLL mit Pfad laden", 250, 20, 200, 30)
    52. Button& = Create("Button", %HWND, "Prozesse listen", 460, 20, %MAXX-(70+460), 30)
    53. ListBox& = Create("Listbox", %HWND, "", 20, 60, %MAXX-80, 300)
    54. Set_Privilege_Status("SeDebugPrivilege",$2)
    55. FillProcessList
    56. While %Umessage<>$10
    57. WaitInput
    58. If Clicked(Button&)
    59. Beep
    60. FillProcessList
    61. endif
    62. If Clicked(DLL_LADEN_ohne_Pfad&)
    63. Beep
    64. CASE Wintrust_DLL& <> 0 : FreeDLL Wintrust_DLL&
    65. Wintrust_DLL& = UseDLL("Wintrust.dll")
    66. endif
    67. If Clicked(DLL_LADEN_mit_Pfad&)
    68. Beep
    69. CASE Wintrust_DLL& <> 0 : FreeDLL Wintrust_DLL&
    70. Wintrust_DLL& = UseDLL($SYSPATH + "" + "Wintrust.dll")
    71. endif
    72. If GetCurSel(ListBox&) <> -1
    73. New_LB_String$ = GetString$(ListBox&, GetCurSel(ListBox&))
    74. IF New_LB_String$ <> OLD_LB_String$
    75. OLD_LB_String$ = New_LB_String$
    76. PR_ID& = Val(SubStr$(New_LB_String$, 1, ","))
    77. Liste_DLLS(PR_ID&, New_LB_String$)
    78. endif
    79. endif
    80. EndWhile
    81. CASE Wintrust_DLL& <> 0 : FreeDLL Wintrust_DLL&
    82. end
    83. Proc Set_Privilege_Status
    84. Parameters Privilege_name$, Aktive&
    85. Declare NewState&, AH_Token_Handle&, Fehler&, Privret&
    86. DIM TOKEN_PRIVILEGES#,16
    87. DIM LUID#,8
    88. Clear LUID#
    89. External("advapi32.dll","LookupPrivilegeValueA",0,ADDR(Privilege_name$),LUID#)
    90. CLEAR AH_Token_Handle&
    91. LET FEHLER&=External("advapi32.dll","OpenProcessToken",External("KERNEL32.dll","GetCurrentProcess"),$20,ADDR(AH_Token_Handle&))
    92. LONG TOKEN_PRIVILEGES#,0=1
    93. NewState&=TOKEN_PRIVILEGES#
    94. External("KERNEL32.dll","RtlMoveMemory",NewState&+4,LUID#,8)
    95. LET NewState&=Aktive&
    96. Clear Aktive&
    97. IF NewState& | $2 = NewState&
    98. LET Aktive&=AKTIVE& | $2
    99. Endif
    100. IF NewState& | $80000000 = NewState&
    101. LET Aktive&= AKTIVE& | $80000000
    102. Endif
    103. LONG TOKEN_PRIVILEGES#,12=Aktive&
    104. Privret&=External("advapi32.dll","AdjustTokenPrivileges",AH_Token_Handle&,0,TOKEN_PRIVILEGES#,0,0,0)
    105. If AH_TOKEN_Handle&<>0
    106. External("KERNEL32.dll","CloseHandle",AH_Token_Handle&)
    107. endif
    108. Dispose TOKEN_PRIVILEGES#
    109. Dispose LUID#
    110. Return Privret&
    111. endproc
    112. Proc FillProcessList
    113. SendMessage(Listbox&,$184,0,0)
    114. Dim Entry#,PROCESSENTRY32
    115. Clear Entry#
    116. Entry#.dwSize& = SizeOf(Entry#)
    117. DIM Filename#, 514
    118. handle& = CreateToolhelp32Snapshot(2, 0)
    119. If handle&
    120. err& = Process32First(handle&, Entry#)
    121. If err&
    122. PID$ = Str$(Entry#.th32ProcessID&)
    123. ProcessName$ = Entry#.szExeFile$
    124. Clear Filename#, PHandle&
    125. IF Val($WINVER) < 6.0
    126. PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
    127. else
    128. PHandle& = OpenProcess($1000, 0, Entry#.th32ProcessID&)
    129. endif
    130. IF PHandle& > 0
    131. IF Val($WINVER) < 6.0
    132. GetModuleFilenameEx(PHandle&, 0, Filename#, 513)
    133. If 64Bit& = 1
    134. External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
    135. IF 64Bit_Test& = 1
    136. 64Bit$ = "32Bit Prozess"
    137. else
    138. 64Bit$ = "64Bit Prozess"
    139. endif
    140. else
    141. 64Bit$ = "32Bit Prozess"
    142. endif
    143. else
    144. Size& = 580
    145. QueryFullProcessImageName(PHandle&, 0, Filename#, addr(Size&))
    146. If 64Bit& = 1
    147. External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
    148. IF 64Bit_Test&=1
    149. 64Bit$ = "32Bit Prozess"
    150. else
    151. 64Bit$ = "64Bit Prozess"
    152. endif
    153. else
    154. 64Bit$ = "32Bit Prozess"
    155. endif
    156. endif
    157. Closehandle(PHandle&)
    158. else
    159. clear 64Bit$
    160. endif
    161. ADDSTRING(ListBox&,PID$ + ", " + ProcessName$ + ", " + String$(Filename#, 0) + ", " + 64Bit$)
    162. Repeat
    163. err& = Process32Next(handle&, Entry#)
    164. If err&
    165. PID$ = Str$(Entry#.th32ProcessID&)
    166. ProcessName$ = Entry#.szExeFile$
    167. Clear Filename#, PHandle&
    168. IF Val($WINVER) < 6.0
    169. PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
    170. else
    171. PHandle& = OpenProcess($1000, 0, Entry#.th32ProcessID&)
    172. endif
    173. IF PHandle& > 0
    174. IF Val($WINVER) < 6.0
    175. GetModuleFilenameEx(PHandle&, 0, Filename#, 513)
    176. If 64Bit& = 1
    177. External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
    178. IF 64Bit_Test& = 1
    179. 64Bit$ = "32Bit Prozess"
    180. else
    181. 64Bit$ = "64Bit Prozess"
    182. endif
    183. else
    184. 64Bit$ = "32Bit Prozess"
    185. endif
    186. else
    187. Size&=580
    188. QueryFullProcessImageName(PHandle&, 0, Filename#, addr(Size&))
    189. If 64Bit& = 1
    190. External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
    191. IF 64Bit_Test& = 1
    192. 64Bit$ = "32Bit Prozess"
    193. else
    194. 64Bit$ = "64Bit Prozess"
    195. endif
    196. else
    197. 64Bit$ = "32Bit Prozess"
    198. endif
    199. endif
    200. Closehandle(PHandle&)
    201. endif
    202. ADDSTRING(ListBox&,PID$ + ", " + ProcessName$ + ", " + String$(Filename#, 0) + ", " + 64Bit$)
    203. EndIf
    204. Until err& = 0
    205. CloseHandle(handle&)
    206. else
    207. clear 64Bit$
    208. EndIf
    209. EndIf
    210. Dispose Filename#
    211. Dispose Entry#
    212. return
    213. EndProc
    214. Proc Liste_DLLS
    215. Parameters ProcessID&, ProcessData$
    216. ClearList
    217. Addstring "Module von " + ProcessData$
    218. Addstring "_____________________________________________________________________"
    219. IF ProcessID& <> 0
    220. Dim Entry#, MODULEENTRY32
    221. Clear Entry#
    222. Entry#.dwSize& = SizeOf(Entry#)
    223. handle& = CreateToolhelp32Snapshot($8, ProcessID&)
    224. If handle&
    225. Entry#.th32ProcessID& = ProcessID&
    226. err& = Module32First(handle&, Entry#)
    227. If err&
    228. AddString Str$(Entry#.hModule&) + " " + Entry#.szExePath$
    229. Repeat
    230. err& = Module32Next(handle&, Entry#)
    231. If err&
    232. AddString Str$(Entry#.hModule&) + " " + Entry#.szExePath$
    233. EndIf
    234. Until err& = 0
    235. CloseHandle(handle&)
    236. EndIf
    237. EndIf
    238. Dispose Entry#
    239. endif
    240. EditBox("Module: ", 1)
    241. SendMessage(ListBox&,$186,-1,0)
    242. Clear OLD_LB_String$
    243. return
    244. 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.

    Quellcode

    1. 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.

    Quellcode

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

    Quellcode

    1. Module von 928, Profan.exe, C:\Program Files (x86)\XProfan9\Profan.exe, 32Bit Prozess
    2. _____________________________________________________________________
    3. 4194304 C:\Program Files (x86)\XProfan9\PROFAN.EXE
    4. 1996423168 C:\Windows\SysWOW64\ntdll.dll
    5. 1973551104 C:\Windows\syswow64\kernel32.dll
    6. 1965948928 C:\Windows\syswow64\KERNELBASE.dll
    7. 1962606592 C:\Windows\syswow64\user32.dll
    8. 1960247296 C:\Windows\syswow64\GDI32.dll
    9. 1989738496 C:\Windows\syswow64\LPK.dll
    10. 1987510272 C:\Windows\syswow64\USP10.dll
    11. 1967783936 C:\Windows\syswow64\msvcrt.dll
    12. 1959460864 C:\Windows\syswow64\ADVAPI32.dll
    13. 1960116224 C:\Windows\SysWOW64\sechost.dll
    14. 1970470912 C:\Windows\syswow64\RPCRT4.dll
    15. 1958084608 C:\Windows\syswow64\SspiCli.dll
    16. 1958019072 C:\Windows\syswow64\CRYPTBASE.dll
    17. 1969881088 C:\Windows\syswow64\oleaut32.dll
    18. 1961164800 C:\Windows\syswow64\ole32.dll
    19. 1956184064 C:\Windows\WinSxS\x86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7600.16385_none_421189da2b7fabfc\comctl32.dll
    20. 1959067648 C:\Windows\syswow64\SHLWAPI.dll
    21. 1974599680 C:\Windows\syswow64\shell32.dll
    22. 1969356800 C:\Windows\syswow64\comdlg32.dll
    23. 1837432832 C:\Windows\system32\winmm.dll
    24. 1963655168 C:\Windows\system32\IMM32.DLL
    25. 1968504832 C:\Windows\syswow64\MSCTF.dll
    26. 1911881728 C:\Windows\system32\uxtheme.dll
    27. 1991966720 C:\Windows\syswow64\ws2_32.dll
    28. 1996226560 C:\Windows\syswow64\NSI.dll
    29. 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:

    Quellcode

    1. Module von 1748, Profan.exe, C:\Program Files (x86)\XProfan9\Profan.exe, 32Bit Prozess
    2. _____________________________________________________________________
    3. 4194304 C:\Program Files (x86)\XProfan9\PROFAN.EXE
    4. 1996423168 C:\Windows\SysWOW64\ntdll.dll
    5. 1973551104 C:\Windows\syswow64\kernel32.dll
    6. 1965948928 C:\Windows\syswow64\KERNELBASE.dll
    7. 1962606592 C:\Windows\syswow64\user32.dll
    8. 1960247296 C:\Windows\syswow64\GDI32.dll
    9. 1989738496 C:\Windows\syswow64\LPK.dll
    10. 1987510272 C:\Windows\syswow64\USP10.dll
    11. 1967783936 C:\Windows\syswow64\msvcrt.dll
    12. 1959460864 C:\Windows\syswow64\ADVAPI32.dll
    13. 1960116224 C:\Windows\SysWOW64\sechost.dll
    14. 1970470912 C:\Windows\syswow64\RPCRT4.dll
    15. 1958084608 C:\Windows\syswow64\SspiCli.dll
    16. 1958019072 C:\Windows\syswow64\CRYPTBASE.dll
    17. 1969881088 C:\Windows\syswow64\oleaut32.dll
    18. 1961164800 C:\Windows\syswow64\ole32.dll
    19. 1956184064 C:\Windows\WinSxS\x86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7600.16385_none_421189da2b7fabfc\comctl32.dll
    20. 1959067648 C:\Windows\syswow64\SHLWAPI.dll
    21. 1974599680 C:\Windows\syswow64\shell32.dll
    22. 1969356800 C:\Windows\syswow64\comdlg32.dll
    23. 1837432832 C:\Windows\system32\winmm.dll
    24. 1963655168 C:\Windows\system32\IMM32.DLL
    25. 1968504832 C:\Windows\syswow64\MSCTF.dll
    26. 1911881728 C:\Windows\system32\uxtheme.dll
    27. 1991966720 C:\Windows\syswow64\ws2_32.dll
    28. 1996226560 C:\Windows\syswow64\NSI.dll
    29. 1955987456 C:\Windows\system32\dwmapi.dll
    30. [B]1967587328 C:\Windows\syswow64\Wintrust.dll[/B]
    31. 1964048384 C:\Windows\syswow64\CRYPT32.dll
    32. 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:

    Quellcode

    1. Module von 1748, Profan.exe, C:\Program Files (x86)\XProfan9\Profan.exe, 32Bit Prozess
    2. _____________________________________________________________________
    3. 4194304 C:\Program Files (x86)\XProfan9\PROFAN.EXE
    4. 1996423168 C:\Windows\SysWOW64\ntdll.dll
    5. 1973551104 C:\Windows\syswow64\kernel32.dll
    6. 1965948928 C:\Windows\syswow64\KERNELBASE.dll
    7. 1962606592 C:\Windows\syswow64\user32.dll
    8. 1960247296 C:\Windows\syswow64\GDI32.dll
    9. 1989738496 C:\Windows\syswow64\LPK.dll
    10. 1987510272 C:\Windows\syswow64\USP10.dll
    11. 1967783936 C:\Windows\syswow64\msvcrt.dll
    12. 1959460864 C:\Windows\syswow64\ADVAPI32.dll
    13. 1960116224 C:\Windows\SysWOW64\sechost.dll
    14. 1970470912 C:\Windows\syswow64\RPCRT4.dll
    15. 1958084608 C:\Windows\syswow64\SspiCli.dll
    16. 1958019072 C:\Windows\syswow64\CRYPTBASE.dll
    17. 1969881088 C:\Windows\syswow64\oleaut32.dll
    18. 1961164800 C:\Windows\syswow64\ole32.dll
    19. 1956184064 C:\Windows\WinSxS\x86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7600.16385_none_421189da2b7fabfc\comctl32.dll
    20. 1959067648 C:\Windows\syswow64\SHLWAPI.dll
    21. 1974599680 C:\Windows\syswow64\shell32.dll
    22. 1969356800 C:\Windows\syswow64\comdlg32.dll
    23. 1837432832 C:\Windows\system32\winmm.dll
    24. 1963655168 C:\Windows\system32\IMM32.DLL
    25. 1968504832 C:\Windows\syswow64\MSCTF.dll
    26. 1911881728 C:\Windows\system32\uxtheme.dll
    27. 1991966720 C:\Windows\syswow64\ws2_32.dll
    28. 1996226560 C:\Windows\syswow64\NSI.dll
    29. 1955987456 C:\Windows\system32\dwmapi.dll
    30. 1967587328 C:\Windows\system32\Wintrust.dll
    31. 1964048384 C:\Windows\syswow64\CRYPT32.dll
    32. 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.
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von AHT ()

  • GetModuleFileNameEx unter 64Bit mit 32Bit Programmen

    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.
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Warum können 32Bit Programme keine 64Bit Moduldaten auslesen?

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL]http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. Def GetModuleFileNameEx(4) !"Psapi", "GetModuleFileNameExA"
    6. Def CreateToolhelp32Snapshot(2) !"Kernel32", "CreateToolhelp32Snapshot"
    7. Def Process32First(2) !"Kernel32", "Process32First"
    8. Def Process32Next(2) !"Kernel32", "Process32Next"
    9. Def CloseHandle(1) !"Kernel32", "CloseHandle"
    10. Def GetCurrentProcessID(0) !"Kernel32", "GetCurrentProcessId"
    11. Def OpenProcess(3) !"Kernel32", "OpenProcess"
    12. DEF LookupPrivilegeValue(3) !"advapi32","LookupPrivilegeValueA"
    13. DEF AdjustTokenPrivileges(6) !"advapi32","AdjustTokenPrivileges"
    14. DEF OpenProcessToken(3) !"advapi32","OpenProcessToken"
    15. DEF GetCurrentProcess(0) !"KERNEL32","GetCurrentProcess"
    16. DEF CopyMemory(3) !"kernel32","RtlMoveMemory"
    17. DEF GetModuleHandle(1) !"KERNEL32","GetModuleHandleA"
    18. DEF GetProcAddress(2) !"KERNEL32","GetProcAddress"
    19. Def QueryFullProcessImageName(4) !"Kernel32", "QueryFullProcessImageNameA"
    20. DEF CheckTokenMembership(3) !"advapi32","CheckTokenMembership"
    21. Def Module32First(2) !"Kernel32", "Module32First"
    22. Def Module32Next(2) !"Kernel32", "Module32Next"
    23. Def NtQueryInformationProcess(5) !"NTDLL","NtQueryInformationProcess"
    24. Declare Listbox&, Button&, Wintrust_DLL&
    25. Declare Entry#, err&, handle&, PID$, ProcessName$, PHandle&, Filename#
    26. Declare TOKEN_PRIVILEGES#, LUID#, Fehler&, 64Bit&, MODULE$, Funktion$
    27. Declare MHANDLE&, Size&, 64Bit$, 64Bit_test&
    28. Declare NtFehler&, P_Info#, Read&, PEB&
    29. Struct PROCESSENTRY32=dwSize&, \
    30. cntUsage&, \
    31. th32ProcessID&, \
    32. th32DefaultHeapID&, \
    33. th32ModuleID&, \
    34. Threads&, \
    35. th32ParentProcessID&, \
    36. pcPriClassBase&, \
    37. dwFlags&, \
    38. szExeFile$(260)
    39. Struct MODULEENTRY32=dwsize&,th32ModuleID&,th32ProcessID&,GlblcntUsage&,ProccntUsage&,modBaseAddr&,modBaseSize&,hModule&,szModule$(255),szExePath$(260)
    40. Clear 64Bit&
    41. MODULE$ = "Kernel32.DLL"
    42. Funktion$ = "IsWow64Process"
    43. MHANDLE& = GetModuleHandle(ADDR(Module$))
    44. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$)) <> 0
    45. External("Kernel32.dll", "IsWow64Process", GetCurrentProcess(), Addr(64Bit&))
    46. endif
    47. Set_Privilege_Status("SeDebugPrivilege",$2)
    48. ClearList
    49. FillProcessList
    50. EditBox("Prozesse",1)
    51. Proc Set_Privilege_Status
    52. Parameters Privilege_name$, Aktive&
    53. Declare NewState&, AH_Token_Handle&, Fehler&, Privret&
    54. DIM TOKEN_PRIVILEGES#,16
    55. DIM LUID#,8
    56. Clear LUID#
    57. External("advapi32.dll","LookupPrivilegeValueA",0,ADDR(Privilege_name$),LUID#)
    58. CLEAR AH_Token_Handle&
    59. LET FEHLER&=External("advapi32.dll","OpenProcessToken",External("KERNEL32.dll","GetCurrentProcess"),$20,ADDR(AH_Token_Handle&))
    60. LONG TOKEN_PRIVILEGES#,0=1
    61. NewState&=TOKEN_PRIVILEGES#
    62. External("KERNEL32.dll","RtlMoveMemory",NewState&+4,LUID#,8)
    63. LET NewState&=Aktive&
    64. Clear Aktive&
    65. IF NewState& | $2 = NewState&
    66. LET Aktive&=AKTIVE& | $2
    67. Endif
    68. IF NewState& | $80000000 = NewState&
    69. LET Aktive&= AKTIVE& | $80000000
    70. Endif
    71. LONG TOKEN_PRIVILEGES#,12=Aktive&
    72. Privret&=External("advapi32.dll","AdjustTokenPrivileges",AH_Token_Handle&,0,TOKEN_PRIVILEGES#,0,0,0)
    73. If AH_TOKEN_Handle&<>0
    74. External("KERNEL32.dll","CloseHandle",AH_Token_Handle&)
    75. endif
    76. Dispose TOKEN_PRIVILEGES#
    77. Dispose LUID#
    78. Return Privret&
    79. endproc
    80. Proc FillProcessList
    81. SendMessage(Listbox&,$184,0,0)
    82. Dim Entry#,PROCESSENTRY32
    83. Clear Entry#
    84. Entry#.dwSize& = SizeOf(Entry#)
    85. DIM Filename#, 514
    86. handle& = CreateToolhelp32Snapshot(2, 0)
    87. If handle&
    88. err& = Process32First(handle&, Entry#)
    89. If err&
    90. PID$ = Str$(Entry#.th32ProcessID&)
    91. ProcessName$ = Entry#.szExeFile$
    92. Clear Filename#, PHandle&
    93. IF Val($WINVER) < 6.0
    94. PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
    95. else
    96. PHandle& = OpenProcess($1000, 0, Entry#.th32ProcessID&)
    97. endif
    98. IF PHandle& > 0
    99. IF Val($WINVER) < 6.0
    100. GetModuleFilenameEx(PHandle&, 0, Filename#, 513)
    101. If 64Bit&=1
    102. External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
    103. IF 64Bit_Test&=1
    104. 64Bit$="32Bit Prozess"
    105. else
    106. 64Bit$="64Bit Prozess"
    107. endif
    108. else
    109. 64Bit$="32Bit Prozess"
    110. endif
    111. else
    112. Size&=580
    113. QueryFullProcessImageName(PHandle&, 0, Filename#, addr(Size&))
    114. If 64Bit&=1
    115. External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
    116. IF 64Bit_Test&=1
    117. 64Bit$="32Bit Prozess"
    118. else
    119. 64Bit$="64Bit Prozess"
    120. endif
    121. else
    122. 64Bit$="32Bit Prozess"
    123. endif
    124. endif
    125. Closehandle(PHandle&)
    126. else
    127. clear 64Bit$
    128. endif
    129. PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
    130. IF PHandle& > 0
    131. DIM P_Info#,24
    132. NtFehler& = NtQueryInformationProcess(PHandle&, 0, P_Info#, 24, ADDR(Read&))
    133. PEB& = Long(P_Info#, 4)
    134. Dispose P_Info#
    135. CloseHandle(PHandle&)
    136. endif
    137. ADDSTRING PID$ + ", " + ProcessName$ + ", " + String$(Filename#,0)+", "+64Bit$+", "+"PEB="+Str$(PEB&)
    138. Repeat
    139. err& = Process32Next(handle&, Entry#)
    140. If err&
    141. PID$ = Str$(Entry#.th32ProcessID&)
    142. ProcessName$ = Entry#.szExeFile$
    143. Clear Filename#, PHandle&
    144. IF Val($WINVER) < 6.0
    145. PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
    146. else
    147. PHandle& = OpenProcess($1000, 0, Entry#.th32ProcessID&)
    148. endif
    149. IF PHandle& > 0
    150. IF Val($WINVER) < 6.0
    151. GetModuleFilenameEx(PHandle&, 0, Filename#, 513)
    152. If 64Bit&=1
    153. External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
    154. IF 64Bit_Test&=1
    155. 64Bit$="32Bit Prozess"
    156. else
    157. 64Bit$="64Bit Prozess"
    158. endif
    159. else
    160. 64Bit$="32Bit Prozess"
    161. endif
    162. else
    163. Size&=580
    164. QueryFullProcessImageName(PHandle&, 0, Filename#, addr(Size&))
    165. If 64Bit&=1
    166. External("Kernel32.dll", "IsWow64Process", PHandle&, Addr(64Bit_Test&))
    167. IF 64Bit_Test&=1
    168. 64Bit$="32Bit Prozess"
    169. else
    170. 64Bit$="64Bit Prozess"
    171. endif
    172. else
    173. 64Bit$="32Bit Prozess"
    174. endif
    175. endif
    176. Closehandle(PHandle&)
    177. endif
    178. PHandle& = OpenProcess($400 | $10, 0, Entry#.th32ProcessID&)
    179. IF PHandle& > 0
    180. DIM P_Info#,24
    181. NtFehler& = NtQueryInformationProcess(PHandle&, 0, P_Info#, 24, ADDR(Read&))
    182. PEB& = Long(P_Info#, 4)
    183. Dispose P_Info#
    184. CloseHandle(PHandle&)
    185. endif
    186. ADDSTRING PID$ + ", " + ProcessName$ + ", " + String$(Filename#,0)+", "+64Bit$+", "+"PEB="+Str$(PEB&)
    187. EndIf
    188. Until err& = 0
    189. CloseHandle(handle&)
    190. else
    191. clear 64Bit$
    192. EndIf
    193. EndIf
    194. Dispose Filename#
    195. Dispose Entry#
    196. return
    197. EndProc
    Alles anzeigen
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Speicher eines 64Bit Programms mit einem 32Bit Programm scannen

    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.
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • 32Bit Programme und die Dateidialoge auf 64Bit Betriebsystem

    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.

    1. 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.
    2. 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.
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Die Message LB_DIR unter WOW64 versenden

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL='http://www.paules-pc-forum.de/']http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare ListBox&, FileName$, Checkbox&, Button&
    8. Declare Wow64EnableWow64FsRedirection&
    9. Declare Module$, MHANDLE&, Funktion$
    10. Declare 64Bit&
    11. Declare Wow64DisableWow64FsRedirection&, OldValue&
    12. Windowstyle 31 + 512
    13. WindowTitle "LB_DIR Test"
    14. Window 0, 0 - 640, 440
    15. Usermessages $10
    16. Module$ = "Kernel32.DLL"
    17. MHANDLE& = GetModuleHandle(ADDR(Module$))
    18. Funktion$ = "Wow64DisableWow64FsRedirection"
    19. Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    20. Funktion$ = "Wow64EnableWow64FsRedirection"
    21. Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    22. Funktion$ = "IsWow64Process"
    23. MHANDLE& = GetModuleHandle(ADDR(Module$))
    24. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    25. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    26. endif
    27. FileName$ = $SYSPATH+"\"+"Drivers\"+"*.*"
    28. Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 20, 500, 30)
    29. Button& = Create("Button", %HWND, FileName$+" auslesen", 20, 60, 500, 30)
    30. Listbox& = Create("ListBox", %HWND, "", 20, 100, 500, 260)
    31. While %Umessage <> $10
    32. Waitinput
    33. IF Clicked(Button&)
    34. EnableWindow Checkbox&, 0
    35. EnableWindow Button&, 0
    36. SendMessage(Listbox&, $184, 0, 0) 'Listbox löschen
    37. 'Umleitung deaktivieren
    38. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    39. SendMessage(Listbox&, $18D, $20 | $2 | $1 | $10, addr(Filename$)) 'LB_DIR senden
    40. 'Umleitung aktivieren
    41. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, addr(OldValue&)) : Set("FastMode", 0) : endif
    42. EnableWindow Checkbox&, 1
    43. EnableWindow Button&, 1
    44. endif
    45. 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]
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT
  • Profans AddFiles unter 64Bit

    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:

    Quellcode

    1. '#####################################################################################
    2. '######### Code von AHT #########
    3. '######### Gepostet für [URL]http://www.paules-pc-forum.de[/URL] #########
    4. '#####################################################################################
    5. DEF GetProcAddress(2) !"KERNEL32.dll", "GetProcAddress"
    6. DEF GetModuleHandle(1) !"KERNEL32", "GetModuleHandleA"
    7. Declare FileName$, Checkbox&, Button&, Edit&
    8. Declare Wow64EnableWow64FsRedirection&
    9. Declare Module$, MHANDLE&, Funktion$
    10. Declare 64Bit&
    11. Declare Wow64DisableWow64FsRedirection&, OldValue&
    12. Windowstyle 31 + 512
    13. WindowTitle "AddFiles Test"
    14. Window 0, 0 - 640, 440
    15. Usermessages $10
    16. Module$ = "Kernel32.DLL"
    17. MHANDLE& = GetModuleHandle(ADDR(Module$))
    18. Funktion$ = "Wow64DisableWow64FsRedirection"
    19. Wow64DisableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    20. Funktion$ = "Wow64EnableWow64FsRedirection"
    21. Wow64EnableWow64FsRedirection& = GetProcAddress(MHANDLE&, ADDR(FUNKTION$))
    22. Funktion$ = "IsWow64Process"
    23. MHANDLE& = GetModuleHandle(ADDR(Module$))
    24. IF GetProcAddress(MHANDLE&, ADDR(FUNKTION$))<>0
    25. External("Kernel32.dll", "IsWow64Process", External("Kernel32", "GetCurrentProcess"), Addr(64Bit&))
    26. endif
    27. FileName$ = $SYSPATH+"\"+"Drivers\"+"*.sys"
    28. Checkbox& = Create("CheckBox", %HWND, "Umleitung deaktivieren", 20, 100, 500, 30)
    29. Button& = Create("Button", %HWND, "auslesen", 20, 60, 500, 30)
    30. Edit& = Create("Edit", %HWND, FileName$, 20, 20, 500, 30)
    31. While %Umessage <> $10
    32. Waitinput
    33. IF Clicked(Button&)
    34. EnableWindow Checkbox&, 0
    35. EnableWindow Button&, 0
    36. clearlist
    37. 'Umleitung deaktivieren
    38. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Set("FastMode", 1) : Call(Wow64DisableWow64FsRedirection&, addr(OldValue&)) : endif
    39. Addfiles GetText$(Edit&)
    40. 'Umleitung aktivieren
    41. IF (GetCheck(Checkbox&)) and (64Bit& = 1) : Call(Wow64EnableWow64FsRedirection&, 1) : Set("FastMode", 0) : endif
    42. EnableWindow Checkbox&, 1
    43. EnableWindow Button&, 1
    44. EditBox("Dateien",1)
    45. endif
    46. EndWhile
    Alles anzeigen
    ________________________________________________________

    PPFScanner PPFS Android MisterXMail@web.de
    Mfg AHT