Maschinensprache

[Neutral General]

Ich habe mal eine total verrückte Frage :

Kann man Programme in Maschinensprache programmieren, also im Binärsystem ?
Und wie macht man sowas ? Einfach in eine Textdatei

Delphi-Quellcode:

001010100111000110
101010110110001100
010000111001011101

schreiben und als Exe-Datei speichern ?

[StefanDP]

das ganze nennt sich assembler!
es gibt auch assembler für windows
du selbst brauchst nicht in 0en und 1en schreiben, sondern kannst z.b.
MOV R16 R17 oder so schreiben
das wird dann vom assembler in einen Maschinencode aus 0en und 1en umgewandelt

um eine exe daraus zu machen musst du es noch compilieren

[Neutral General]

Ich will aber 1en und 0en schreiben :mrgreen:

[sakura]

Zitat:

Zitat von Neutral General

Ich will aber 1en und 0en schreiben :mrgreen:

Hast Du Dir mal eine EXE angesehen, da ist nichts mit 0 und 1en, da sind alle 256 Varianten eines Bytes drinne ;-) Also HEXA-Dezimalen Editor und los gehts.

Ist es möglich? Ja.
Macht es wer? Nur extrem talentierte oder total verrückte.
Warum macht es heutzutage noch jemand? Keine Ahnung :mrgreen:

...:cat:...

[d3g]

Man kann. Wenn du die Textdatei mit Nullen und Einsen schreibst, wirst du allerdings eine Datei mit den ANSI-Codes der Nullen und Einsen erhalten. Die Nullen und Einsen sind ohnehin nur eine etwas bildliche Größe. Was du machen müsstest, ist einen Editor öffnen, der Binärdateien berbeiten hann (es bäte sich ein Hexeditor an, aber ein Texteditor, der mit dem gesamten ASCII-Zeichensatzumgehen kann, täte es auch) und dann byteweise die Instruktionen und deren Parameter schreiben.

Weil das unheimlich umständlich und sehr schwer handzuhaben ist, benutzt man meistens Assembler. Dort schreibt man die Opcodes und deren Parameter in einem menschenlesbaren Format, hat aber genau dieselben Möglichkeiten wie beim direkten binären Programmieren.

[edit]Etwas langsam, naja...[/edit]

[Neutral General]

Oh... ich fürchte das ist doch etwas umständlicher als ich gedacht hab ^^

[sakura]

Zitat:

Zitat von Neutral General

Oh... ich fürchte das ist doch etwas umständlicher als ich gedacht hab ^^

Es ist noch mal viel umständlicher ;-)

...:cat:...

[Christian Seehase]

Moin Neutral General,

mal abgesehen vom Aufwand:
Such' Dir erst mal etwas, wo Du es nutzen könntest.

Das wären dann, vielleicht, ein Zuse oder ein ENIAC Simulator (falls es so etwas gibt :gruebel: )

[MaBuSE]

Zitat:

Zitat von sakura

Zitat:

Zitat von Neutral General

Oh... ich fürchte das ist doch etwas umständlicher als ich gedacht hab ^^

Es ist noch mal viel umständlicher ;-)

Das wird an einem einfachem Beispiel klar:

Schau doch mal wie groß denn so die Programme (*.exe) auf deinem Rechner sind.

Wenn eine Project2.exe 512 kByte hat (also 0,5 MB) dann sind dass 512 * 1024 Bytes.
Ein Byte hat 8 Bit. Also hätte eine Exe mit 0,5 MByte 4.194.304 Einsen und Nullen.

Wie lange braucht man um über 4 Mio Einsen und Nullen zu tippen :mrgreen:

-gut- es gibt auch kleinere Programme ;-), aber 0,5 MB ist keine Seltenheit.

[phXql]

Maschinencode is doch nich das selbe wie Assembler. Assembler hat ja schon n paar befehle, aber maschinencode is wirklich nur "strom da" und "strom nich da" (1 bzw 0)... Oder hab ich da mal wieder nich aufgepasst? ^^

[dizzy]

Für den Kameraden hier habbich was gefunden :mrgreen:

[Stanlay Hanks]

Es hat doch niemand was anderes gesagt :gruebel:

Ich hab übrigens mal etwas weiter gerechnet (Wahrscheinlich hab ich mich wiedermal verrechnet):

Angenommen, man weiß genau, was man tippen will (man hat also auswendig die von MaBuSe errechneten 4.194.304 Nullen und Einsen im Kopf) und tippt pro Sekunde (gerade im Eigenversuch probiert) 6 Ziffern, also 21600 pro Stunde, benötigt man für die 4 Mio Nullen und Einsen gerade mal 194 Stunden, also 8,x Tage. Problematisch wird das ganze, wenn man zwischen jeder 0 und 1 noch 5 Sekunden Pause zum Überlegen machen muss :mrgreen:


Man liest sich, Stanlay :hi:

[woki]

Zitat:

Zitat von phXql

Maschinencode is doch nich das selbe wie Assembler. Assembler hat ja schon n paar befehle, aber maschinencode is wirklich nur "strom da" und "strom nich da" (1 bzw 0)... Oder hab ich da mal wieder nich aufgepasst? ^^

Ja, da liegst du nicht ganz falsch. Maschinencode wäre etwas, was durch kein Übersetzungsprogramm mehr laufen muß, um vom Prozessor ausgeführt zu werden. Assembler braucht ja schon ein Übersetzungsprogramm, eben den Assembler. Beim Assembler (wie ich ihn definieren würde), entspricht ein Assemblerbefehl genau einer Prozessoranweisung, und ich kann mit Symbolen arbeiten, statt z.B. Sprungziele von Hand ausrechnen zu müssen.
Zu einem Zeitpunkt, zu dem man nichts weiter hat als einen nackten Prozessor (mit Peripherie aber ohne irgendwelche Software) kann man mit Maschinensprache anfangen, aber eben nicht mit Assembler.


Grüsse
Woki

[MaBuSE]

Zitat:

Zitat von phXql

Maschinencode is doch nich das selbe wie Assembler. Assembler hat ja schon n paar befehle, aber maschinencode is wirklich nur "strom da" und "strom nich da" (1 bzw 0)... Oder hab ich da mal wieder nich aufgepasst? ^^

Mir ist nun klar geworden, dass es Sinn macht etwas mehr zu Thema zu schreiben ;-)

Also...

• Computer arbeiten digital. (Digital bedeutet logisch es gibt nur 1 und 0 bzw. auf der elektrischen Ebene es gibt nur Strom an und Strom aus.)
  Das kleinste Digitale Element ist ein Bit. (Ein Bit kann 1 oder 0 sein.)
  
• Wenn man mit Bits arbeitet, benutzt man das Binäre (duale) Zahlensystem.
  Damit kann man mit 2 Bit 4 Zustände, mit 4 Bit 16 Zustände und mit 8 Bit 256 Zustände darstellen.
  
  Code:

  bin  dez
  00 = 0
  01 = 1
  10 = 2
  11 = 3

• 8 Bit werden in einem Byte zusammengefasst.
  Zur Darstellung benutzt man das Hexadezimale Zahlensystem. (Hier gibt es Ziffern von 0 bis F.)
  
  Code:

  bin    hex   dez
  0000 = 0   = 0
  0001 = 1   = 0
  0010 = 2   = 0
  0011 = 3   = 0
  0100 = 4   = 0
  0101 = 5   = 0
  0110 = 6   = 0
  0111 = 7   = 0
  1000 = 8   = 0
  1001 = 9   = 0
  1010 = A   = 10
  1011 = B   = 11
  1100 = C   = 12
  1101 = D   = 13
  1110 = E   = 14
  1111 = F   = 15

  Die 8 Bits 11010110 werden in 2 4er Gruppen aufgeteilt: 1101 0110
  und dann, nach der Tabelle oben, Hexadezimal dargestellt:
  1101 = D und 0110 = 6 -> 11010110 = D6
  So werden statt 8 Zeichen nur noch 2 benötigt (viel weniger zu tippen ;-))
  
• Ein Maschinen Programm könnte also wie folgt aussehen:
  EB 0C 68 65 6C 6C 6F 20 77 6F 72 6C 64 24 BA 02 01 B4 09 CD 21 B8 01 4C CD 21
  Dieses Programm gibt auf dem Bildschirm (in der Dos Box) "hello world" aus :mrgreen:
  
• Es ist natürlich sehr schwer sich die Befehle in dieser Form zu merken, deshalb wurden für die einzelnen Befehle kleine Kürzel (so genannte mnemonische Symbole, kurz Mnemonics)
  • EB bedeutet JMP (Jump = Springe nach)
  • 0C ist der Parameter von JMP und bedeutet 12 Byte
    -> Der 1. Befehl ist also ein "goto 12 Bytes weiter"
  • 68 65 6C 6C 6F 20 77 6F 72 6C 64 24 ist die hexadezimale Darstellung von "hello world$" (genau 12 Bytes :-))
  • BA bedeutet MOV DX, Wert
  • 02 01 Ist der Wert (Es werden Low und High Byte vertauscht -> Wert = 0102)
    -> MOV DX, 102 -> Dieser Befehl speichert den Wert 0102 in dem Register DX des Prozessors ab
  • B4 bedeutet MOV AH, Wert
  • 09 ist der Wert
    -> MOV AH, 09 -> speichert den Wert 09 im Register AH ab
  • CD bedeutet INT Wert
  • 21 ist der Wert
    -> INT 21 -> ruft den Software Interupt 21 auf
    -> hier wird die DOS Funktion 09 mit Parameter 102 aufgerufen
    -> diese gibt den Text ab Adresse 102 bis zum $ aus
  • B8 bedeutet MOV AX, Wert
  • 01 4C ist der Wert (Es werden Low und High Byte vertauscht -> Wert = 4C01)
    -> MOV AX, 4C01 -> schreibt 4C01 in Register AX
  • CD bedeutet INT Wert
  • 21 ist der Wert
    -> INT 21 -> ruft den Software Interupt 21 auf
    -> hier wird die DOS Funktion 4C 01 aufgerufen
    -> diese beendet das Programm
• hier noch mal das ganze Listing:
  
  Code:

  125A:0100 EB0C          JMP     010E
  125A:0102 68656C6C6F20  DB      "hello "
  125A:0108 776F726C6424  DB      "world$"
  125A:010E BA0201        MOV     DX,0102
  125A:0111 B409          MOV     AH,09
  125A:0113 CD21          INT     21
  125A:0115 B8014C        MOV     AX,4C01
  125A:0118 CD21          INT     21

• so sieht’s als Hex Dump aus:
  
  Code:

  125A:0100  EB 0C 68 65 6C 6C 6F 20-77 6F 72 6C 64 24 BA 02   ..hello world$..
  125A:0110  01 B4 09 CD 21 B8 01 4C-CD 21 00 00 00 00 00 00   ....!..L.!......

• Wie kann ich das denn selbst ausprobieren?
  Es gibt im MS DOS / Windows ein Programm Debug.exe mit dem das geht.
  Dieser Debugger wird von der Dos Box aus gestartet:
  
  Code:

  C:\>debug
  -n c:\temp\hello.com
  -a
  11D1:0100 jmp 130
  11D1:0102 db "hello world",24
  11D1:010E mov dx,102
  11D1:0111 mov ah,9
  11D1:0113 int 21
  11D1:0115 mov ax,4c01
  11D1:0118 int21
  11D1:011A
  -a 100
  11D1:0100 jmp 10e
  11D1:0102
  -rcx
  CX 0000
  :1a
  -w
  0001A Bytes werden geschrieben.
  -q
  
  C:\>c:\temp\hello.com
  hello world
  C:\>

  Anmerkung zu obigem Beispiel:
  Ich habe erst einen "jmp 130" eingegeben, da ich ja nicht wusste wie lange mein Text wird.
  Vor "mov dx,102" steht die Adresse "010E".
  Diese Adresse habe ich am Schluss nochmal korrigiert "jmp 10e"
  
  mit "n dateiname" legen wir den Dateinamen fest.
  mit "a" schalten wir in die Assembler Eingabe um
  mit "rcx" legen wir die Programmgröße fest (nach "Int 21" steht "xxxx:011A", da wir bei 0100 begonnen haben und nun bei "011A" sind ist das Programm "1A" Byte groß) ("1A" hex = 26 dez)
  mit "w" speichern wir das Programm ab
  mit "q" beenden wir den Debug.exe
  
  Im Debug.exe kann man mit ? eine kleine Hilfe (Befehlsübersicht) bekommen.

So das sollte als Info reichen.

Viel Spaß
Dr. MaBuSE

ps: ich werde das auch nach Tutorial posten :mrgreen:

[MaBuSE]

Hier kann man noch etwas mehr dazu lesen:

• WikiPedia - Assembler (Informatik)
• WikiPedia - Assemblersprache
• WikiPedia - Maschinensprache

[GuenterS]

Notfalls könnte man auch ein Delphi Programm schreiben, das 8 Nullen oder Einsen in das entsprechende Byte umrechnen und so dann Maschinencode erzeugen.

Inwieweit das aber Sinnvoll ist, sei dahingestellt, zumal Verglichen mit Maschinencode ist Assembler noch die schönste "Hochsprache" (finde ich)

[Neutral General]

Zitat:

Zitat von GuenterS

Notfalls könnte man auch ein Delphi Programm schreiben, das 8 Nullen oder Einsen in das entsprechende Byte umrechnen und so dann Maschinencode erzeugen.

Inwieweit das aber Sinnvoll ist, sei dahingestellt, zumal Verglichen mit Maschinencode ist Assembler noch die schönste "Hochsprache" (finde ich)

Hey gute Idee ... Kannst du mir vielleicht einen Ansatz geben wie man das realisieren könnte ? :)

[Tubos]

Zitat:

Inwieweit das aber Sinnvoll ist, sei dahingestellt, zumal Verglichen mit Maschinencode ist Assembler noch die schönste "Hochsprache" (finde ich)

ASM ist keine Hochsprache ;)
Aber ich halte es für extrem sinnlos, in Maschinensprache zu proggen wenn es doch Assembler gibt...

[Fourcorner]

Solly,
Assembler ist halt nicht so schön zu lesen wie Pascal oder C++, aber ich glaube ,dass es keinen Sinn machen würde, ein Pro zu schreiben, das alles in 0 und 1 umwandelt.
Assembler ist auserdem schon durchgetestet. warum also arbeit machen?

[Neutral General]

Bitteeeee... ich will nur mal ausprobieren ob das funktioniert :stupid:
Nur einen kleinen Ansatz...

[moritz]

Sicher funktioniert es, die Programme machen ja auch nicht mehr als nullen und einsen zu erzeugen. Dafür musst du dich aber schwer einlesen.

[Tubos]

--> Hexeditor
Schreibe einen Hexeditor, und dann kannst du immer noch Einser und Nullen in das Hexadezimalsystem umrechnen, wenn du noch tiefer gehen willst.

[MaBuSE]

Hallo,
ich wurde folgendes gefragt:

Zitat:

...ich hab eine kleine Frage an dich:
Kennst du eine gute Dokumentation zu debug? ...

Diese Seite hier ist ganz gut:
MS-DOS DEBUG Program

gefunden mit:
DOS DEBUG.EXE

Viel Spaß
Dr. MaBuSE

[GuenterS]

Zitat:

Zitat von Tubos

Zitat:

Inwieweit das aber Sinnvoll ist, sei dahingestellt, zumal Verglichen mit Maschinencode ist Assembler noch die schönste "Hochsprache" (finde ich)

ASM ist keine Hochsprache ;)
Aber ich halte es für extrem sinnlos, in Maschinensprache zu proggen wenn es doch Assembler gibt...

Das weiß ich, dass ASM keine Hochsprache ist, deshalb hab ich es ja unter "" gestellt. Nur vergleichsweise zu Maschinencode kommts einem schon so vor, da assembler eben deutlich lesbarer ist.


Vielleicht ist mir am Wochenende fad, dass ich sowas mal schreib.

[choose]

Sehr gute Darstellung, MaBuSE!

Da bekomme ich schon fast wieder Lust :)

[MaBuSE]

Zitat:

Zitat von choose

Sehr gute Darstellung, MaBuSE!
Da bekomme ich schon fast wieder Lust :)

Danke.
Die Erstellung des kleinen Tutorials hat auch viel Spaß gemacht.
Habe schon seit Jahren kein DEBUG.EXE mehr benuzt.

Aber in Delphi kenn man ja auch Assebler programmieren:

Delphi-Quellcode:

procedure TForm1.BitBtn1Click(Sender: TObject);
var
  x, y, z: Integer;
begin
  x := 5;
  y := 7;
  z := 0;
  asm
    MOV     EAX,X
    ADD     EAX,Y
    MOV     Z,EAX
  end;
  showmessage('Z='+IntToStr(z));
end;

Es gibt ja auch noch den CPU Debuger.
Einfach auf MOV EAX,X einen Breakpoint setzen und danach in die CPU Sicht gehen.
(Menü -> Ansicht -> Debug-Fentser -> CPU)
siehe Bild im Anhang
Da kann man dann Delphi-Programme auf Assembler Ebene debuggen.

[Neutral General]

Also nochmal eine blöde (?) Frage: Würde es theoretisch gehen wenn man das richtige in eine Textdatei
schreibt und diese dann in .exe umbenennt, das da dann ein Programm
rauskommt ?

[d3g]

Ja. Nur erlaubt dir nicht jeder Editor, alle notwendigen Zeichen eingeben zu können (das Nullbyte zum Beispiel).

[Neutral General]

Nein, aber Delphi erlaubt es doch oder ?

[d3g]

Nein, glaube kaum. Nimm einen Hexeditor oder debug.exe.

[Neutral General]

Wenn ich jetzt sowas hab :

Delphi-Quellcode:

E2 21 FF 21 AC 11 7D

Kann ich das nicht mit Delphi so in eine Textdatei speichern das das ein richtiges Programm wird ?
Auch wenn das hier wahrscheinlich nichts sinnvolles ergeben würde :mrgreen:

[MaBuSE]

Zitat:

Zitat von Neutral General

Wenn ich jetzt sowas hab :

Delphi-Quellcode:

E2 21 FF 21 AC 11 7D

Kann ich das nicht mit Delphi so in eine Textdatei speichern das das ein richtiges Programm wird ?
Auch wenn das hier wahrscheinlich nichts sinnvolles ergeben würde :mrgreen:

Kein Problem:
Einfach neue Anwendung, TMemo, TEdit und TButton drauf und folgenden Quelltext ;-)

Delphi-Quellcode:

// Wandelt Hex Code in Bin Datei um
// Benötigt:
//    Memo1 mit Hexwerten
///     (z.B. Memo1.Lines.Text := 'EB 0C 68 65 6C 6C 6F 20 77 6F 72 6C 64 '+
//                                '24 BA 02 01 B4 09 CD 21 B8 01 4C CD 21';)
//    Edit1 mit Dateinamen
//      (z.B. Edit1.Text := 'C:\TEMP\TEST.COM';)
//
// written by Dr. MaBuSE
procedure TForm1.Button1Click(Sender: TObject);
var
  i: Integer;
  s: string;
  BinDatei: TextFile;
begin
  s := Memo1.Lines.Text;

  // unnötige Zeichen aus Text entfernen
  i := length(s);
  while i > 0 do
  begin
    if pos(upcase(s[i]), '0123456789ABCDEF') = 0 then
    begin
      delete(s, i, 1);
    end;
    dec(i);
  end;

  AssignFile(BinDatei, Edit1.Text);
  ReWrite(BinDatei);
  // String aus Hexwerten in Bin konvertieren
  for i := 0 to (length(s) div 2)-1 do
  begin
    Write(BinDatei, Chr(StrToInt('$'+s[i*2+1]+s[i*2+2])));
  end;
  CloseFile(BinDatei);
end;

[MaBuSE]

Oder folgende Funktion verwenden:

in der Delphi 7 Hilfedatei steht

Die Funktion konvertiert einen String mit Hexadezimalzeichen in den entsprechenden Binärwert.

Delphi-Quellcode:

function HexToBin(Text, Buffer: PChar; BufSize: Integer): Integer

Beschreibung
Mit HexToBin können Sie den Hexadezimal-String Text in den entsprechenden Binärwert umwandeln.
Text ist die String-Darstellung eines Hexadezimalwertes.
Buffer gibt den Wert in der binären Darstellung zurück.
BufSize legt die Größe von Buffer fest. Text muss auf Hexadezimalzeichen mit mindestens 2*BufSize zeigen, das jedes Hexadezimalzeichen ein Byte repräsentiert.
HexToBin gibt die Anzahl der Zeichen in Buffer zurück, die nicht verwendet wurden, das Text keine gültigen Hexadezimalzeichen enthalten hat ('0'..'f')..

Hinweis: Die Hexadezimalzahl muss Zeichen in Kleinschreibung enthalten, da HexToBind keine Zeichen in Großschreibung erkennt.

[Neutral General]

Danke aber bei Delphi 3 gibt diese Funktion leider nicht (Wie sovieles andere auch :evil: )
Wie kann ich z.B dein Hello-World Programm damit machen ?

Wenn ich in das Memo :

Delphi-Quellcode:

EB 0C 68 65 6C 6C 6F 20 77 6F 72 6C 64 24 BA 02 01 B4 09 CD 21 B8 01 4C CD 21

eingebe sieht die Exe so aus :

Delphi-Quellcode:

ëhello world$º
´   Í!¸
LÍ!

ist das richtig so ?
Wenn ich das Programm starte blinkt jedenfalls nur das DOS-Fenster kurz auf :(

[tommie-lie]

Zitat:

Zitat von Neutral General

Also nochmal eine blöde (?) Frage: Würde es theoretisch gehen wenn man das richtige in eine Textdatei schreibt und diese dann in .exe umbenennt, das da dann ein Programm rauskommt ?

Jein, eine Windows-EXE enthält nicht nur den MAschinencode. Die Datei muss dem PE-Format folgen, also .data- und .text-Abschnitt, diverseste Header (unter XP evtl noch ein Manifest).

[Shaman]

@tommie-lie: Er hat schon recht, wenn er das Richtige in eine Textdatei schreibt, kommt sicher ein Programm raus. Nur wird er Probleme haben, #0 zu schreiben... :wink:

Gruss
Shaman

[Neutral General]

dumme Frage #3 : Was ist #0 :mrgreen:

[dizzy]

Ich glaube, dass das gesamte Unterfangen nichts weiter als reine Zeitverschwendung würde. Sicherlich ist es sinnvoll Grundlagen zu lernen - aber in dieser Form ist's irgendwie sehr sinnlos. Selbst wenn du wüsstest dass mit #0 das ASCII-Zeichen mit dem Index 0 gemeint ist, und damit u.a. Strings abgeschlossen werden, so ist es ganz einfach viel zu viel Handarbeit. Ich spreche da aus Erfahrung - ich habe mal versucht die FPU direkt zu steuern - also mit Opcodes. Man ist dann nur noch dabei sämtliche Speicheradressen von Hand zu berechnen, und die Parameter der Opcodes in Hex, oder in diesem Fall binär zu kodieren.
Trink dir lieber ne gute Tasse Tee, da hast du im Endeffekt mehr von :D.
Der einzige Grund die CPU von Hand steuern zu wollen ist, wenn du einen kompletten Compiler von null auf selber bauen wolltest. Und selbst das wird nicht in 0/1 gemacht.

Es sei gesagt dass es theoretisch möglich ist, sich aber eigentlich jeder sinvollen Machbarkeit entzieht.

Gruss,
Fabian

[Neutral General]

Zitat:

Zitat von dizzy

Selbst wenn du wüsstest dass mit #0 das ASCII-Zeichen mit dem Index 0 gemeint ist, und ...

Das das ein ASCII-Zeichen mit dem Index 0 ist weis ich auch -.-

Trotzdem würde ich gerne wissen warum

Delphi-Quellcode:

EB 0C 68 65 6C 6C 6F 20 77 6F 72 6C 64 24 BA 02 01 B4 09 CD 21 B8 01 4C CD 21

umgewandelt in

Delphi-Quellcode:

ë hello world$º
´   Í!¸
LÍ!

nicht als exe-Datei funktioniert . Normalerweise müsste dann doch da 'hello world' stehen oder ? Bei mir blinkt aber nur kurz die DOS-Box und dann ist Ende... :gruebel:

PS: Das das eigentlich Zeitverschwendung ist ist mir klar, aber ich interessiere mich jetzt eben dafür und sinnvolle Programme hab ich noch selten geschrieben :mrgreen:

[Shaman]

Starte das Programm mal von der Kommandozeile aus.

Gruss
Shaman