Systemaufrufe in Fenster & native API?

StackOverflow https://stackoverflow.com/questions/2489889

Frage

Vor kurzem habe ich mit viel Assemblersprache in * NIX Betriebssysteme sind. Ich frage mich, über die Windows-Domäne.

Aufrufkonvention in Linux: 

mov $SYS_Call_NUM, %eax
mov $param1 , %ebx
mov $param2 , %ecx
int $0x80

Das ist es. Das ist, wie wir einen Systemaufruf in Linux machen sollten.

Referenz aller Systemaufrufe unter Linux:

Im Hinblick auf die $ SYS_Call_NUM & welche Parameter wir diese Referenz verwenden können: http://docs.cs.up.ac.za/programming/asm/derick_tut/syscalls.html

OFFIZIELLE Referenz: http://kernel.org/doc/man-pages /online/dir_section_2.html

Aufrufkonvention in Windows:

???

Referenz aller Systemaufrufe unter Windows:

???

Unofficial: http://www.metasploit.com/users/opcode/syscalls. html , aber wie verwende ich diese bei der Montage, wenn ich die Aufrufkonvention kennen.

OFFIZIELLE: ???

  • Wenn Sie sagen, haben sie es nicht dokumentiert. Dann, wie wird sich eine für Fenster schreiben libc ohne Systemaufrufe zu wissen? Wie ist gonna eine Windows-Assembly-Programmierung zu tun? Zumindest in der Treiberprogrammierung man braucht, um diese zu kennen. nicht wahr?

Nun, was ist mit der so genannten Mutter API up? Ist Native API & System calls for windows beide beziehen sich verschiedene Begriffe auf gleiche Sache? Um im Vergleich zu bestätigen ich diese aus zwei inoffiziellen Quellen

Systemaufrufe: http://www.metasploit.com/users/opcode/syscalls .html

Native API: http://undocumented.ntinternals.net/aindex.html

Meine Beobachtungen:

  1. Alle Systemaufrufe mit Buchstaben Nt beginnen, wo als Native API wird von vielen Funktionen aus, die nicht mit Buchstaben Nt beginnen.
  2. System Call of windows sind Teilmenge von Native API. Systemaufrufe sind nur ein Teil der Native API.

Kann man bestätigen Sie dieses jede mögliche und erklären.

EDIT:

Es gab eine andere Antwort. Es war eine zweite Antwort. Ich mochte es wirklich, aber ich weiß nicht, warum Antworter es gelöscht hat. Ich bitte ihn, seine Antwort auf umbuchen.

War es hilfreich?

Lösung

Wenn Sie tun Assembler-Programmierung unter Windows tun Sie nicht manuell syscalls. Sie verwenden NTDLL und Native API, dass für Sie tun.

The Native API ist einfach ein Wrapper um die Kernel Seite der Dinge. Denn es macht nicht ist eine syscall für die richtige API durchführen.

Sie sollten sich nicht müssen manuell syscall so Ihre gesamte Frage ist überflüssig.

Linux syscall Codes nicht ändern, Windows-do ist, das ist, warum Sie an der Arbeit durch eine zusätzliche Abstraktionsschicht benötigen (aka NTDLL).

EDIT:

Auch wenn Sie auf Baugruppenebene arbeiten, können Sie immer noch vollen Zugriff auf den Win32-API haben, gibt es keinen Grund, mit dem NT-API, um mit zu beginnen! Import, Export, usw. alle gut funktionieren in Assembler-Programme.

EDIT2:

Wenn Sie wirklich manuellen syscalls tun wollen, sind Sie nach Bedarf gehen NTDLL für jede relevante Windows-Version rückgängig zu machen, Versionserkennung hinzufügen (über die PEB) und eine syscall-Suche für jeden Anruf durchführen.

Doch das wäre albern. NTDLL ist es für einen Grund.

Die Menschen haben bereits den Reverse-Engineering Teil getan: siehe https: //j00ru.vexillium .org / syscalls / nt / 64 / für eine Tabelle von System-Call-Nummern für jeden Windows-Kernel. (Beachten Sie, dass die späteren Zeilen ändern sich auch zwischen den Versionen von Windows 10.) Auch dies ist eine schlechte Idee, außerhalb des persönlichen Gebrauch nur für Experimente auf Ihrem eigenen Rechner mehr über asm und / oder Windows-Interna zu lernen. Nicht Inline-Systemaufrufe in den Code, den Sie jemand anderes zu verteilen.

Andere Tipps

Das andere, was Sie brauchen, um über den Windows-syscall Konvention wissen ist, dass, wie ich es die syscall Tabellen verstehen als Teil des Build-Prozesses erzeugt werden. Dies bedeutet, dass sie einfach ändern kann - niemand Spuren sie. Wenn jemand einen neuen an der Spitze der Liste hinzufügt, ist es egal. NTDLL funktioniert immer noch, so alle anderen, die NTDLL nennt noch funktioniert.

Auch die verwendeten Mechanismus syscalls auszuführen (die int oder SYSENTER) ist nicht in Stein gemeißelt und hat in der Vergangenheit verändert, und ich denke, dass die gleiche Version von Windows ist einmal verschiedene DLLs verwendet, die verschiedenen Eingabemechanismen abhängig von der CPU in der Maschine.

Windows-Systemaufrufe werden durch den Aufruf in System-DLLs wie kernel32.dll oder gdi32.dll durchgeführt, die mit gewöhnlichen Subroutinenaufrufe erfolgt. Die Mechanismen zum Einfangen von in die OS privilegierte Schicht ist nicht dokumentiert, aber das ist in Ordnung, weil DLLs wie kernel32.dll dies für Sie tun.

Und durch Systemaufrufe, ich bin auf dokumentierten Windows-API-Einstiegspunkte wie CreateProcess() oder GetWindowText(). Gerätetreiber wird in der Regel eine andere API aus dem Windows DDK verwenden.

Ich war dabei ein Fenster API-Aufruf interessiert bei der Montage ohne Importe (als Bildungsübung), so dass ich die folgende FASM Versammlung schrieb zu tun, was NTDLL! NtCreateFile tut. Es ist eine grobe Demonstration auf meiner 64-Bit-Version von Windows (Win10 1803 Version 10.0.17134) und stürzt nach dem Anruf, aber der Rückgabewert des syscall ist Null, so dass es erfolgreich ist. Alles wird per Windows-x64 eingerichtet Aufrufkonvention, dann das System Rufnummer wird in RAX geladen, und dann ist es die syscall Montageanleitung den Anruf auszuführen. Mein Beispiel erstellt die Datei c:. \ HelloWorldFile_FASM, so hat es ausgeführt werden soll "als Administrator" 

format PE64 GUI 4.0


entry start


section '.text' code readable executable


 start: 
 ;puting the first four parameters into the right registers

                            mov rcx, _Handle
                            mov rdx, [_access_mask]
                            mov r8, objectAttributes
                            mov r9, ioStatusBlock

 ;I think we need 1 stack word of padding:

                            push 0x0DF0AD8B


 ;pushing the other params in reverse order:

                            push [_eaLength]
                            push [_eaBuffer]
                            push [_createOptions]
                            push [_createDisposition]
                            push [_shareAcceses]
                            push [_fileAttributes]
                            push [_pLargeInterger]

 ;adding the shadow space (4x8)

 ;                               push 0x0
 ;                               push 0x0
 ;                               push 0x0
 ;                               push 0x0

 ;pushing the 4 register params into the shadow space for ease of debugging

                            push r9
                            push r8
                            push rdx
                            push rcx

 ;now pushing the return address to the stack:

                            push endOfProgram

                            mov r10, rcx ;copied from ntdll!NtCreateFile, not sure of the reason for this
                            mov eax, 0x55
                            syscall

 endOfProgram:
                            retn




 section '.data' data readable writeable

 ;parameters------------------------------------------------------------------------------------------------

 _Handle                         dq      0x0
 _access_mask                    dq      0x00000000c0100080
 _pObjectAttributes              dq      objectAttributes        ; at 00402058
 _pIoStatusBlock                 dq           ioStatusBlock
 _pLargeInterger                 dq      0x0
 _fileAttributes                 dq      0x0000000000000080
 _shareAcceses                   dq      0x0000000000000002
 _createDisposition              dq      0x0000000000000005
 _createOptions                  dq      0x0000000000000060
 _eaBuffer                       dq      0x0000000000000000       ; "optional" param
 _eaLength                       dq      0x0000000000000000

 ;----------------------------------------------------------------------------------------------------------


                            align   16
 objectAttributes:
 _oalength                       dq      0x30
 _rootDirectory                  dq      0x0
 _objectName                     dq           unicodeString
 _attributes                     dq      0x40
 _pSecurityDescriptor            dq      0x0
 _pSecurityQualityOfService      dq      securityQualityOfService


 unicodeString:
 _unicodeStringLength            dw      0x34
 _unicodeStringMaxumiumLength    dw      0x34, 0x0, 0x0
 _pUnicodeStringBuffer           dq      _unicodeStringBuffer


 _unicodeStringBuffer            du      '\??\c:\HelloWorldFile_FASM'       ; may need to "run as adinistrator" for the file create to work.



 ioStatusBlock:
 _status_pointer                 dq      0x0
 _information                    dq      0x0


 securityQualityOfService:
 _sqlength                       dd      0xC
 _impersonationLevel             dd      0x2
 _contextTrackingMode            db      0x1
 _effectiveOnly                  db      0x1, 0x0, 0x0

Ich habe die Dokumentation für Ntdll! NtCreateFile, und ich den Kernel-Debugger auch zu betrachten verwendet und kopieren viele der params. 

__kernel_entry NTSTATUS NtCreateFile(
  OUT PHANDLE                      FileHandle,
  IN ACCESS_MASK                   DesiredAccess,
  IN POBJECT_ATTRIBUTES            ObjectAttributes,
  OUT PIO_STATUS_BLOCK             IoStatusBlock,
  IN PLARGE_INTEGER AllocationSize OPTIONAL,
  IN ULONG                         FileAttributes,
  IN ULONG                         ShareAccess,
  IN ULONG                         CreateDisposition,
  IN ULONG                         CreateOptions,
  IN PVOID EaBuffer                OPTIONAL,
  IN ULONG                         EaLength
);

OFFIZIELLE Funktionsaufruf unter Windows: http://msdn.microsoft.com /en-us/library/7kcdt6fy.aspx

(hoffen, diese Verbindung überlebt in der Zukunft, wenn es nicht der Fall ist, suchen Sie einfach nach „x64 Software Konventionen“ auf MSDN)

.

Die Funktion Aufrufkonvention unterscheidet sich in Linux & Windows-x86_64. In beiden ABIs werden Parameter vorzugsweise über Register übergeben, aber die verwendeten Register unterscheiden. Mehr auf dem Linux-ABI kann unter http://www.x86-64.org finden /documentation/abi.pdf

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top