simple.vm
1.0.0
Ce référentiel contient l'implémentation d'une machine virtuelle simple , ainsi qu'un pilote qui lira un programme à partir d'un fichier et l'exécutera via cette machine virtuelle.
En plus de l'interprète de machine virtuelle, vous trouverez également:
Cette machine virtuelle particulière est intentionnellement simple, mais malgré cela, il est, espérons-le, implémenté de manière lisible. ("Simplicité" ici signifie que nous ne prenons en charge qu'un petit nombre d'instructions, et les registres que possède le processeur virtuel peut stocker des chaînes et des entiers, mais pas des valeurs à virgule flottante.) Cette machine virtuelle particulière est basée sur un registre, ayant dix registres qui peuvent être utilisés pour stocker des chaînes ou des valeurs entières.
Parce que le compilateur et le décompilateur sont écrits en perl, ils n'ont pas besoin de traitement spécial.
L'interpréteur, écrit en C, peut être construit comme tel:
$ make
Cela générera simple-vm et embedded à partir du contenu de Src /.
La mise en œuvre d'une machine virtuelle de base, comme celle-ci, est un problème assez bien compris:
case .halt ou exit des instructions.Les principales complications de la rédaction d'une machine virtuelle sont:
goto repeat " pas " 0x10 0x03 0x00 ". Cette machine virtuelle particulière ne contient que quelques primitives, mais elle inclut la prise en charge des étiquettes, du boucle, des sauts conditionnels, des appels et des retours. Il existe également une pile qui peut être utilisée pour stocker des valeurs temporaires et utilisée pour la manipulation call / ret .
La manipulation des étiquettes dans cette implémentation est peut-être digne de noter, car de nombreuses machines virtuelles simples / démonstrations ne les gèrent pas du tout.
Afin de prendre en charge le saut à des étiquettes qui n'ont pas nécessairement été définies encore, notre compilateur conserve une liste de cours de toutes les étiquettes (c'est-à-dire des destinations de saut possibles) et lorsqu'elle rencontre une instruction de saut, ou quelque chose d'autre qui fait référence à une étiquette, il publie un espace réservé, comme:
JUMP 0x0000x10 0x00 0x00 car l'instruction de saut est définie comme 0x10 .Une fois la compilation terminée, toutes les cibles auraient dû être découvertes et le compilateur est libre de mettre à jour les décodes bytecodes générés pour remplir les destinations appropriées.
Remarque : Dans nos machines virtuelles, tous les sauts sont absolus, ils peuvent donc ressembler à "
JUMP 0x0123" plutôt que "JUMP -4" ou "JUMP +30".
Remarque : La même chose s'applique aux autres instructions qui génèrent des étiquettes, telles que le stockage de l'adresse d'une étiquette, une appel, etc.
Cette machine virtuelle est conçue principalement comme une expérience d'apprentissage, mais elle est construite avec l'idée d'incorporer à l'esprit.
Le binaire simple-vm standard, qui lira les opcodes à partir d'un fichier et les interprétera, est de moins de 40k.
Étant donné que le traitement des opcodes binaires est géré via une table de répartition, il est trivialement possible pour vous d'ajouter vos propres opcodes spécifiques à l'application au système qui vous permettrait d'exécuter de minuscules programmes compilés et efficaces qui peuvent rappeler dans votre application lorsqu'ils le souhaitent.
Il existe un exemple de définition d'un OPCode personnalisé dans le fichier src/embedded.c . Cet exemple définit un OPCode personnalisé 0xCD et exécute un petit programme qui utilise cet opcode à des fins de démonstration:
$ ./embedded
[stdout] Register R01 => 16962 [Hex:4242]
Custom Handling Here
Our bytecode is 8 bytes long
Il y a plusieurs types d'instructions mis en œuvre:
Les instructions sont assez basiques, car ce n'est qu'un jouet, mais en ajouter de nouvelles n'est pas difficile et les primitives disponibles sont raisonnablement utiles telles quelles.
Voici des exemples de toutes les instructions:
:test
:label
goto 0x44ff # Jump to the given address
goto label # Jump to the given label
jmpnz label # Jump to label if Zero-Flag is not set
jmpz label # Jump to label if Zero-Flag is set
store #1, 33 # store 33 in register 1
store #2, "Steve" # Store the string "Steve" in register 1.
store #1, #3 # register1 is set to the contents of register #3.
exit # Stop processing.
nop # Do nothing
print_int #3 # Print the (integer) contents of register 3
print_str #3 # Print the (string) contents of register 3
system #3 # Call the (string) command stored in register 3
add #1, #2, #3 # Add register 2 + register 3 contents, store in reg 1
sub #1, #2, #3 # sub register 2 + register 3 contents, store in reg 1
mul #1, #2, #3 # multiply register 2 + register 3 contents, store in reg 1
concat #1, #2,#3 # store concatenated strings from reg2 + reg3 in reg1.
dec #2 # Decrement the integer in register 2
inc #2 # Increment the integer in register 2
string2int #3 # Change register 3 to have a string from an int
is_integer #3 # Does the given register have an integer content?
int2string #3 # Change register 3 to have an int from a string
is_string #3 # Does the given register have a string-content?
cmp #3, #4 # Compare contents of reg 3 & 4, set the Z-flag.
cmp #3, 42 # Compare contents of reg 3 with the constant 42. sets z.
cmp #3, "Moi" # Compare contents of reg 3 with the constant string "Moi". sets z.
peek #1, #4 # Load register 1 with the contents of the address in #4.
poke #1, #4 # Set the address stored in register4 with the contents of reg1.
random #2 # Store a random integer in register #2.
push #1 # Store the contents of register #1 in the stack
pop #1 # Load register #1 with the contents of the stack.
call 0xFFEE # Call the given address.
call my_label # Call the defined label
ret # Return from a called-routine.
Le programme suivant publiera sans cesse une chaîne:
:start
store #1, "I like loops"
print_str #1
goto start
Ce programme stocke d'abord la chaîne " I like loops " dans le registre 1, puis imprime ce registre, avant de revenir au début du programme.
Pour compiler ce programme dans ByteCode Run:
$ ./compiler ./examples/simple.in
Cela produira un fichier de sortie plein d'opcodes binaires dans le fichier simple.raw :
$ od -t x1 -An ./examples/simple.raw
01 01 0c 49 20 6c 69 6b 65 20 6c 6f 6f 70 73 03
01 06 00 00
Nous pouvons maintenant exécuter cette série d'opcodes:
./simple-vm ./examples/simple.raw
Si vous souhaitez déboguer l'exécution, exécutez:
DEBUG=1 ./simple-vm ./examples/simple.raw
Il y a plus d'exemples stockés sous les examples/ sous-répertoire dans ce référentiel. Les exemples de fichiers / Quine.in fournissent un bon exemple de diverses fonctionnalités - il publie ses propres opcodes.
Si vous souhaitez être testé avec AFL, vous devriez trouver ce assez simple:
afl lui-même, selon les instructions.CC=afl-gcc dans le Makefile .Vous pouvez compiler chacun de nos échantillons groupés comme ça:
cd examples/
for i in *.in; do ../compiler $i; done
cd ..
Cela compilera examples/*.in des examples/*.raw . Placez-les dans un répertoire et commencez votre fuzzer:
mkdir samples/
cp examples/*.raw samples/
Maintenant, vous avez ./samples/ contenant uniquement des programmes compilés. Vous pouvez ensuite muter / permuter ces exemples sous le contrôle du Fuzzer avec une ligne de commande comme celle-ci:
export FUZZ=1
afl-fuzz -i ./samples/ -o results/ ./simple-vm @@ 16384
Remarque : Ici, nous plafonnions chaque exécution pour exécuter les instructions de 16384 à exécution. Cela garantira que les programmes n'ont pas de boucles infinies.
Nous définissons la FUZZ variable environnementale pour contenir 1 uniquement pour désactiver l'utilisation de la fonction system() . Ce qui pourrait accidentellement supprimer votre directeur de maison, formater votre disque ou m'envoyer un don!
Un port Golang du compilateur et interprète de machine virtuelle est disponible dans le référentiel suivant:
En plus de cela, vous pouvez trouver une véritable machine virtuelle à l'intérieur du moteur de script intégré que j'ai écrit, également pour Golang. Dans ce cas, un langage de script est analysé et converti en une série d'instructions bytecode, qui sont exécutées par une machine virtuelle. Semblable à ce projet, mais les opérations de bytecode sont plus complexes et de haut niveau:
Si vous êtes intéressé par les compilateurs et les interprètes, vous pourriez généralement apprécier ces autres projets:
