Discussion :

[matrob72]

Tout est dans le titre, quelqu’un connaitrait un logiciel qui permet de lire les fichier .lib ?
J’aimerais connaître un peu mieux comment sont fait les fonctions/macro de base dans masm comme par exemple la fonction Sleep. (Dont, je n’ai pu remonter que jusqu’à son prototype)

[chrtophe]

Un fichier .lib sert normalement au linker, Il contient une table de points d'entrées d'après ce que j'ai compris, pas de code.

[matrob72]

Oui, je le sais, mais je voudrais savoir les besoin d’une fonction pour fonctionner.
En exemple, quelqu’un saurait comment est fait la macro ´inkey’ ?
(Sans appel de bibliothèque)

[Invité]

Le fichier LIB ne te renseignera probablement pas sur la manière de commander une API Windows. Le fichier .LIB gère les liens en direction de la DLL qui contient la fonction concernée. Si tu veux savoir comment commander une API déterminée, il faut consulter la documentation Microsoft.
Pour la fonction Sleep, par exemple, tape « msdn sleep » sur Google. Tu vas trouver tout ce qu’il faut, à savoir notamment que ladite fonction reçoit un paramètre Dword qui contient le nombre de millisecondes.
Exemple de codage d’un appel à cette fonction dans un programme en assembleur sous Masm 32 bits :
invoke Sleep, eax (ici, le registre eax contient le nombre de millisecondes)
Note bien que Inkey n’est ni une instruction du processeur, ni une API Windows. Je sais, en revanche, que ça existe en Basic et en Visual Basic. Mais c’est un peu hors sujet sur ce forum.

[matrob72]

Réellement, je veux pas commander les API Windows mais savoir comment sont-elles créées. (Comment les créer seulement avec des instructions de base)
Comment est faite la fonction Sleep ? où se trouve sa fonction ?
Une autre question, que veut dire STDCALL dans : Sleep PROTO STDCALL :DWORD ? (Comment est-il interprété?)
Pour information, 'inkey' existe bien sur masm dans macro.asm. (qui sert à afficher du texte et à attendre une touche)

[chrtophe]

Tu veux étudier le codes des fonctions ?

[matrob72]

Oui, c’est ça. Mais j’en ai trouvé que très peu... Alors où les trouver ...?
Je pensais trouver une piste dans les fichiers lib.

[Invité]

Je n’ai jamais eu la curiosité de me pencher sur le code des API. La seule fois que j’ai tenté ça avec un désassembleur, j’ai lu quelque chose d’assez touffu. L’assembleur sans la présence de commentaires détaillés et de notation symbolique est quasiment incompréhensible. C’est également valable avec les autres langages. Là où je suis en ce moment, je n’ai pas d’outils sous la main et ne peux te proposer une méthode. Essaie toutefois avec l’excellent désassembleur OllyDbg, si tu t’en sens le courage (il est gratuit.) Mais, ce n’est pas dépourvu de risques.
Voici comment se présente un programme assembleur en MASM:

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
.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\kernel32.lib
include \masm32\include\user32.inc
includelib \masm32\lib\user32.lib
 
.data
…
 
.code
start:
…
end start

Pour chaque DLL (ici, il n’y a que Kernel32 et User32), tu as un fichier .LIB et un fichier .INC. Par exemple, le fichier Kernel32.inc contient la déclaration Sleep PROTO STDCALL WORD que tu as remarquée. Ça t’évite de faire cette déclaration toi-même.
Il s’agit d’un prototypage, lequel permet de tester les appels INVOKE à la fonction Sleep dans ton programme et de s’assurer qu’ils contiennent le bon nombre de paramètres (un seul, dans ce cas.) De la sorte, si une erreur de paramétrage est détectée, elle est détectée au moment de l’assemblage et non au moment du lancement du programme qui peut provoquer des dégâts par erreur d’empilage. Note également que la déclaration STDCALL n’est pas obligatoire dans un PROTO.

S’agissant enfin de la fonction INKEY, je te confirme qu’elle n’existe ni dans le langage du processeur, ni dans Windows. Il s’agit d’une macro qui a été implémentée dans Macro.asm, effectivement. Cette macro appelle une fonction wait_key qui est dans un fichier LIB. En fait, Macro.asm est un des innombrables outils de l’ahurissant SDK Masm 32 conçu par Steve Hutcheson aidé en cela par quelques collaborations de poids. Mais ça n’a rien à voir avec Microsoft ou Intel.

Je reviendrai sur ces différents points lorsque je retournerai à la civilisation en début de semaine prochaine.

[matrob72]

Très intéressant ce que tu dis Asmou. J'ai du coup regardé le débogueur ollydbg qui est assez compliqué à comprendre mais après quelques jours, j'ai à peu près compris son fonctionnement. J'ai essayé du coup de décortiquer la procédure Sleep:

Code :

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

1
2
3
4
5
6
7
8
9
10
.386
.model flat, stdcall
option casemap :none
include masm32/include/kernel32.inc
includelib masm32\lib\kernel32.lib
.code
start:
push 2000
call Sleep
end start

En continuant, je me suis posé plusieurs questions :

• peut-on faire un call [valeur] ? (j'ai essayé mais masm à refusé, alors quel est la bonne syntaxe si elle existe ?)
• call enregistre l'emplacement d'appel du fichier où ? (je sais que call est comme un jmp qui cible le jmp d'appel de la procédure mais qu'a-t-il en plus ?)
• j'ai aussi fait quelque essaie en essayant d'appeler directement une procédure : jmp dword ptr DS:[<&kernel32.Sleep>] mais cela ne marche pas, pourquoi ?
• quel est le module KERNELBA et peut-on l'utiliser directement ?
• si oui, avec ce module, comment appeler ces procédures ? (je suis tombé sur : call KERNELBA.76311BA8, mais en l'écrivant directement, ça n'a pas marché, donc comment la déclarer ?)

Auriez-vous des réponses ?
Merci d'avance.

Pour information, ce que j'essaie de faire est d'apprendre le langage machine en parallèle (l'OPCODE). Si quelqu'un a quelque information sur comment est généré l'entête de fichier ce serait super de m'en dire plus. (J'ai mis cette question sur ce forum car je ne pense pas qu'il y en est un adapté à celle-là.)

[chrtophe]

La fonction call va, avant de faire le saut à l'adresse empiler l'adresse de retour. L'appel à ret va prendre cette adresse et y sauter. Tu peux voir ça comme l'appel d'une fonction en C.

Quand tu appelles des fonctions externes, comme celles du système, l'executabke va consulter sa table de fonctions importées qui vont contenir leur adresse en mémoire.

j'ai aussi fait quelque essaie en essayant d'appeler directement une procédure : jmp dword ptr DS:[<&kernel32.Sleep>]

Ca ne pourra jamais marcher. Une fonction de l'OS sera obligatoirement appelé par un CALL car cela va passer par une call gate pour passer mode noyau. Et certainement pas par un saut vers un descripteur de segment de données (DS).

[Invité]

@matrob72
Ne t’amuse pas à chercher à appeler une fonction API de manière plus directe que celle qui est utilisée par l’EXE généré successivement par l’assembleur puis par le linker. L’assembleur est justement construit pour te simplifier la vie sur ce point (et beaucoup d’autres, d’ailleurs). Si, toutefois, tu souhaites t’aventurer sur ce terrain, attends d’avoir un peu plus d’expérience. Par exemple, tu saurais qu’on ne peut coder un CALL avec une valeur directe. Tu peux avoir ainsi un CALL Dword Ptr [0040351A].
Malgré mon expérience en matière d’assembleur, il m’arrive de devoir recharger Windows 2 fois par an en moyenne. Alors, méfiance...
Je reviens sur les API en complément de ce qu’a écrit Chrtophe. Si tu utilises des PUSH pour les paramètres puis que tu appelles ta fonction par un CALL, tu te prives de la possibilité que t’offre l’assembleur de contrôler le nombre de paramètres spécifié et de te retourner une erreur le cas échéant. Pour cela, il faut utiliser la forme :
INVOKE Sleep, 2000, pour reprendre ton exemple. INVOKE est une directive du préprocesseur inclus dans ML.EXE.
Enfin j’attire ton attention sur la fin de ton message : ne perds pas ton temps avec les opdcodes. L’assembleur est précisément là pour t'éviter d’y recourir. Et, en principe, l’assembleur ne modifie pas ton code d’origine (GoAsm pratique toutefois certaines modifications dans un but d’optimisation. Exemple : mov eax,0 est transformé en xor eax,eax. À ma connaissance, MASM ne fait rien de tel). Essaie de te faire une vue d’ensemble de l’environnement Windows avant de choisir ton mode de programmation en assembleur.
L’assembleur est relativement simple si tu utilises les bons outils. Mais peu de gens les connaissent vraiment. Au besoin, je pourrais te recommander quelques lectures utiles si tu le souhaites.
Bonne soirée

[matrob72]

Ce que tu dis est intéressant, mais je le sais bien. Je ne prononce pas les invokes, parce que je voudrais être au plus proche des directives du processeur. Après, j’aimerais surtout voir si je peux recréer les fonctions api. Je m’interesse Également de voir si je peux créer mon propre assembleur (langage de programmation le plus optimisé possible)
tout ce que je dis sont des idées mais je m’intéresse plus à savoir comment ils ont été créé qu’à les r’inventer.
Donc si vous avez des connaissances que peut de gens savent sur le langage machine ou sur les instructions les plus proches qu’on peut donner à Windows, je les prends. 😀
Je vais éviter de parler de philosophie sur le pourquoi car je ne sais pas moi même. 🧐

[bifur]

attention, le langage assembleur n'est pas un langage créer pour être optimisé mais le langage qui est utilisé par le microprocesseur d'une machine, c'est le langage le plus proche de la machine, donc c'est grâce a celui ci que l'on peut contrôler le plus le comportement d'une machine et que l'on considère que l'assembleur permet d'optimiser (au prix d'une connaissance parfaite de tout le système)

la création d'un nouveau assembleur est un privilège réservé aux créateur de nouveaux processeur/microcontrôleur mais si tu veux utiliser un pc standard il vas falloir te contenter du x86 et de sa descendance

si tu veux étudier le code des API Windows, j'ai bien peur que ça ne soit pas possible, Windows n'est surement pas écrit en assembleur et les sources ne sont pas consultables
si tu veux étudier des API de system d'exploitation, il vas falloir étudier une API d'un système d'exploitation dont les source sont ouvertes, linux par exemple mais dans ce cas les sources ne sont pas en assembleur (ou très peu) mais en C. il reste quelques "Hobby OS" qui ont leurs sources écrit en assembleur mais c'est pas forcément très optimisé ou aboutit

[chrtophe]

Si tu veux recréer une fonction, il faut savoir/comprendre ce quelle fait. Et pour info, l'OS t'empêchera de faire un appel direct au matériel.
Par ailleurs, un assembleur ne fait que des calculs et lire/écrire des valeurs à des adresses mémoires, ou dans l'espace d'adressage de la carte vidéo, de la carte son (ou plutôt des chipsets maintenant, vu que tout est intégré). Il faut donc parfaitement connaitre l’électronique de tous les composants de l'appareil pour comprendre tout ce que le code machine fait, ce qui est maintenant impossible (trop d'info, peu ou pas de documentation), et inutile.

Exemple pour la fonction sleep, ton ordi contient un élément nommé timer qui va déclencher une x interruptions par seconde. Sans OS, il te faut gérer cette interruption en par exemple incrémentant un compteur (une valeur à une adresse mémoire), et il suffit au niveau de ton code de lire le compteur en début de programme puis par une boucle, relire cette valeur et faire la différence avec la première valeur pour voir si le temps souhaité est écoulé.

Avec un OS, tu ne pourras pas accéder directement au timer, par contre tu vas avoir une fonction toute faite qui va "attendre" le temps souhaité. Cette fonction va mettre ton processus en attente sans bloquer les autres processus.

[Kannagi]

Je m’intéresse Également de voir si je peux créer mon propre assembleur (langage de programmation le plus optimisé possible)

Alors je pense que tu ne sais pas ce qu'est l'assembleur parce que ça n'a pas beaucoup de sens
L'assembleur ce sont des mnémoniques quand tu écris mov ax,bx , c'est pareil que si tu écrivais 0x15 (c'est au pif pas vérifié les opcodes) , alors que si tu écris un nouveau assembleur qui fait toto r0,r1 , ça va pas changer énormément le schmilblick
Tu peux très bien créer ton nouvel assembleur avec des toto ou en langage shadok , mais peu de personne l'utilisera parce que si tu code sur un X86 , les gens liront la doc intel donc il est plus préférable d'avoir une syntaxe intel.
(Cela dit , ça sera pareil pour tout les assembleurs ,on va se mettre sur la syntaxe proposé par le constructeur).

L'assembleur par définition n'optimise rien , c'est au programmeur de s'en soucier et dans une certaine mesure les langages haut niveau optimisera mieux en règle général (qui va optimiser ces 50 000 lignes en asm ? ).

Ce que tu dis est intéressant, mais je le sais bien. Je ne prononce pas les invokes, parce que je voudrais être au plus proche des directives du processeur.
Donc si vous avez des connaissances que peut de gens savent sur le langage machine ou sur les instructions les plus proches qu’on peut donner à Windows, je les prends. 😀

Comme le dit si bien chrtophe un processeur , c'est juste une machine a calculer par définition ça ne fait rien , ça n'affiche pas d'image , ça contrôle pas de clavier , ni de souris , ni un écran etc etc, c'est la communication avec le hard qui le fait et fort heureusement l'OS te l'interdira !
Tu peux comme dit juste avant de programmer sans OS , mais y'a pas de doc ou très peu et ça demande un niveau au delà du simple débutant , je pense qu'un arduino codé en asm est beaucoup plus instructive et plus simple que du PC/X86 sans OS.

[matrob72]

Quand je dis de vouloir créer mon assembleur, je parle d’une application qui permet de construire un fichier exe, hors, je connais très peu l’encodage des déclarations. J’ai déjà pu comprendre le squelette principale, (entêté, instruction, redirection fonction ?, variable)
Après, comme je l’ai dit, je ne veux pas forcément le créer directement, mais plutôt voir comment ils ont fait les assembleurs.
Et je n’ai jamais dit que je voulais publier mon application. 🤨😄
Evitez de me répondre comme si je ne savais pas ceci cela, je commence à en avoir marre...
(J’ai beaucoup de mal à dire ce que je veux précisément mais quand même...)

[matrob72]

Euh, je crois que je me suis un peu dérivé du titre... on peu le modifier ?

[bifur]

c'est vrai que le titre ne correspond plus a la majorité du sujet de ce débat

bon visiblement tu veux plus faire un compilateur (même si j'ai déjà entendu parler d"assembleur" pour un logiciel qui transforme un texte en exécutable)
alors si tu connait bien le langage assembleur je te conseillerait d'étudier le compilateur assembleur FASM qui est lui même écrit en assembleur pour plusieurs plateformes

et pour la documentation je conseil le "Intel Software develloper's manual" , c'est lourd mais il as pas plus complet

[Kannagi]

Si tu veux créer un logiciel d'assembleur ,alors n'importe quel langage peut faire l'affaire (la plupart sont fait en C ou C++ ).
Apres il y'a a vraiment rien de bien sorcier ,c'est une analyse de texte + génération d'opcode.
Mais ça peut devenir plus complexe (si on veut faire un assembleur assez complet) vu que ça reste vouloir créer un compilateur.

[matrob72]

Ce que tu dis est faux, grâce au mot clef que bifure à donné, 🤩 j’ai trouvé le logiciel PE Explorer qui permet de visualiser et de desassembler les fichiers exe, et on peut très bien voir que leurs en-tête non rien à voir à l’opcode. Il est standardisé et est constitue essentiellement d’offset et tailles de block que constitue le fichier. Derrière le block d’instruction, on trouve toutes les données (directive, variables...) les une dernière les autres chacun dans son block sans trace d’opcode.
Ça résume à peu près tout ce qui y a dans les fichiers. Si quelqu’un est intéressé par les détailles, dite le moi. (Je n’ai pas encore terminé d’analyser tout)
Sinon, que ce soit de créer l’assembleur en assembleur ou en c, il faut bien connaître la base.