add assembly code tutorial

Author: x4nth055

README.md

@@ -81,6 +81,7 @@ This is a repository of all the tutorials of [The Python Code](https://www.thepy
     - [How to Get the Size of Directories in Python](https://www.thepythoncode.com/article/get-directory-size-in-bytes-using-python). ([code](general/calculate-directory-size))
     - [How to Play and Record Audio in Python](https://www.thepythoncode.com/article/play-and-record-audio-sound-in-python). ([code](general/recording-and-playing-audio))
     - [How to Get Geographic Locations in Python](https://www.thepythoncode.com/article/get-geolocation-in-python). ([code](general/geolocation))
+    - [How to Assembly, Disassembly and Emulate Machine Code using Python](https://www.thepythoncode.com/article/arm-x86-64-assembly-disassembly-and-emulation-in-python). ([code](general/assembly-code))
 
 
 - ### [Web Scraping](https://www.thepythoncode.com/topic/web-scraping)

general/assembly-code/README.md

@@ -0,0 +1,3 @@
+# [How to Assembly, Disassembly and Emulate Machine Code using Python](https://www.thepythoncode.com/article/arm-x86-64-assembly-disassembly-and-emulation-in-python)
+To run this:
+- `pip3 install -r requirements.txt`

general/assembly-code/arm_assembly.py

@@ -0,0 +1,56 @@
+# We need to emulate ARM
+from unicorn import Uc, UC_ARCH_ARM, UC_MODE_ARM, UcError
+# for accessing the R0 and R1 registers
+from unicorn.arm_const import UC_ARM_REG_R0, UC_ARM_REG_R1
+# We need to assemble ARM code
+from keystone import Ks, KS_ARCH_ARM, KS_MODE_ARM, KsError
+
+
+ARM_CODE = """
+// n is r0, we will pass it from python, ans is r1
+mov r1, 1       	// ans = 1
+loop:
+cmp r0, 0       	// while n >= 0:
+mulgt r1, r1, r0	//   ans *= n
+subgt r0, r0, 1 	//   n = n - 1
+bgt loop        	// 
+                	// answer is in r1
+"""
+
+print("Assembling the ARM code")
+try:
+    # initialize the keystone object with the ARM architecture
+    ks = Ks(KS_ARCH_ARM, KS_MODE_ARM)
+    # Assemble the ARM code
+    ARM_BYTECODE, _ = ks.asm(ARM_CODE)
+	# convert the array of integers into bytes
+    ARM_BYTECODE = bytes(ARM_BYTECODE)
+    print(f"Code successfully assembled (length = {len(ARM_BYTECODE)})")
+    print("ARM bytecode:", ARM_BYTECODE)
+except KsError as e:
+    print("Keystone Error: %s" % e)
+    exit(1)
+
+
+# memory address where emulation starts
+ADDRESS = 0x1000000
+
+print("Emulating the ARM code")
+try:
+    # Initialize emulator in ARM mode
+    mu = Uc(UC_ARCH_ARM, UC_MODE_ARM)
+    # map 2MB memory for this emulation
+    mu.mem_map(ADDRESS, 2 * 1024 * 1024)
+    # write machine code to be emulated to memory
+    mu.mem_write(ADDRESS, ARM_BYTECODE)
+    # Set the r0 register in the code, let's calculate factorial(5)
+    mu.reg_write(UC_ARM_REG_R0, 5)
+    # emulate code in infinite time and unlimited instructions
+    mu.emu_start(ADDRESS, ADDRESS + len(ARM_BYTECODE))
+    # now print out the R0 register
+    print("Emulation done. Below is the result")
+    # retrieve the result from the R1 register
+    r1 = mu.reg_read(UC_ARM_REG_R1)
+    print(">>  R1 = %u" % r1)
+except UcError as e:
+    print("Unicorn Error: %s" % e)

general/assembly-code/disassemble_x86-64.py

@@ -0,0 +1,39 @@
+# We need to emulate ARM and x86 code
+from unicorn import Uc, UC_ARCH_X86, UC_MODE_64, UcError
+# for accessing the RAX and RDI registers
+from unicorn.x86_const import UC_X86_REG_RDI, UC_X86_REG_RAX
+# We need to disassemble x86_64 code
+from capstone import Cs, CS_ARCH_X86, CS_MODE_64, CsError
+
+
+X86_MACHINE_CODE = b"\x48\x31\xc0\x48\xff\xc0\x48\x85\xff\x0f\x84\x0d\x00\x00\x00\x48\x99\x48\xf7\xe7\x48\xff\xcf\xe9\xea\xff\xff\xff"
+
+# memory address where emulation starts
+ADDRESS = 0x1000000
+
+try:
+      # Initialize the disassembler in x86 mode
+      md = Cs(CS_ARCH_X86, CS_MODE_64)
+      # iterate over each instruction and print it
+      for instruction in md.disasm(X86_MACHINE_CODE, 0x1000):
+            print("0x%x:\t%s\t%s" % (instruction.address, instruction.mnemonic, instruction.op_str))
+except CsError as e:
+      print("Capstone Error: %s" % e)
+
+try:
+    # Initialize emulator in x86_64 mode
+    mu = Uc(UC_ARCH_X86, UC_MODE_64)
+    # map 2MB memory for this emulation
+    mu.mem_map(ADDRESS, 2 * 1024 * 1024)
+    # write machine code to be emulated to memory
+    mu.mem_write(ADDRESS, X86_MACHINE_CODE)
+    # Set the r0 register in the code to the number of 7
+    mu.reg_write(UC_X86_REG_RDI, 7)
+    # emulate code in infinite time & unlimited instructions
+    mu.emu_start(ADDRESS, ADDRESS + len(X86_MACHINE_CODE))
+    # now print out the R0 register
+    print("Emulation done. Below is the result")
+    rax = mu.reg_read(UC_X86_REG_RAX)
+    print(">>> RAX = %u" % rax)
+except UcError as e:
+    print("Unicorn Error: %s" % e)

general/assembly-code/requirements.txt

@@ -0,0 +1,3 @@
+keystone-engine
+capstone
+unicorn