[ASM] Ou l'apprendre ?

Bonjour depuis quelque temps j’aimerais apprendre l’ASM , mais je me pose plusieurs questions .

1. Sur quelle type d’architecture faut il l’apprendre ? (x86, x64 , ARM etc..) .
2. Ou l’apprendre . J’ai l’impression que beaucoup de tutos apprennent le 16 bits ce qui n’est pas très récent hein

Voila peut être que je parais un peu con pour les expérimentés de l’asm x)

Merci !

Je suis actuellement en train de suivre une license d’informatique à l’Université de Strasbourg, et on a eu une UE d’Architecture des Ordinateurs, dans laquelle on a pratiqué sur une architecture MIPS.

J’ai pas beaucoup plus d’expérience en assembleur en général, mais j’ai trouvé que l’assembleur MIPS était relativement simple a comprendre par rapport à de l’x86 ou de l’ARM, et il y a plusieurs émulateurs comme SPIM ou MARS assez complets pour apprendre.

Aussi, je te conseille la suite de vidéo de Ben Eater sur un ordinateur 8-bit qu’il a fait à partir de composants électroniques discrets, si tu veux comprendre un peu mieux comment ensuite ton processeur exécute réellement du code machine.

Salut,

Ben, j’ai envie dire, apprend l’Assembleur d’une architecture sur laquelle tu peux faire des tests et qui a un intérêt pour toi.

En fait, c’est en un sens assez logique. Tu as, je dirais, trois cas typiques d’utilisation de l’Assembleur aujourd’hui :

1. Pour la réalisation de programme d’amorçage, c’est-à-dire de programme chargés de démarrer ton système d’exploitation. Les processeurs de la famille x86 et x86_64 démarrant en mode 16 bits, ils sont écrits dans ce type d’Assembleur.
2. Dans l’informatique embarqué, quand les performances sont plus que critiques (et encore, je pense qu’aujourd’hui, c’est toujours au moins possible de faire du C) ;
3. Dans des cas particuliers d’optimisations, lorsque les compilateurs ne font pas du bon boulot.

Les deux derniers cas cités étant assez rares, ceci t’explique pourquoi tu ne trouves pour ainsi dire que des cours sur les architectures x86 et x86_64 en mode 16 bits.

Si tu souhaites apprendre l’Assembleur de manière générale, à ma connaissance, le mieux est d’expérimenter par toi-même (par exemple en examinant le code produit par un compilateur C) et en lisant les manuels de références, comme ceux d’AMD (voir la série « AMD64 Architecture Programmer’s Manual »).

Personelement je préférerai coder sous x64 (bah l’architecture de mon processeur quoi ) je vais faire peut être un peu plus de recherche

Du coup avec mars je peut être capable d’écrire un programme pour pc sans êtres forcément sous une architecture MIPS ? (Je suis pas un mec trop surpuissant en asm x) )

Une question que je me pose, c’est pourquoi souhaite tu apprendre l’asm ?

Y a des tutos assez vieux, mais au final la logique reste identique.

Mais que souhaite tu vraiment faire avec ? Parce que y a quelques tutos pour faire son OS basique, du reverse, de la prog basique, apprendre comment marche tel ou tel truc ?

ça permet de mieux t’orienter.

J’ajouterais également, que plus beaucoup de monde fait de l’asm aujound’hui. Principalement car les compilateurs font généralement mieux que nous (ou des experts dans leurs domaines).

J’ajouterais qu’il est également possible de l’apprendre pour le « cracking » ou le « hacking », comme pour trouver l’algo de génération des clés sur les anciens jeux, et autres

Pour ma part, et dans le but de maitriser le reverse-engineering, j’ai entamé de The art of assembly, une bible qui permet de comprendre exactement le fonctionnement d’un ordinateur et qui introduit bien d’autre concepts que l’assembleur. Mais c’est un livre en anglais, qui s’adresse à des universitaires et qui est donc destiné à etre lu en plusieurs semestres… Il faut donc être bien accroché pour en faire la lecture.

Salut, je ne sais pas si tu connais gcc.godbolt.org, mais c’est une bonne approche pour comprendre comment sont compilés les codes, sous les différents compilateurs modernes … !

Sinon concernant l’ASM, j’ai appris le NASM dans le cadre de ma L3 Informatique.
NASM est un compilateur de code assembleur type Intel qui fait un peut tout

En L3 ont a créé un compilateur de langage dit LL (voir théorie des langage), et donc à partir d’un programme en C qui décortique une grammaire LL (lexique, syntaxique, arbre abstrait) spécifique à notre compilateur LL, qui permet de génèré un code NASM que l’on compile.
Après cette compilation on obtient des « .o » (objet) qu’il faut linker avec « ld » en mode « elf-i386 » sous Linux, et sous Windows en « PE », par exemple « i386pe ». Puis il faut faire attention, car en fonction des systèmes/émulation il peut y avoir certaines incompatibilités dans le code ASM, surtout au niveau des interruptions, c’est pour ça qu’en C on utilise la « libc ».
A savoir, tu peux voir toute les « Emulations » possible de ton linker avec « ld -V ».

A propos des interruptions, c’est un sujet assez important, puisque nécessaire pour faire des entrées/sorties, ou même pour arrêter son programme.
Et donc tu comprendras qu’il y a plein d’interruption différentes, et que par exemple, « int 0x80 » c’est coté Linux, et « int 0x21 » c’est du côté Windows/DOS.
L’idée et qu’avant chaque interruption il faut paramétré les registre nécessaire au travail fournit par le système, par exemple sous linux « mov eax, 1 », puis « int 0x80 » pour arrêter ton programme, tu peux ajouter « mov ebx, 5 » avant ton interruption pour qu’il renvoi la valeur « 5 » (par exemple), ce qui ressemblera à ceci (programme qui s’ouvre et se ferme aussi tôt) :

1
2
3
4
5
6
7

section  .text
global _start

_start:                  ; entrée start
  mov   eax, 1           ; 1 est le code de SYS_EXIT
  mov   ebx, 5           ; valeur de retour, pour 'exit'
  int  0x80              ; exit

Il y a différent site qui traite le sujet des interruptions, mais pour voir rapidement ce qui existe :

• sous linux : int80
• sous Windows/DOS : int21

Concernant les cours d’ASM, mon prof de L3 les a mis en libre accès, donc si ça t’intéresse :

• Gramaires/Compilation/ASM (2 derniers cours pour l’ASM)
• Théorie des langages

Petite info, dépêche-toi vite de DL tout ça avant la rentrée universitaire, parce qu’il va tous enlever et remplir à nouveau au fur à mesure de ces cours …
Bon apprentissage !

Merci beaucoup de faire profiter tout le monde de tes cours, parce que du coup je pense que je vais aussi les recupérer.

Et donc tu comprendras qu’il y a plein d’interruption différentes, et que par exemple, « int 0x80 » c’est coté Linux, et « int 0x21 » c’est du côté Windows/DOS.

À noter que sur les architecture 64 bits, c’est l’instruction syscall qui est employée et non l’instruction int pour les appels systèmes.

Je ne suis pas un fin connaisseur de Windows, mais visiblement les interruptions citées ne concernent que les systèmes qui se basaient sur DOS, soit jusqu’avant Windows XP si ma mémoire est bonne.

Bien vue Taurre , vis-à-vis des interruptions.

J’ai mis le projet dont je parlai plus haut, de mon semestres en L3 Informatique partie compilation, sur GitHub :
c-compilator-ll-for-nasm

Ce qui t’intéressera certainement plus, se trouve dans la rubrique « generator » où tu peux voir, pour un fichier « %.l », un fichier généré en code NASM « nasm/%.nasm ».

Je te laisse donc faire ton propre avis, pour mieux comprendre : c-compilator-ll-for-nasm/generator

A noter, et c’est très important ! Le code NASM généré par ce compilateur LL n’est absolument pas optimisé !
C’est pour cela que tu verras des « pop » et « push » tout le temps…
En réalité c’est dans un soucis de simplifier le compilateur LL et donc de ne pas trop surcharger son écriture avec des optimisations.
De plus, il y a toute sorte de façon d’écrire en assembleur, de faire des boucles, de gérer les conditions, de nommer ses points d’entrées, etc…
Justement, je suis resté assez propre vis-à-vis de la génération, et est pris la peine de créer des points d’entrés nommés avec des tabulations et commentaires…

Les rudiments qui peuvent t’aider à comprendre : affect.l-affect.nasm / boucle.l-boucle.nasm / expression.l-expression.nasm / max.l-max.nasm / tri.l-tri.nasm

Voici, voilà…
N’hésite pas à poser d’autres questions.

Puis il faut faire attention, car en fonction des systèmes/émulation il peut y avoir certaines incompatibilités dans le code ASM, surtout au niveau des interruptions, c’est pour ça qu’en C on utilise la « libc ».
A savoir, tu peux voir toute les « Emulations » possible de ton linker avec « ld -V ». A propos des interruptions, c’est un sujet assez important, puisque nécessaire pour faire des entrées/sorties, ou même pour arrêter son programme. Et donc tu comprendras qu’il y a plein d’interruption différentes, et que par exemple, « int 0x80 » c’est coté Linux, et « int 0x21 » c’est du côté Windows/DOS. A propos des interruptions, c’est un sujet assez important, puisque nécessaire pour faire des entrées/sorties, ou même pour arrêter son programme.
Et donc tu comprendras qu’il y a plein d’interruption différentes, et que par exemple, « int 0x80 » c’est coté Linux, et « int 0x21 » c’est du côté Windows/DOS.

C’est la raison principal qui me dit que faire de l’asm sur X86 et avec un OS ne sert pas a grand chose et de mal comprendre certaines notions.
Alors non les interruptions ne permet pas de communiquer avec les I/O (entrée/sortie) , une interruption , c’est que ton programme s’arrête et va aller sauter ailleurs.
Dans ton cas l’OS a mis un code sur une interruption pour communiquer avec lui , tu communique pas non plus avec le matériel en faisant un int 80.
De plus quand on parle d’interruption , en assembleur on parle plus souvent interruption matériel qui est bien différent que int ou syscall (qui n’existe pas forcément sur tout les processeurs d’ailleurs).

Après je reste toujours très sceptique sur apprendre avec le x86 et une architecture PC , le x86-64 c’est pas un petit processeur , et l’architecture PC est vielle de plusieurs dizaine d’années (donc y’a beaucoup de chose de l’utile comme de l’inutile), de plus la plupart du matériel il faudrait écrire un pilote pour chaque matériel existant sur PC ce qui est pas forcément le plus simple pour un débutant (et si cette doc existe , va trouver la doc de NVDIA bon courage ! ).

Et si c’est faire de l’assembleur sous Linux ou Windows , ben l’utilité est proche de zero.
Et si on veut faire un programme plus évolué , il faudrait utilisé des librairies externe (écrite en C,C++ autre) , et donc utilisé une lib faite pour des langages compilé en assembleur est comment dire … pas très intéressants x)

NT: Pour MARS ou autre truc du genre , moi je prefere conseille la PSP , plus fun et qui marche sur du vrai matériel.