Ich versuche, rücksprungorientierte Programmierung (ROP) zu lernen.

Und zwar habe ich ein Programm mit einem Pufferüberlauf auf dem Stack, und ich möchte das Programm dazu bringen, /bin/sh zu öffnen.

Das geht mit dem execve Syscall, wenn ich die richtigen Instruktionen finden kann, um die Funktionsparameter vorzubereiten. Das ist die Signatur von execve:

int execve(const char *pathname, char *const _Nullable argv[], char *const _Nullable envp[]);

Also muss ich die folgenden Register setzen:

• rax = 0x3b (Syscallnummer von execve)
• rdi = "/bin/sh" Pointer
• rsi = NULL
• rdx = NULL

Die folgenden Instruktionen habe ich bereits gefunden:

pop rax ; ret
pop rdi ; ret
pop rsi ; ret
pop rdx ; ret
syscall

Ich kann also die Instruktionen und Registerwerte mit dem Pufferüberlauf auf den Stack schreiben und so meine Register füllen. Das Problem ist aber, dass ich einen "/bin/sh" Pointer in rdi brauche (also nicht "/bin/sh" im Register, sondern eine Speicheradresse, an der "/bin/sh" steht).

Ich kann natürlich "/bin/sh" in den Puffer auf dem Stack schreiben, aber leider ist die Speicheradresse jedes Mal anders und ich kenne sie vorher nicht.

Ich weiß, dass "/bin/sh" in libc vorkommt, aber auch dort ist die Speicheradresse jedes Mal anders und ich kenne sie vorher nicht.

Wie komme ich also an einen "/bin/sh" Pointer? Gibt es Tricks oder bestimmte Instruktionen, nach denen ich mich umsehen sollte?

Hallo und mir ist es bewusst, dass ein Betriebssystem zu machen ziemlich schwer sein kann, aber ich würde sowas machen als ein Hobby.

Aber ich meine nicht Linux zu nehmen, sondern ein eigenes Betriebssystem zu machen, aber keines mit GUI, sondern einfach ein Terminal, sowie MS-DOS, C64, ZX Spectrum usw. Vielleicht simuliere ich auch eine eigene “simple” CPU oder nehme ein 8 oder 16 Bit Prozessor (wie Zilog Z80, MOS 6502 oder Motorola 68k) und simuliere es damit.

Warum ich auf diese Idee gekommen bin? Weil ich mal ein YouTube eine Person gesehen habe, der ein 16 Bit CPU gemacht hat mit „Logisim Evolution“ und schrieb sogar ein Emulator, Compiler, renderer, Circuit (Schaltkreise) und Programmiersprache. Ich will nicht alles davon machen, aber ich würde gerne mein Betriebssystem in Logisim simulieren und es auch programmieren.

Hier der GitHub Link von meiner Inspiration: https://github.com/sam-astro/Astro8-Computer

Mir ist es bewusst, dass man Assembly Kenntnisse braucht und auf jeden Prozessor, ob von Intel, AMD usw., ist die Programmiersprache auch etwas anders.

Also, wie kann ich anfangen?

Hallo,

auf dem MIPS Green Sheet steht, dass "add" den Opcode "000000" hat. Hingegen behauptet das Referenzblatt der Universität von Arizona, dass der Opcode für "add" "100000" ist.

Zudem haben "and" und "add" dort unterschiedliche Opcodes. Das hat mich verwirrt, weil in einer Online-Multiple-Choice-Übung meiner Universität behauptet wurde, dass "Die Befehle and und add weisen identische Werte für das Feld 'opcode' auf", eine richtige Aussage sein soll.

Und im MIPS Green Sheet, unsere bevorzugte Informationsquelle, enthält in die Opcode-Tabelle kein "and". Deswegen habe ich in eine andere Tabelle geschaut (die von der Universität von Arizona), aber die scheint ja etwas komplett Anderes zu sagen!

Ich frage mich, wo mein Missverständnis liegt. Irgendetwas muss ich falsch gemacht haben. Würde mich sehr darüber freuen, wenn mich irgendjemand aufklären könnte... Danke im voraus!

heyy, ich hab gerade für morgen ein Assembler code geschrieben, und kann diesen nicht laufen lassen durch f11...

der Pfeil und alles danach ist ausgegraut...

Hallo,

bei diesem Video wird ein Sprachassistent programmiert und das wollte ich nachmachen: https://youtu.be/x_gZYZ59cys?si=ROu4WUnMyfo83CmC

Bei Sekunde 30 jedoch, sagt sie, dass man assembly, openai und elevenlabs installieren muss. Wie geht das? Muss ich auf die jeweiligen Webseiten gehen und das herunterladen und wo muss ich die Zeilen, die bei Sekunde 30 sind hinschreiben? Kann mir bitte jemand helfen?

Vielen Dank

Es gibt Dart-Flutter, C#-Blazor soweit ich weiß, aber ich nehme an, es ist nur JavaScript unter der Haube.

Ähnlich wie, wenn man React Native Code schreibt, wird es in die native mobile Sprache umgewandelt => Kotlin, Swift etc..

Weil soweit ich weiß, versteht der Browser nichts anderes als HTML, CSS und JavaScript.

Es gibt da nur die V8-Engine / andere JavaScript-Engines.

Aber warum?

Wieso ist es nicht theoretisch möglich, einfach mit einer neuen Sprache die für cross platform entwickelt wurde, einen onclick-Event Listener zu nutzen?

In einer ganz eigenen Engine.

Heißt nicht, das sie JavaScript irgendetwas die nächsten 5 Jahre streitig machen könnte, aber wenn diese Sprache direkt Typisierung unterstützen würde, ohne TypeScript und auch noch für andere Dinge besser geeignet wäre als JavaScript (wurde halt nicht dafür designed, ganz egal ob Electron, Native existiert) wie Desktopanwendungen, Mobil, etc..

PHP nehme ich erst garnicht auf, das macht alleine gar nichts im Frontend, ist eine Backendsprache und alleine sinnlos auf Websites, bis auf bisschen HTML generieren, das auch nur vom Server kommt.

Klar, wenn du ewig lange Weiterleitungen willst, die furchtbar sind und überhaupt nicht interaktive Websites, dich auf Formulare beschränkst, dann kriegst du das auch ohne JavaScript hin, etwas Schreckliches zu programmieren.

Mit WebAssembly kenne ich mich gar nicht aus. Ob da Event Listener, usw. möglich sind. Aber alleine von der Einstiegshürde und Komplexität die ich höre, ist das keine Alternative.

Assembly ist auch keine Alternative zu C++. Dafür gibt es Rust.

Hallo, folgendes Problem; ich speicher ein Wort und möchte den ersten Byte auslesen:

.data ##
.text
.globl main
main:
li $s0, 0x1234abcd
lb $s1,0x00($s0)

Aus s0 soll er geladen werden, in diesem Fall d, aber ich bekomme diesen Fehler:

Runtime exception at 0x00400008: address out of range 0x1234abd1

Überall im Internet ist der gleiche Code, wieso funktioniert er bei mir nicht?

Hallo, mich interessiert es eine Programmiersprache, die Hardwarenah ist, weil ich gerne uneingeschränkt Programmieren möchte, ohne jetzt eine Runtime zu gebrauchen (wie .NET oder JDK mit JRE z.B.), aber zumindest ein Compiler wie GCC. Ich bin auch interessiert in Betriebssysteme wie Linux und verwende auch Linux.

Mir ist es bewusst, dass solche Programmiersprachen ein Sicherheitsrisiko sind, wegen Memory Leaks und andere Risiken, wenn man nicht vorsichtig damit umgeht. Besonders bei C, Assembly und C++.

Und ich habe schon Erfahrungen mit C# auf Visual Studio in der Schule seit 4 Jahren.

Was würdet ihr mir für den Anfang empfehlen?

Ich werde mir auch das Video von der Harward CS50 anschauen (aber nicht den kompletten Course), wo sie C erklären, weil von was ich kurz gesehen habe, gefällt es mir, werde mir aber kein Zertifikat holen.

Hey, also ich habe einen 32Bit Prozessor mit folgender Register und Speicherbelegung:

Nun soll ich erklären was in register t2 steht. Ich habe es so interpretiert, dass der Inhalt von s1 als Speicheradresse interpretiert wird. lhu läd einen 16bit wert von Adresse s1 + 0 in t2. Also läd es doch von der Speicheradresse 0x119 2 Byte. Aber es gibt doch nicht diese Speicherstelle?

Das Ergebnis ist : 0xa75a (in Sepicherstelle 0x118 , wahrscheinlich als little endian angegeben)

Gruß

Hallo, es geht um folgende Aufgabe:

ADCS R11, R2, R4.

R2 = 0xFFFF FFFF

R4 = 0x8000 0000

Befehl ADCS erfolgt so: Rd = Op1 + Op2 + Carry.

Ich verstehe hier nicht, wie ein Carry dazu addiert werden soll? Kann mir da jemand helfen bitte.

section .text
	extern scanf
	extern printf
	global main

main:
	push msg
	call printf
	
	push input
	push formatin
	call scanf
	add esp, 8

	push input
	push formatin
	call printf
	
exit:
	mov eax, 1
	mov ebx, 0
	int 80h

section .data
 formatin: db "%s", 0
 input: times 32 db 0
 msg db 'Input eingeben:', 0xa

Eingabe funktioniert
es erscheint Input eingeben:
Gebe z. B. Hallo ein drücke enter
Ausgabe erscheint nichts. Warum?

Hey,

Ich will so langsam auch reverse Engineering lernen habe auch gut Kenntnisse mit Assembly. Ich weiß auch das man sowas macht damit mit z.b Exploits oder 0day Malware erstellen kann aber wozu auf Games anwenden und bringt es am Ende überhaupt etwas?

The data section is used for declaring initialized data or constants. This data does not change at runtime. You can declare various constant values, file names, or buffer size, etc., in this section.

Soweit ok!

In der section .data

mymsg db 'Hello World', oxa

Fragen dazu: Dieses mymsg ist jetzt in dem Fall eine Adresse und keine Variable.

=> Richtig? Da Variablen in section bss liegen?

=> db heißt ja define byte. Bedeutet das jetzt, dass ich für mymsg, die Adresse, ein Byte festlege bzw. freien Speicher zuordne?

Was macht dieser Code?

Kann man mit scanf etwas von der Konsole einlesen?

Ich pushe hier auf den Stack in der main: nur die 101 und den String mymsg

Warum wird unten in der Konsole, wenn ich das Programm ausführe, auch der

zweite String s mitausgegeben?

section .text
global main

main:
  mov esi, 10           ; ESI holds current number
  mov eax, 0           ; EAX holds sum of numbers
  push 10             ; Line feed for end of line (Stack is first in, last out -> Line feed will be last char)
  mov edi, 10           ; Divisor of 10 for seperating digits of number (used in divisionLoop)



; Sum numbers 1 through 10
sumLoop:
  add eax, esi          ; Add number to sum
  dec esi             ; Next number
  jnz sumLoop           ; Loop until 0



; Seperate eax into its digits, by dividing by 10 multiple times,
; where in each division the remainder will be a single digit 
; and the quotient will be the remaining digits used as dividend in next loop run
divisionLoop:
  mov edx, 0           ; Make sure edx is empty, as it is used as upper half of dividend
  div edi             ; Divide eax by edi (= 10) => quotient is in eax (= Rest of digits for next loop), remainder in edx (= Single digit)
  add edx, 48           ; Make edx (digit) a char representing its value by adding '0' to it
  push edx            ; Push char to stack for usage in print later

  cmp eax, 0           ; Loop until quotient is 0 (=> no more digits left)
  jne divisionLoop



; Print digits from Stack one by one
printLoop:
  mov eax, 4
  mov ebx, 1
  mov ecx, esp          ; Print top of stack (esp always points to top of stack)
  mov edx, 1           ; Length of 1 byte (= 1 char)
  int 80h

  pop esi             ; Remove top of stack
  cmp esi, 10           ; Loop until Line feed is reached
  jne printLoop


exit:
  mov eax, 1
  mov ebx, 0           ; Exit code 0
  int 80h

Hallo,

hier steht ein Programm in Assembler, dass die Zahlen von 1 bis 10 addiert.

Die 55 durch 10 teilt und die Reste der Division dann in einem Stack speichert.

push....

Am Ende wird alles über den Standardkanal ausgegeben auf der Konsole.

Wenn ich 55 / 10 teile ergibt das Quotient 5 steht in Register eax und der Rest hier auch 5 in edx Register. Bevor ich jetzt den Rest auf den Stack lege wird die Zahl mit 48 addiert. ergbit 53 ist das char Zeichen 5 im ASCII Code.

Heißt das jetzt, dass die Ergebnisse bei einer ganzzahligen Division im Assembler-Code immer in ASCII-Zeichen gespeichert sind?

mov dx, offset msg

Unten steht, was der Befehl bedeutet. Was mich wundert ist, dass man hier

offset msg schreibt. Warum offset msg?

Wie man in der Grafik sieht hat der Prozessor 8 Haupt-Register mit je 32-Bit, wo jeweils eine Zahl drinnen steht. Z. B. EAX, EBX...

Jetzt gibt es ja noch eine andere Möglichkeit, dass man z. B. diese AX, BX, ...Register mit 16-Bit nutzt/hat.

=> Ist es nun vom Prozessor abhängig, den ich nutze, ob ich diese EAX, EBX Register oder diese AX, BX Register habe?

=> Oder kann ich dies selber festlegen/programmieren/einstellen...?

Dritte Möglichkeit ist die Aufteilung der 16-Bit Register AX, BX in AH, AL oder BH, BL...

=> D. h. ich habe jetzt hier 2 Register zu je 8-Bit. 8-Bit in AH und 8-Bit in AL

=> Kann man jetzt hier auch wieder nur "eine" Zahl drinnen speichern oder jetzt "zwei"?

Increments 32-Bit register

=> Was soll das bedeuten, das man ein 32-bit register hier EBX um 1 erhöht?

32-bit sind 4 Byte. D. h. dort stehen vier Zeichen oder vier Zahlen, jede im Bereich 2^7 ist 0 bis 255.

inc [count]

=> Hier erhöhe ich den Inhalt/Wert der Variablen count um 1. In der Variablen count ist z. B. die Zahl 5, braucht 1-Byte als Hexa 0x5 abgespeichert. Mittels inc erhöht sich der Wert der Variablen um 1 also hat sie nun den Wert 0x6 => ist 6.

Richtig?

Was bewirkt das Add EBX, 2 ;EBX = EBX + 2 ?

Mov [EBX], 123 ; My_Table[1] = 123

Warum spreche ich jetzt hier My_Table[1] an?

1 ist die zweite Zahl in dem Register EBX?

ich habe diese Schritte nicht verstanden:

"shl eax, 16

sar eax, 8

mov edx, eax

shr edx, 16"

Warum haben wir folgendes geschrieben ?

   cld
   rep     movsb

durch lopsb und stosb wird jedes Byte in esi mit 2 addiert und nach edi transferiert, oder ?

können die beiden Operanden zwei Speicherzugriffe sein ? oder sollen die beiden Register sein ?

Warum hat man hier "PUSH EDX" geschrieben ?

Was ist seine Aufgabe ?

Wenn wir darauf verzichten, was könnten es sein ? Wird der Programm ein Fehler zeigen ?

Negative - Flag = negatives ALU ergebnis

Carry - Flag = ALU Ergebnis erzeugte Carry (Übertrag)

Zero - Flag = ALU Ergebnis ist Null

Overflow - Flag = ALU Ergebnis erzeugte Overflow. ~ Was ist Overflow ?

Was macht es genau? Ich verstehe es nicht.. kann mir da Jemand helfen?

Guten Abend,

Kürzlich habe ich ein kleines Programm in x86-Assembly geschrieben. Da ich absoluter Anfänger in diesem Bereich bin, habe ich erstmal mit 16-Bit Assembly für DOS begonnen. Das Problem ist, dass ich Windows 11 habe, das ausschließlich als 64-Bit Version verfügbar ist und keine Programme unter DOS mehr unterstützt.

Nun ist meine Frage, wie ich dennoch eine DOS-Umgebung simulieren und das Programm ausführen kann, ohne dass es Kompatibilitätsprobleme gibt.

LG Heinzfred

Guten Tag,

In letzter Zeit sehe ich mir immer wieder Codeschnipsel an, in denen der Code höherer Programmiersprachen mit ihrem Assembly-Pendant verglichen wird. Ich habe schon ein wenig Erfahrung mit C-Programmierung, ansonsten nur mit Webdevelopment. Assemblersprache reizt mich schon ein wenig, vor allem die Nähe zur Hardware. Ich habe mal eine kurze Zeit unter Ubuntu Linux mit NASM experimentiert, woran ich auch Freude hatte. Nun suche ich einen gescheiten Assembler für Windows. Ja, ich kenne den MASM und habe ein wenig in den Docs gelesen. So blöd das auch klingen mag - der meiner Meinung nach zu vollgepackte Funktionsumfang gefällt mir einfach nicht, ebenso Schlüsselwörter wie includelib. Unter Linux hat die Ausgabe von Texten in der Standardausgabe mit einfachen Syscalls funktioniert. Ich bin also auf der Suche nach einem Assembler, der alle notwendigen und wichtigen Operationen zur Verfügung stellt, vielleicht sowas wie der GNU-Assembler mit Intel-Syntax.

LG Heinzfred

Ich habe folgende Projektidee:

Ich würde gerne eine Digitaluhr selbst bauen (Platine kaufen, selbst bestücken etc.)

Die Zeit sollte durch einen Mikroprozessor berechnet werden, wobei ich den Mikroprozessor programmiere, um die Zeit zu erhalten. Diese Zeit soll anschliessend auf dem Display angezeigt werden, die Zeit sollte echt sein, also die Uhr sollte möglichst irgendwie per Funk die Zeit empfangen. Ein Bild wie, das Ganze am Schluss aussehen könnte, findet Ihr weiter unten.

Nun folgende Fragen:

1. Was muss ich alles einplanen (Bauteile, Berechnungen etc.) ?
2. In welcher Programmiersprache sollte ich den Mikroprozessor programmieren? Ich nehme an, in Assembly.
3. Wie anspruchsvoll ist das Ganze, beziehungsweise ist es überhaupt möglich, dies zu tun (Vorkenntnisse, eines Elektronikers, sowohl eines Programmierers, könnte ich einholen) ?

Wann wird Overflow, wann carry und wann beides gesetzt? Dabei gehts mir wies hardware technisch aussieht:

 0111
+0001
01000 => carrys
------
01000 =>result
=========
In arm nur V flag (overflow gesetzt)

.

 10011
+11001
100110 =>carrys
-----------
101100 =>result
=========
beides gesetzt

.

 11100
+00110
111000 =>carrys
------
100010 =>result
=======
carry nur gesetzt

Wie man sieht, ist das letzte carry gleichzeitig das carry bit. Beim overflow aber komplexer. Warum ist das so? Wann erkennt er den overflow und woran?

Ich bekomme einen Speicherzugriffsfehler bei einem Teil meiner IOTA Methode. Diese Funktion ermittelt die Länge einer Zahl, die im eax Register später steht. Das funktioniert auch, das Ergebnis ist richtig, nur ich bekomme dann einen nervigen Speicherzugriffsfehler.

Die Methode wird folgendermaßen angesteuert:

  push    edi
  push    ebx
  push    esi
  mov     esi, 0   mov     edi, eax


  call    len_count


len_count:   mov     eax, edi   mov     ebx, 10   idiv    ebx   call    resetcalc


  mov     edi, eax


  cmp     eax, 0   je      len_iszero   inc     esi   jne     len_count


len_iszero:   mov     eax, esi   add     eax, 1   pop     esi   pop     ebx   pop     edi   ret

Die Methode steuere ich so an:

 mov  eax, 15024
 call  len

In len_iszero ist eax beim Abschluss der Methode 5, logisch, die Zahl ist fünfstellig. len_iszero läuft komplett durch und dann gibt es einen Speicherzugriffsfehler.

Ich habe schon öfters gelesen, dass Chris Sawyer RCT zu 99% in Assembly und 1% in C programmiert hat. Wieso ist dies so faszinierend? Ich kenne mich mit programmieren überhaupt nicht aus. Ich wäre dankbar wenn es mir jemand ausführlich erklären könnte.

Wofür kann ich Assembly Language verwenden?

Ein bekannter hat mir erklärt, dass es eine andere 'Schreibweise' von Maschinencode ist. Ausserdem habe ich gelesen, dass man Assembler auch für das Entwickeln von Betriebssystemen verwendet.

Was sind andere die Anwendungsgebiete dieser Sprache?

Ganz am anfang meiner Programmierreise hat man mir gesagt C und C++ seien Low-Level Programmiersprachen. Jetzt höre ich aber immer wieder das das High-Level Programmiersprachen sind.

Laut dem was ich auf Wikipedia gelesen habe sind eigentlich nur Maschinencode und Assembly Low-Level Sprachen. Gibt es keine andere, falls das wahr sein sollte?

Was stimmt nun?