Segfo avec 0 caractères avec gcc

introduction

[Matériel populaire](https://qiita.com/search?q=%E3%82%BB%E3%82%B0%E3%83%95%E3%82%A9%E3%82%89%E3 C'est une chevauchée sur% 81% 9B% E3% 82% 8B).

Démonstration rapide

J'utilise x86-64 Ubuntu 19.04 + gcc 8.3.0 comme environnement de vérification de fonctionnement.

Construire et exécuter


$ gcc -xc /dev/null -nostdlib -Wl,-e0xfa -Wl,-Ttext=0x2504890000 -zexecstack && ./a.out
Segmentation fault (core dumped)
$ 

Commentaire

Tout d'abord, essayez de compiler le plus petit programme C qui ne donne pas d'avertissement.

int main(){}

Comme il est difficile de préparer le code source, j'utiliserai la commande echo pour me connecter au compilateur avec | et le saisirai directement comme entrée standard. Puisque le compilateur ne peut pas déterminer le type de fichier d'entrée par l'extension du fichier d'entrée, utilisez l'option de ligne de commande `-xc 'en notifiant qu'il s'agit d'une source C.

$ echo 'int main(){}' | gcc -xc - && ls -l a.out
-rwxr-xr-x 1 fujita fujita 16344 Jul  8 22:31 a.out
$ 

Un fichier exécutable d'environ 16 Ko a été créé. Lorsque je transmets le a.out généré à la commande readelf

$ readelf -S a.out
There are 28 section headers, starting at offset 0x38d8:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .interp           PROGBITS         00000000000002a8  000002a8
       000000000000001c  0000000000000000   A       0     0     1
  [ 2] .note.gnu.build-i NOTE             00000000000002c4  000002c4
       0000000000000024  0000000000000000   A       0     0     4
  [ 3] .note.ABI-tag     NOTE             00000000000002e8  000002e8
       0000000000000020  0000000000000000   A       0     0     4
  [ 4] .gnu.hash         GNU_HASH         0000000000000308  00000308
       0000000000000024  0000000000000000   A       5     0     8
  [ 5] .dynsym           DYNSYM           0000000000000330  00000330
       0000000000000090  0000000000000018   A       6     1     8
  [ 6] .dynstr           STRTAB           00000000000003c0  000003c0
       000000000000007d  0000000000000000   A       0     0     1
  [ 7] .gnu.version      VERSYM           000000000000043e  0000043e
       000000000000000c  0000000000000002   A       5     0     2
  [ 8] .gnu.version_r    VERNEED          0000000000000450  00000450
       0000000000000020  0000000000000000   A       6     1     8
  [ 9] .rela.dyn         RELA             0000000000000470  00000470
       00000000000000c0  0000000000000018   A       5     0     8
  [10] .init             PROGBITS         0000000000001000  00001000
       0000000000000017  0000000000000000  AX       0     0     4
  [11] .plt              PROGBITS         0000000000001020  00001020
       0000000000000010  0000000000000010  AX       0     0     16
  [12] .plt.got          PROGBITS         0000000000001030  00001030
       0000000000000008  0000000000000008  AX       0     0     8
  [13] .text             PROGBITS         0000000000001040  00001040
       0000000000000151  0000000000000000  AX       0     0     16
  [14] .fini             PROGBITS         0000000000001194  00001194
       0000000000000009  0000000000000000  AX       0     0     4
  [15] .rodata           PROGBITS         0000000000002000  00002000
       0000000000000004  0000000000000004  AM       0     0     4
  [16] .eh_frame_hdr     PROGBITS         0000000000002004  00002004
       000000000000003c  0000000000000000   A       0     0     4
  [17] .eh_frame         PROGBITS         0000000000002040  00002040
       0000000000000108  0000000000000000   A       0     0     8
  [18] .init_array       INIT_ARRAY       0000000000003df0  00002df0
       0000000000000008  0000000000000008  WA       0     0     8
  [19] .fini_array       FINI_ARRAY       0000000000003df8  00002df8
       0000000000000008  0000000000000008  WA       0     0     8
  [20] .dynamic          DYNAMIC          0000000000003e00  00002e00
       00000000000001c0  0000000000000010  WA       6     0     8
  [21] .got              PROGBITS         0000000000003fc0  00002fc0
       0000000000000040  0000000000000008  WA       0     0     8
  [22] .data             PROGBITS         0000000000004000  00003000
       0000000000000010  0000000000000000  WA       0     0     8
  [23] .bss              NOBITS           0000000000004010  00003010
       0000000000000008  0000000000000000  WA       0     0     1
  [24] .comment          PROGBITS         0000000000000000  00003010
       0000000000000023  0000000000000001  MS       0     0     1
  [25] .symtab           SYMTAB           0000000000000000  00003038
       00000000000005b8  0000000000000018          26    43     8
  [26] .strtab           STRTAB           0000000000000000  000035f0
       00000000000001e9  0000000000000000           0     0     1
  [27] .shstrtab         STRTAB           0000000000000000  000037d9
       00000000000000f9  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),
  l (large), p (processor specific)
$ 

Vous pouvez voir qu'il contient de nombreuses sections.

Essayez ensuite de compiler la source à 0 caractère. Utilisez / dev / null au lieu du fichier source, qui renvoie toujours un EOF lors de la lecture. Vous n'avez même pas besoin d'un démarrage pour appeler main, alors spécifiez l'option \ -nostdlib'. Si vous utilisez ceci, l'adresse de début d'exécution du programme par défaut _start ne sera pas trouvée et l'éditeur de liens vous en avertira, utilisez donc l'option -Wl, -e0 'pour spécifier 0 comme adresse de début d'exécution temporaire.

$ gcc -xc /dev/null -nostdlib -Wl,-e0 && ls -l a.out
-rwxr-xr-x 1 fujita fujita 9512 Jul  8 22:35 a.out
$ 

Un fichier exécutable d'environ 9,5 Ko a été créé. Si vous transmettez cela à la commande readelf

$ readelf -S a.out
There are 12 section headers, starting at offset 0x2228:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .interp           PROGBITS         0000000000000200  00000200
       000000000000001c  0000000000000000   A       0     0     1
  [ 2] .note.gnu.build-i NOTE             000000000000021c  0000021c
       0000000000000024  0000000000000000   A       0     0     4
  [ 3] .gnu.hash         GNU_HASH         0000000000000240  00000240
       000000000000001c  0000000000000000   A       4     0     8
  [ 4] .dynsym           DYNSYM           0000000000000260  00000260
       0000000000000018  0000000000000018   A       5     1     8
  [ 5] .dynstr           STRTAB           0000000000000278  00000278
       0000000000000001  0000000000000000   A       0     0     1
  [ 6] .eh_frame         PROGBITS         0000000000001000  00001000
       0000000000000000  0000000000000000   A       0     0     8
  [ 7] .dynamic          DYNAMIC          0000000000001f20  00001f20
       00000000000000e0  0000000000000010  WA       5     0     8
  [ 8] .comment          PROGBITS         0000000000000000  00002000
       0000000000000023  0000000000000001  MS       0     0     1
  [ 9] .symtab           SYMTAB           0000000000000000  00002028
       0000000000000168  0000000000000018          10    12     8
  [10] .strtab           STRTAB           0000000000000000  00002190
       0000000000000027  0000000000000000           0     0     1
  [11] .shstrtab         STRTAB           0000000000000000  000021b7
       000000000000006c  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),
  l (large), p (processor specific)
$ 

Vous pouvez voir que l'exécutable contient toujours plusieurs sections, bien que moins que le plus petit exemple principal.

Certaines options de ligne de commande de l'éditeur de liens spécifient l'adresse de départ de la section. Essayons de spécifier la valeur 0x123456789abcdef0 comme adresse de début de la section .text qui n'est pas incluse dans la liste des sections ci-dessus. L'option de ligne de commande suivante `-Wl, -Ttext = 0x123456789abcdef0 'est applicable.

$ gcc -xc /dev/null -nostdlib -Wl,-e0 -Wl,-Ttext=0x123456789abcdef0 && ls -l a.out
-rwxr-xr-x 1 fujita fujita 9512 Jul  8 22:41 a.out
$ readelf -S a.out
There are 12 section headers, starting at offset 0x2228:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .interp           PROGBITS         0000000000000238  00000238
       000000000000001c  0000000000000000   A       0     0     1
  [ 2] .note.gnu.build-i NOTE             0000000000000254  00000254
       0000000000000024  0000000000000000   A       0     0     4
  [ 3] .gnu.hash         GNU_HASH         0000000000000278  00000278
       000000000000001c  0000000000000000   A       4     0     8
  [ 4] .dynsym           DYNSYM           0000000000000298  00000298
       0000000000000018  0000000000000018   A       5     1     8
  [ 5] .dynstr           STRTAB           00000000000002b0  000002b0
       0000000000000001  0000000000000000   A       0     0     1
  [ 6] .eh_frame         PROGBITS         123456789abce000  00001000
       0000000000000000  0000000000000000   A       0     0     8
  [ 7] .dynamic          DYNAMIC          123456789abcef20  00001f20
       00000000000000e0  0000000000000010  WA       5     0     8
  [ 8] .comment          PROGBITS         0000000000000000  00002000
       0000000000000023  0000000000000001  MS       0     0     1
  [ 9] .symtab           SYMTAB           0000000000000000  00002028
       0000000000000168  0000000000000018          10    12     8
  [10] .strtab           STRTAB           0000000000000000  00002190
       0000000000000027  0000000000000000           0     0     1
  [11] .shstrtab         STRTAB           0000000000000000  000021b7
       000000000000006c  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),
  l (large), p (processor specific)
$ 

Je ne sais pas quelle est la section, mais vous pouvez voir que la section .eh_frame est affectée et a une adresse similaire. Il semble que les 16 bits inférieurs de l'adresse, qui est la valeur de l'élément Offset, sont alignés de «def0» à «e000». Ces informations de section doivent être incluses dans le fichier exécutable a.out. Si vous essayez un vidage hexadécimal avec la commande hexdump

$ hexdump -C a.out | head -24
00000000  7f 45 4c 46 02 01 01 00  00 00 00 00 00 00 00 00  |.ELF............|
00000010  03 00 3e 00 01 00 00 00  00 00 00 00 00 00 00 00  |..>.............|
00000020  40 00 00 00 00 00 00 00  28 22 00 00 00 00 00 00  |@.......("......|
00000030  00 00 00 00 40 00 38 00  09 00 40 00 0c 00 0b 00  |[email protected]...@.....|
00000040  06 00 00 00 04 00 00 00  40 00 00 00 00 00 00 00  |........@.......|
00000050  40 00 00 00 00 00 00 00  40 00 00 00 00 00 00 00  |@.......@.......|
00000060  f8 01 00 00 00 00 00 00  f8 01 00 00 00 00 00 00  |................|
00000070  08 00 00 00 00 00 00 00  03 00 00 00 04 00 00 00  |................|
00000080  38 02 00 00 00 00 00 00  38 02 00 00 00 00 00 00  |8.......8.......|
00000090  38 02 00 00 00 00 00 00  1c 00 00 00 00 00 00 00  |8...............|
000000a0  1c 00 00 00 00 00 00 00  01 00 00 00 00 00 00 00  |................|
000000b0  01 00 00 00 04 00 00 00  00 00 00 00 00 00 00 00  |................|
000000c0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
000000d0  b1 02 00 00 00 00 00 00  b1 02 00 00 00 00 00 00  |................|
000000e0  00 10 00 00 00 00 00 00  01 00 00 00 04 00 00 00  |................|
000000f0  00 10 00 00 00 00 00 00  00 e0 bc 9a 78 56 34 12  |............xV4.|
00000100  00 e0 bc 9a 78 56 34 12  00 00 00 00 00 00 00 00  |....xV4.........|
00000110  00 00 00 00 00 00 00 00  00 10 00 00 00 00 00 00  |................|
00000120  01 00 00 00 06 00 00 00  20 1f 00 00 00 00 00 00  |........ .......|
00000130  20 ef bc 9a 78 56 34 12  20 ef bc 9a 78 56 34 12  | ...xV4. ...xV4.|
00000140  e0 00 00 00 00 00 00 00  e0 00 00 00 00 00 00 00  |................|
00000150  00 10 00 00 00 00 00 00  02 00 00 00 06 00 00 00  |................|
00000160  20 1f 00 00 00 00 00 00  20 ef bc 9a 78 56 34 12  | ....... ...xV4.|
00000170  20 ef bc 9a 78 56 34 12  e0 00 00 00 00 00 00 00  | ...xV4.........|
$ 

Vous pouvez voir que 8 octets de l'adresse 000000f8, qui semble être l'adresse de début de .eh_frame, sont stockés dans Little Endian. En utilisant \ -Wl, -Ttext = 0xXXXXXXXXXXXX0000 ', en supposant que les 16 bits inférieurs sont ignorés pour éviter d'aligner les adresses, toute chaîne d'octets de l'adresse 000000fa est incorporée dans le fichier d'exécution en tant qu'adresse de .eh_frame. Je pense que je peux le faire. Comme test, spécifiez \ -Wl, -Ttext = 0x2504890000 'et placez 89 04 25 à partir de l'adresse 000000fa. Spécifiez l'adresse 000000fa comme adresse d'exécution avec \ -e0xfa ', et spécifiez également \ -zexecstack', ce qui permet l'exécution dans des zones autres que la zone de code.

$ gcc -xc /dev/null -nostdlib -Wl,-e0xfa -Wl,-Ttext=0x2504890000 -zexecstack && ls -l a.out
-rwxr-xr-x 1 fujita fujita 9512 Jul  8 22:49 a.out
$ ./a.out
Segmentation fault (core dumped)
$ 

J'ai pu confirmer que segfo est généré en exécutant le a.out généré. Utilisons la commande objdump pour voir les instructions intégrées dans le fichier exécutable à partir de l'adresse 000000fa.

$ objdump -D -bbinary -mi386 -Mintel,x86-64 --start-address=0xfa a.out | head -8

a.out:     file format binary


Disassembly of section .data:

000000fa <.data+0xfa>:
      fa:	89 04 25 00 00 00 00 	mov    DWORD PTR ds:0x0,eax
$ 

Le contenu est d'écrire la valeur du registre EAX à l'adresse 0. En essayant de faire cela, vous pouvez voir que la protection du système d'exploitation est terminée dans Segfo.

Avec ce qui précède, nous avons obtenu le titre "Segfo avec 0 caractères avec gcc". De plus, il est possible d'émettre une erreur autre que Segfo en concevant le contenu de \ `-Wl, -Ttext = 0xXXXXXXXXXXXX0000 '.

Appelez l'interruption logicielle INT3 pour le débogage


$ gcc -xc /dev/null -nostdlib -Wl,-e0xfa -Wl,-Ttext=0xcc0000 -zexecstack && ls -l a.out
-rwxr-xr-x 1 fujita fujita 9512 Jul  8 22:55 a.out
$ objdump -D -bbinary -mi386 -Mintel,x86-64 --start-address=0xfa a.out | head -8

a.out:     file format binary


Disassembly of section .data:

000000fa <.data+0xfa>:
      fa:	cc                   	int3   
$ ./a.out
Trace/breakpoint trap (core dumped)
$ 

Exécuter UD2 réservé comme instruction illégale


$ gcc -xc /dev/null -nostdlib -Wl,-e0xfa -Wl,-Ttext=0x0b0f0000 -zexecstack && ls -l a.out
-rwxr-xr-x 1 fujita fujita 9512 Jul  8 22:56 a.out
$ objdump -D -bbinary -mi386 -Mintel,x86-64 --start-address=0xfa a.out | head -8

a.out:     file format binary


Disassembly of section .data:

000000fa <.data+0xfa>:
      fa:	0f 0b                	ud2    
$ ./a.out
Illegal instruction (core dumped)
$ 

Divisez la valeur du registre AX par le contenu de l'adresse 0x100 où 0 est stocké et générez une erreur de division 0.


$ gcc -xc /dev/null -nostdlib -Wl,-e0xfa -Wl,-Ttext=0x35f60000 -zexecstack && ls -l a.out
-rwxr-xr-x 1 fujita fujita 9512 Jul  8 22:58 a.out
$ objdump -D -bbinary -mi386 -Mintel,x86-64 --start-address=0xfa a.out | head -9

a.out:     file format binary


Disassembly of section .data:

000000fa <.data+0xfa>:
      fa:	f6 35 00 00 00 00    	div    BYTE PTR [rip+0x0]        # 0x100
     100:	00 00                	add    BYTE PTR [rax],al
$ ./a.out
Floating point exception (core dumped)
$ 

C'est amusant d'essayer diverses choses.

en conclusion

La fin.

Recommended Posts

Segfo avec 0 caractères avec gcc
Segfo Python avec 33 caractères
Segfo avec 16 caractères en langage C
[Python] Tri Starlin à une ligne avec 50 caractères
[Note] Les caractères japonais sont déformés avec atom-runner
Sortir les caractères de couleur en joli avec python
Reconnaissance faciale des personnages d'anime avec Keras
Compter le nombre de caractères avec écho