Discussion :

[The Hidden Ghost]

Salut mes amies
Oui, ça fait un bail que j'ai une question qui semble très difficile en ce qui concerne la programmation en "Binary Code" (le codage en binaire). Est-qu'il est possible de programmer en utilisant juste le "zéro" et "le un" (1s and 0s) ? Est-qu'il est possible de faire ça au sein du 8086 processeur ?!. Si oui, j'espère que vous donnez un livre qui met l'accent à ce sujet, car j'ai cherché plusieurs fois dans Google mais j'ai rien trouvé !
Une autre question qui s'impose c'est: puis-je ignorer les librairies de linkage dynamiques (Dynamic Linking Library) en windows lors de la programmation en assembleur par exemple ? je sais que les applications qu'on programme doivent être attachées avec ces librairies au cours de la production du exécutable. Mais y-a-t-elle une méthode pour créer un exécutable libre qui n'a pas besoin d'APIs(les fonctions Win32 APIs) ? - Un exécutable 32-bit et n'on pas 16-bit -.
J'ai déjà posé ma question dans un forum qui s'appelle "rohitab.com" et voici le lien: http://www.rohitab.com/discuss/topic...ing-win32-api/, mais j'ai pas trouvé la bonne réponse jusqu'à présent. Voici la plus proche réponse:

Assuming Windows, the majority of the user API provided just set up arguments and then commit to a syscall.

So basically:

Push arguments onto stack
Blah, blah set up registers with required values
Syscall on x86: Move the system call number into edx and call some syscall stub or whatever (example below) that deals with far jumps and kernel stuff
Syscall on x64 with a 32-bit app (32-bit app will use WoW64): Same idea, move your stuff into the correct registers for x64 and call the fs segment at 0xC0. This will in turn deal with the WoW32 reserved to save the 32-bit state (see example 2).

Example 1:

Code :

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

1
2
3
4
 
mov eax, 0x58
mov edx, offset SharedUserData!SystemCallStub 
call dword ptr [edx]

Example 2:

Code :

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

1
2
3
4
5
 
mov eax, 0x1002; Index here (This is MessageBeep)
mov ecx, 0; Or xor it, whatever
lea edx, [esp+4]; Load edx with the value here
call dword ptr fs:[0C0h]; Jump to transparency layer and get your beep

And you're basically done after that. Assuming you set everything up correctly, you can wrap this into a function and you now have an API that you can call without requiring including windows headers or libraries.

Keep in mind, many of the usermode API do heavy processing before the kernel jump via syscall, and not every API requires a syscall.

Cette personne là a eu quelques informations à propos ce sujet, mais il n'a ma donnée pas des ressources qui m'intéressent
Est-qu'ils y a des tutoriels qui touchent ce phénomène autour d'internet ?

Merci en avance !

[Kannagi]

Alors pour ta première question je me demande si tu sais c'est quoi l'assembleur...
L'assembleur est grosso modo un ensemble de mnémonique qui permet de retenir plus facilement que le code binaire , donc les instruction possède leur opcode et donc il suffit juste de lire n’importe quel doc intel qui met a mon avis l'opcode des instruction et leur cycle.
D'ailleurs ça arrivait a l'époque que certain programmeur assemble leur programme a la main , donc remplacé toutes les mnémonique , saut ect par le codage binaire , bah après si tu veux t’amusè a le faire n'importe quel éditeur hexadécimal suffira.

Je connais pas le format PE en particulier mais oui tu peux créer un exécutable Windows sans link , après sans link le résultat et limité vu que on est obligé de passer par OS pour un programme un minima sérieux.
Après la méthode la seule que je connaisse c'est de créer le format PE a la main, je l'avais vu pour ceux qui voulait créer un programme minimaliste.

[chrtophe]

C'est techniquement possible mais il faut être fou. Il faut calculer toutes les adresses à la main.

[The Hidden Ghost]

Alors pour ta première question je me demande si tu sais c'est quoi l'assembleur...
L'assembleur est grosso modo un ensemble de mnémonique qui permet de retenir plus facilement que le code binaire , donc les instruction possède leur opcode et donc il suffit juste de lire n’importe quel doc intel qui met a mon avis l'opcode des instruction et leur cycle.
D'ailleurs ça arrivait a l'époque que certain programmeur assemble leur programme a la main , donc remplacé toutes les mnémonique , saut ect par le codage binaire , bah après si tu veux t’amusè a le faire n'importe quel éditeur hexadécimal suffira.

Je connais pas le format PE en particulier mais oui tu peux créer un exécutable Windows sans link , après sans link le résultat et limité vu que on est obligé de passer par OS pour un programme un minima sérieux.
Après la méthode la seule que je connaisse c'est de créer le format PE a la main, je l'avais vu pour ceux qui voulait créer un programme minimaliste.

Qui, je sais qu'est que l'assembleur, j'ai déjà programmé quelques programmes avec cet langage et aussi je sais qu'est que l'opcode (Operation Code). En ce qui concerne ta réponse, j'ai bien compris ces choses, car j’étais l'un de ceux qu'ont une main dans ce domaine, j'ai programmé des applications en binaire (applications 16-bit). Il est facile de faire ça, il suffit de retenir le code binaire de chaque instruction est finalement il suffit de sauvegarder le fichier comme un exécutable, précisément à l’extension "*.COM". Mais j'ai pas besoin de ça, je cherche une méthode qui me permette à créer un exécutable 32-bit sans une intégration des APIs

Peux-tu me donner une explication précise ou un livre qui touche ce sujet ?

[The Hidden Ghost]

C'est techniquement possible mais il faut être fou. Il faut calculer toutes les adresses à la main.

Peux-tu m'expliquer ou bien une référence qui explique cela ?

[Kannagi]

il suffit de sauvegarder le fichier comme un exécutable, précisément à l’extension "*.COM"

Pas exactement vu que pas tout le monde ici est sur Windows donc un .com ne marchera pas sur un linux.

Sinon je ne te suis pas :

Mais j'ai pas besoin de ça, je cherche une méthode qui me permette à créer un exécutable 32-bit sans une intégration des APIs

ça veut dire ? tu considère un éditeur hexadécimal comme une API ?

[The Hidden Ghost]

Non, c'est pas ça, je parle de Windows et non pas Linux(L'extension ".COM" n'est pas supportée dans Linux )
Aussi, il y a une grande différence entre l'hex-éditeur et l'APIs. Je pense que tu n'as pas compris mon opinion jusqu'à présent

Ok, je veux créer un programme 32-bit(PE) en utilisant l'assembleur ou le C sans l'utilisation du DLL ou les librairies standards ou les fichiers headers.
Un exécutable libre.

[Kannagi]

Ok, je veux créer un programme 32-bit(PE) en utilisant l'assembleur ou le C sans l'utilisation du DLL ou les librairies standards ou les fichiers headers.

Ok et donc qu'est qui t'en empêche ?
Certe peut etre que sur gcc ou mingw il link une librairie par défaut alors soit il est surement possible en configurant le compilateur de mettre aucun link , soit tu créer le format éxécutable a la la main et la t'es sur de faire aucun link.

[The Hidden Ghost]

OK, je vais expliquer ma problème d'une autre manière !
Autrement dit, j'ai crée mon propre programme qui sert à construire un exécutable depuis un code binaire(Binary Code) comme le montre l'image ci-dessous:



Par exemple, si je veux créer un programme, j'ai besoin de comprendre le code binaire de chaque registre du processeur:

Code :

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

1
2
3
4
5
6
7
8
9
 
00000000 ==> ax
01100000 ==>  bx
00100000 ==> cx
01000000 ==> dx
10000000 ==> sp
10100000 ==> bp
11000000 ==> si
11100000 ==> di

Après ça, j'ai le droit de faire n'importe quoi en utilisant cet concept d'interruptions et d'instructions.

Code :

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

1
2
 
MOV ==> B8 ==> 10111000

Voici un exemple d'un programme en binaire que j'ai écrit, il sert à afficher la lettre 'A':

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
21
22
23
24
25
26
27
28
29
30
31
32
 
;;;;; Show 'A' on Screen In Binary Code ;;;;;;;
10111000
00010011
00000000
11001101
00010000
10110100
00000010
10110010
01000001
11001101
00100001
10111000
00000000
00000000
11001101
00010110
11001101
00100000
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;; The Same Program in Assembly Language ;;;;;;;;;
 
MOV AX,13h ; VGA MODE
INT 10h ; bios interrupt
MOV AH,02h ; write a character on screen
MOV AL,41h ; write 'A' on screen
INT 21h ; Dos Interrupt
XOR AX,AX ; AX = 0
INT 16h , Keyboard interrupt
INT 20h ; return 0 - end of program -
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Voici le code source en C:

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
#include <windows.h>
#include "Code.c"
#include "defined.h"
char GetMachineCode[2048];
char Little_Trick[2];
int i = 0;
char *_8digit, _Bin[7];
FILE *_export_exe, *_bin_source_code;
char *registers =  "00000000 ax => MOV AX,something => B8 something AX\n"
				   "00100000 cx => MOV CX,something => B9 something CX\n"
				   "01000000 dx => MOV DX,something => BA something DX\n"
				   "01100000 bx => MOV BX,something => BB something BX\n"
				   "10000000 sp\n"
				   "10100000 bp\n"
				   "11000000 si\n"
				   "11100000 di\n";
char *BIN_EXAMPLE = "\n10111000\n" // MOV B8
					"00010011\n" // 13h
					"00000000\n" // AX register
					"11001101\n" // INT
					"00010000\n" // 10h
					"10110100\n" // MOV B4
					"00000010\n" // 02h write a character on screen
					"10110010\n" // MOV B2
					"01000001\n" // A
					"11001101\n" // INT
					"00100001\n" // 21
					"10111000\n" // MOV B8
					"00000000\n" // 0
					"00000000\n" // AX register
					"11001101\n" // INT
					"00010110\n" // 16
					"11001101\n" // INT
					"00100000\n" // 20
					"\nshow 'A' on screen\n"
					"\nCreated By :\nThe Hidden Ghost\n";
 
/* Display A Character On Screen in Assembly Code :
 
		   MOV AX,13h
		   INT 10h
		   MOV AH,02h
		   MOV AL,41h
		   INT 21h
		   MOV AX,00h
		   INT 16h
		   INT 20h
This is an example to show the 'A' on FullScreen Mode */
 
LPSTR TheHiddenGhost	  =		"This litte program is\n"
								   "designed By :\n\n"
								   "The Hidden Ghost\n\n"
								   "The prominent aim\n"
								   "for this application is\n"
								   "to show how to build\n"
								   "an executable file  \n"
								   "without any compiler \n"
								   "or any assembler...\n\n"
								   "All Rights Reserved\n\n"
								   "By : Hamza Qdider\n\n";
 
LRESULT CALLBACK GENERATORDLG( HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam )
{
		switch( umsg )
		{
			   case WM_COMMAND:
					{
						 switch( LOWORD( wparam ) )
						 {
								 case GEN_BUTTON:
 
									  GetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( LARGE_EDIT_BOX ),GetMachineCode,sizeof( GetMachineCode ) );
 
									  if( GetMachineCode[1] == 0 ) {
 
										 MessageBoxA( hwnd,"There are no Machine Codes in the TextBox Sir !!!","An Error Is Occured !",MB_OK | MB_ICONERROR );
										 return 0;
									  }
 
									  MessageBoxA( hwnd,GetMachineCode,"Your Machine Code Is : ",MB_OK );
 
									 _export_exe = fopen( "Generated.exe","wb" );
									 _bin_source_code = fopen("Generated.bin","w");
 
									_8digit = &GetMachineCode;
 
									  while( *_8digit++ )
									  {
											 if( *_8digit != '\n' && *( _8digit - 1 ) != ' ' ) {
 
											  if( *( _8digit - 1 ) == '\n' )
													*_8digit++;
 
											 _Bin[i++] = *( _8digit - 1 );
 
											  if( i == 8 ) {
												  i = 0;
												  fprintf(_export_exe,"%c",__BINARY( _Bin ) );
												  fprintf(_bin_source_code,"%s\n",_Bin );
 
											 }
										 }
									  }
 
									  SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_STEPS ),"Checking MachineCode." );
									  Sleep( 900 );
									  SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_STEPS ),"Checking Machine Code.." );
									  Sleep( 900 );
									  SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_STEPS ),"Checking Machine Code..." );
 
									  Sleep( 1000 );
 
									  SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_STEPS ),"Generating Executable File." );
									  Sleep( 900 );
									  SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_STEPS ),"Generating Executable File.." );
									  Sleep( 900 );
									  SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_STEPS ),"Generating Executable File..." );
 
									  Sleep( 1000 );
 
									  SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_STEPS ),"Executable is Generated ... Let's Go !!!" );
 
									  fclose( _export_exe );
									  fclose( _bin_source_code );
 
									  break;
 
							  case CLR_BUTTON:
 
								   SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( LARGE_EDIT_BOX ),"" );
 
								   SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_EXAMPLE ),"PUT YOUR MACHINE CODE HERE, BUT EACH LINE MUST CONTAIN JUST 8 NUMBERS NO MORE.( 0's AND 1's)" );
 
								   SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_STEPS ),"" );
 
								   break;
 
							  case REG_BUTTON:
 
								   MessageBoxA( hwnd,registers,"Registers in Machine Code : ",MB_OK | MB_ICONINFORMATION );
 
								   break;
 
							  case EXM_BUTTON:
 
								   SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_EXAMPLE ),BIN_EXAMPLE );
 
								   break;
 
							  case ABOUT_BUTTON:
 
								   SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_EXAMPLE ),TheHiddenGhost );
 
								   break;
 
						 }		
 
					}
 
					break;
 
			   case WM_CLOSE:
 
					EndDialog( hwnd,0 );
					break;
 
			   default:
 
						GetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( LARGE_EDIT_BOX ),Little_Trick,sizeof( Little_Trick ) );
 
						if( Little_Trick[0] != 0 )
 
						SetDlgItemText( hwnd,( int ) MAKEINTRESOURCE( SW_EXAMPLE ),"" );
 
						break;
		}
		return 0;
}
 
INT WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int ShowCmd )
{
	DialogBoxParam( hInstance,MAKEINTRESOURCE( GEN_DLG ),0,( DLGPROC )GENERATORDLG,0 );
	return 0;
}

MachineCode.c

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#include <stdio.h>
int power(int n,int pow);
int To_Dec(char binary[]);
int strlength(char *src);
int strlength(char *src)
{
	int pcount = 0;
	while( pcount[src] != '\0' )
	pcount++;
	return pcount;
}
int power(int n,int pow)
{
	int p = 1;
	int ret = 1;
	if(pow == 0)
	   return 1;
	else{
	for(p;p<=pow;p++)
	 ret = ret * n;
}
return ret;
}
int __BINARY(char binary[])
{
	int len = strlength(binary);
	int dec = 0;
	int i = 0;
	while(i<len)
	{
	if(binary[i] == '0')i++;
	else {
	dec += 1 * power(2,len-(i+1));
	i++;
	}
}
return dec;
}

Cette méthode là a eu une restriction en ce qui concerne le mode protégé, vous connaissez bien que les interruptions en mode protégé ne sont pas accessibles donc je ne peux pas faire ça si je veux créer un exécutable 32-bit(cette méthode est spécifiquement désirée pour les applications 16-bit ).

Voici l'article originale: http://www.rohitab.com/discuss/topic...#entry10090168

Voici mon code source:

Machine Code Generator V2.zip

[Kannagi]

je suis désolé mais je ne vois toujours pas ou tu veux en venir (peut être que c'est moi qui comprend pas) , donc j’espère que un autre membre te répondra s'il vois ce que tu souhaite faire exactement.

[The Hidden Ghost]

OK, je suis désolé si j'étais méchant

[Obsidian]

Salut mes amies
Oui, ça fait un bail que j'ai une question qui semble très difficile en ce qui concerne la programmation en "Binary Code" (le codage en binaire). Est-qu'il est possible de programmer en utilisant juste le "zéro" et "le un" (1s and 0s) ? Est-qu'il est possible de faire ça au sein du 8086 processeur ?!. Si oui, j'espère que vous donnez un livre qui met l'accent à ce sujet, car j'ai cherché plusieurs fois dans Google mais j'ai rien trouvé !

Il est possible de faire cela avec TOUS les micro-processeurs. Le binaire, tout comme l'hexadécimal, n'est qu'une façon de représenter les nombres. On a choisi l'hexadécimal parce que c'est le plus pratique aujourd'hui, mais tu pourrais tout aussi bien les écrire en chiffres romains, par exemple.

In fine, tous ces nombres seront physiquement représentés en binaire dans le micro-processeur puisqu'il s'agit de lignes électroniques parallèles sur lesquelles une tension électrique est présente (« 1 ») ou pas (« 0 »). Tu peux donc tout-à-fait programmer avec un flot de 0 et de 1 (même si c'est très compliqué) mais il faudra de toutes façons les regrouper en paquet de 8 bits minimum pour les transmettre à ta RAM, d'où ils pourront être lus par ton micro-processeur.

Une autre question qui s'impose c'est: puis-je ignorer les librairies de linkage dynamiques (Dynamic Linking Library) en windows lors de la programmation en assembleur par exemple ? je sais que les applications qu'on programme doivent être attachées avec ces librairies au cours de la production du exécutable. Mais y-a-t-elle une méthode pour créer un exécutable libre qui n'a pas besoin d'APIs(les fonctions Win32 APIs) ? - Un exécutable 32-bit et n'on pas 16-bit -. J'ai déjà posé ma question dans un forum qui s'appelle "rohitab.com" et voici le lien: http://www.rohitab.com/discuss/topic...ing-win32-api/, mais j'ai pas trouvé la bonne réponse jusqu'à présent. Voici la plus proche réponse:

C'est possible également puisque ces bibliothèques dynamiques sont en fait des exécutables au même titre que le tien. Tu peux t'en tenir aux simples appels systèmes, par exemple. Seulement, par définition, l'environnement sera très limité et il sera difficile de communiquer pleinement avec l'extérieur. Mais ça reste possible.

Si tu veux demander à ton compilateur de le faire, il faut lui passer les bonnes options. Si tu veux générer cet exécutable toi-même, alors il faut faire le travail du linker et te promener dans les spécifications du format PE. Ce n'est pas forcément très difficile en soi, mais c'est très fouillis car c'est un format à tiroir : il y un entête qui contient (ou pas) un certain nombre de pointeurs vers une certain nombre de tables pointant elle-même vers un certain nombre de sections, et il y a différents offsets et RVA dans tous les sens, faisant tous référence à un point de départ différent. Par dur mais rébarbatif, donc.

[The Hidden Ghost]

Peux-tu me donner un exemple Monsieur ? Ou un lien qui explique ça ?
Avez-vous une idée en ce qui concerne le "syscall" et "l'index" ?

[The Hidden Ghost]

Quelques réponses ? :

[chrtophe]

Il faut que tu comprennes que l'assembleur a été créé pour éviter de devoir coder en binaire, et que le C a été créer pour éviter le codage en assembleur (en caricaturant un peu).

ça été crée à l'époque ou les processeurs étaient moins puissant que la calculette que j'utilisais il y a 25 ans. C'était déjà compliqué à l'époque, alors avec la complexité des CPUs actuels ...

Dans une instruction, tu as les 1ers bits qui correspondent à la commande (exemple mov) puis les bits suivants qui sont les paramètres (registre, adresse exemple eax,5), tu peux trouver cela dans la doc du CPU.

le nbre de bits de" commande" est variable je crois. Il te faut calculer toutes les adresses des variables à la main