12 - Assembly Lesson No 1

Null diskmag Issue 1

eZine lover (@eZine)

Published in 

null magazine

 · 26 Dec 2020

Lesson 1 - Hello, world!
First, some background...

Assembly language is bare-bones. The only interface a programmer has above the actual hardware is the kernel itself. In order to build useful programs in assembly we need to use the linux system calls provided by the kernel. These system calls are a library built into the operating system to provide functions such as reading input from a keyboard and writing output to the screen.

When you invoke a system call the kernel will immediately suspend execution of your program. It will then contact the necessary drivers needed to perform the task you requested on the hardware and then return control back to your program.

Note: Drivers are called drivers because the kernel literally uses them to drive the hardware.

We can accomplish this all in assembly by loading EAX with the function number (operation code OPCODE) we want to execute and filling the remaining registers with the arguments we want to pass to the system call. A software interrupt is requested with the INT instruction and the kernel takes over and calls the function from the library with our arguments. Simple.

For example requesting an interrupt when EAX=1 will call sys_exit and requesting an interrupt when EAX=4 will call sys_write instead. EBX, ECX & EDX will be passed as arguments if the function requires them. Click here to view an example of a Linux System Call Table and its corresponding OPCODES.

Writing our program...

Firstly we create a variable 'msg' in our .data section and assign it the string we want to output in this case 'Hello, world!'. In our .text section we tell the kernel where to begin execution by providing it with a global label _start: to denote the programs entry point.

We will be using the system call sys_write to output our message to the console window. This function is assigned OPCODE 4 in the Linux System Call Table. The function also takes 3 arguments which are sequentially loaded into EDX, ECX and EBX before requesting a software interrupt which will perform the task.

The arguments passed are as follows:

• EDX will be loaded with the length (in bytes) of the our string.
• ECX will be loaded with the address of our variable created in the .data section.
• EBX will be loaded with the file we want to write to – in this case STDOUT.

The datatype and meaning of the arguments passed can be found in the function's definition.

We compile, link and run the program using the commands below.

helloworld.asm

; Hello World Program - asmtutor.com 
; Compile with: nasm -f elf helloworld.asm 
; Link with (64 bit systems require elf_i386 option): ld -m elf_i386 
; helloworld.o -o helloworld 
; Run with: ./helloworld 

SECTION .data 
msg     db      'Hello World!', 0Ah     ; assign msg variable with your message 
                                        ; string 

SECTION .text 
global  _start 

_start: 

    mov     edx, 13     ; number of bytes to write - one for each letter plus 
                        ; 0Ah (line feed character) 
    mov     ecx, msg    ; move the memory address of our message string into 
                        ; ecx 
    mov     ebx, 1      ; write to the STDOUT file 
    mov     eax, 4      ; invoke SYS_WRITE (kernel opcode 4) 
    int     80h

Compile it with NASM as follows:

~$ nasm -f elf helloworld.asm 
~$ ld -m elf_i386 helloworld.o -o helloworld 
~$ ./helloworld 
Hello World! 
Segmentation fault

The segmentation fault, right now is normal... more in lesson 2