Discussion :

[sambia39]

Bonsoir,

non, tu ne pourras pas l’exécuter sous Windows. Par ailleurs, ton programme va appeler des fonctions systèmes qui ne sont pas les même sous Linux et Windows. Par ailleurs la convention d'appel des fonctions est différente.

Par contre, si tu écrit un code en C, en utilisant les fonctions de la libc (comme fopen, fread, fwrite), et en recompilant ton code, il fonctionnera sur Windows et Linux (avec un programme exécutable différent par plateforme).

malloc existe sous Windows, fonctionnera pareil en externe (paramètres à fournir, paramètre retourné), mais pas pareil en interne. Tu as vu dans les posts que malloc sous Linux utilisait mmap et sbrk, ces fonctions n'existent pas sous Windows. Tout comme HeapAlloc, VirtualAlloc n’existe que sous Windows.

Non, il est tout à fait possible d'écrire du code assembleur sous GNU/Linux, Mac OS et le compiler pour qu'il soit exécutable sous le système d'exploitation Windows, il suffit juste de connaître le format PE de Windows (et notamment les ABI système de Windows) et ainsi écrire des instructions assembleur qui vont fonctionner sur le système Windows (voir exemple ci-dessous)
En revanche oui utilisée, le langage C permettra d'avoir le même code source fonctionnel sur différents systèmes et architecture.

Code asm :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
BITS 32
 
	extern _printf
	global _main
 
	section .data
 
Msg_x86_32: db 'Bonjour Windows 32 bits', 0xA, 0x13,0x0
Msg_x86_64: db 'Bonjour Windows 64 bits', 0xA, 0x13,0x0
 
 
	section .text
_main:
		push Msg_x86_32
		call _printf
		add esp, 0x4
		ret

Code compil Unix :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
labSec:DebugAsm_unix_pe MrDebugVirtual$ nasm -fWin32 source.asm -o source.obj 
labSec:DebugAsm_unix_pe MrDebugVirtual$ i686-w64-mingw32-gcc source.obj -o Deb.exe
labSec:DebugAsm_unix_pe MrDebugVirtual$ nasm -fWin32 source.asm -o source.obj 
labSec:DebugAsm_unix_pe MrDebugVirtual$ i686-w64-mingw32-gcc source.obj -o Deb.exe
labSec:DebugAsm_unix_pe MrDebugVirtual$ objdump -h Deb.exe
Deb.exe:	file format COFF-i386

Sections:
Idx Name          Size      Address          Type
  0 .text         00001224 0000000000401000 TEXT DATA 
  1 .data         00000060 0000000000403000 DATA 
  2 .rdata        00000430 0000000000404000 DATA 
  3 .bss          00000000 0000000000405000 BSS
  4 .idata        00000538 0000000000406000 DATA 
  5 .CRT          00000034 0000000000407000 DATA 
  6 .tls          00000020 0000000000408000 DATA 
  7 .debug_aranges 00000038 0000000000409000 DATA 
  8 .debug_info   00001b48 000000000040a000 DATA 
  9 .debug_abbrev 00000133 000000000040c000 DATA 
 10 .debug_line   00000349 000000000040d000 DATA 
 11 .debug_frame  00000038 000000000040e000 DATA 
 12 .debug_str    00000156 000000000040f000 DATA

Et dans Windows sous la console en obtient bien

Code cmd :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
C:\Users\WINLABSEC\Desktop\DebugAsm\Deb.exe
Bonjour Windows 32 bits
@

Autres points si en souhaite allouer de la mémoire sous Windows, autant utiliser directement ce que L'API mise a disposition HeapAlloc, GlobalAlloc etc.. seul différence entre HeapAlloc et malloc par exemple est que l'un est portable l'autre non.
À bientôt

[Christophe]

printf n'est pas une fonction système, mais une fonction libc. Donc à ce niveau, oui ça marchera.

Donc si tu utilises fopen pour ouvrir un fichier ça fonctionnera partout, mais pas si tu utilises CreateFile, qui est une fonction spécifique Windows, ton code ne sera compatible qu'avec Windows;

[sambia39]

printf n'est pas une fonction système, mais une fonction libc. Donc à ce niveau, oui ça marchera.

Donc si tu utilises fopen pour ouvrir un fichier ça fonctionnera partout, mais pas si tu utilises CreateFile, qui est une fonction spécifique Windows, ton code ne sera compatible qu'avec Windows;

Oui et je n'ai pas dit le contraire

Bonsoir,
Non, il est tout à fait possible d'écrire du code assembleur sous GNU/Linux, Mac OS et le compiler pour qu'il soit exécutable sous le système d'exploitation Windows, il suffit juste de connaître le format PE de Windows (et notamment les ABI système de Windows) et ainsi écrire des instructions assembleur qui vont fonctionner sur le système Windows (voir exemple ci-dessous)

Le but était de montrer quand pouvait écrire du code assembleur sous le système GNU/Linux, MAC Os X, FreeBSD ou UNIX le compiler sous ces derniers aux formats PE Windows (donc qu'il est question de format d'excutable) et le faire exécuter sous le système Windows. J'ai volontairement pris l'exemple du cas de la libc parce qu'il est portable, je peux faire de même en utilisant uniquement les appels système Windows (voir exemple ci-dessous)

Code asm :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
BITS 32
	global _main
	extern _MessageBoxA@16
	extern _ExitProcess@4
 
	section .data
Msg_x86_32_A: db ' Tiens une Fenêtre 32 bits Windows',0x0
Msg_x86_32_B: db ' Autre exemple ;)', 0x0
 
	section .text
_main:
	push 0x0 | 100h
	push Msg_x86_32_A
	push Msg_x86_32_B
	push 0x0
 
	call _MessageBoxA@16
	cmp eax, 0x7
	je _main
 
	push 0x0
	call _ExitProcess@4

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
labSec:DebugAsm_unix_pe MrDebugVirtual$ nasm -fWin32 source.asm -o source.obj 
labSec:DebugAsm_unix_pe MrDebugVirtual$ i686-w64-mingw32-gcc source.obj -o Deb.exe
labSec:DebugAsm_unix_pe MrDebugVirtual$ objdump -h Deb.exe
Deb.exe:	file format COFF-i386
Sections:
Idx Name          Size      Address          Type
  0 .text         00001244 0000000000401000 TEXT DATA 
  1 .data         0000007c 0000000000403000 DATA 
  2 .rdata        00000430 0000000000404000 DATA 
  3 .bss          00000000 0000000000405000 BSS
  4 .idata        00000580 0000000000406000 DATA 
  5 .CRT          00000034 0000000000407000 DATA 
  6 .tls          00000020 0000000000408000 DATA 
  7 .debug_aranges 00000038 0000000000409000 DATA 
  8 .debug_info   00001b48 000000000040a000 DATA 
  9 .debug_abbrev 00000133 000000000040c000 DATA 
 10 .debug_line   00000349 000000000040d000 DATA 
 11 .debug_frame  00000038 000000000040e000 DATA 
 12 .debug_str    00000156 000000000040f000 DATA

à bientôt

[Médinoc]

On peut cross-compiler un programme pour Windows depuis Linux (en utilisant MinGW), mais l'exécutable PE résultant ne pourra pas tourner nativement sous Linux.

Il pourra tourner dans WINE, par contre.