U potrazi za LD_PRELOAD

Ova bilješka je napisana 2014. godine, ali nisam mogao da je objavim zbog represija na Habr-u. Tokom banovanja sam zaboravio na nju, a sada sam je pronašao u nacrtima. Razmišljao sam da je obrišem, ali možda će nekome biti korisna.

U potrazi za LD_PRELOAD

Ukratko, malo petka za administratore o temi pretraživanja 'uključenog' LD_PRELOAD.

1. Kratak uvod za one koji nisu upoznati sa zamjenom funkcija

Ostali mogu odmah preći na stav 2.

Počnimo s klasičnim primjerom:

#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);
  }
}

Kompajliramo bez ikakvih zastavica:

$ gcc ./ld_rand.c -o ld_rand

I, očekivano, dobijamo 5 nasumičnih brojeva manjih od 100:

$ ./ld_rand
53
93
48
57
20

Ali pretpostavimo da nemamo izvorni kod programa, a ponašanje treba promijeniti.

Kreirajmo svoju biblioteku s vlastitim prototipom funkcije, na primjer:

int rand(){
  return 42;
}

$ gcc -shared -fPIC ./o_rand.c -o ld_rand.so

I sada je naš slučajni odabir prilično predvidiv:

# LD_PRELOAD=$PWD/ld_rand.so ./ld_rand
42
42
42
42
42

Ova caka izgleda još impresivnije ako prvo izvezemo našu biblioteku preko

$ export LD_PRELOAD=$PWD/ld_rand.so

ili prethodno izvršimo

# echo "$PWD/ld_rand.so" > /etc/ld.so.preload

a zatim pokrenemo program na uobičajen način. Nismo promenili nijednu liniju u samom kodu programa, ali njegovo ponašanje sada zavisi od male funkcije u našoj biblioteci. Štaviše, u vreme pisanja programa, lažni rand nije čak ni postojao.

Šta je motivisalo naš program da koristi lažni rand? Разберем по шагам.
Kada se aplikacija pokrene, učitavaju se određene biblioteke koje sadrže funkcije potrebne programu. Možemo ih pogledati koristeći 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)

Ova lista može se razlikovati u zavisnosti od verzije OS-a, ali datoteka libc.so. Ova biblioteka obezbeđuje sistemske pozive i osnovne funkcije poput open, malloc, printf itd. Naš rand takođe spada u njih. Uverimo se u to:

# nm -D /lib/x86_64-linux-gnu/libc.so.6 | grep " rand$"
000000000003aef0 T rand

Pogledajmo da li će se set biblioteka promeniti korišćenjem LD_PRELOAD

# 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)

Ispostavlja se da postavljena varijabla LD_PRELOAD uzrokuje učitavanje naše ld_rand.so čak iako je program sam ne zahteva. I, pošto se naša funkcija "rand" učitava pre nego što rand od libc.so, ona dominira.

U redu, uspelo nam je da zamenimo izvorne funkcije, ali kako da zadržimo njegovu funkcionalnost i dodamo određene radnje. Modifikujemo naš random:

#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();
}

Ovde u našoj 'dopuni' samo štampamo jednu liniju teksta, nakon čega pravimo pokazivač na izvorne funkcije randZa dobivanje adrese ove funkcije trebat ćemo dlsym — to je funkcija iz biblioteke libdl, koja će pronaći našu rand u stogu dinamičkih biblioteka. Nakon toga pozvat ćemo ovu funkciju i vratiti njezinu vrijednost. Shodno tome, morat ćemo dodati «-ldl» prilikom kompilacije:

$ 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 naš program koristi «nativni» rand, prethodno izvršivši neka neprimjerena djelovanja.

2. Muke potrage

Svjesni potencijalne prijetnje, želimo otkriti što preload je izvršeno. Jasno je da je najbolji način detekcije - ugurati ga u jezgru, ali mene su zanimali upravo načini prepoznavanja u korisničkom prostoru.

Sljedeće će uslijediti par rješenja za otkrivanje i njihovo pobijanje.

2.1. Počnimo sa jednostavnim

Kao što je ranije spomenuto, učitanu biblioteku moguće je odrediti pomoću varijable LD_PRELOAD ili je upisati u datoteku /etc/ld.so.preload. Napravit ćemo dva najjednostavnija detektora.

Prvi — za provjeru postavljene varijable okruženja:

#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");
}

Drugi — za provjeru otvaranja datoteke:

#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");
}

Učitat ćemo biblioteke:

$ 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) [+]

Ovdje i dalje [+] označava uspješno otkrivanje.
Shodno tome, [-] označava zaobilaženje detekcije.

Koliko je učinkovit takav detektor? Prvo se pozabavimo varijablom okruženja:

#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) [-]

Slično se oslobađamo i od provjere open:

#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) [-]

Da, ovdje se mogu koristiti drugi načini pristupa datoteci, poput, open64, stat itd., ali, u suštini, za njihovo obmanjivanje potrebno je istih 5-10 linija koda.

2.2. Krećemo dalje

Gore smo koristili getenv() za dobivanje vrijednosti LD_PRELOAD, ali postoji i 'nivo niži' način dolaska do ENV-varijabli. Nećemo koristiti posredničke funkcije, već ćemo se obratiti nizu **environ, u kojem se čuva kopija okruženja:

#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;
}

Budući da ovdje čitamo podatke izravno iz memorije, taj poziv se ne može presresti, a naš undetect_getenv više ne ometa otkrivanje upada.

$ LD_PRELOAD=./ld_undetect_getenv.so ./detect_environ
LD_PRELOAD (**environ) [+]

Činilo se da je time problem riješen? Sve tek počinje.

Nakon što je program pokrenut, vrijednost varijable LD_PRELOAD nije više potrebna hakerima, što znači da je možemo smatrati suvišnom i ukloniti je prije nego što se izvrše bilo koje instrukcije. Naravno, uređivanje niza u memoriji je u najmanju ruku loš stil programiranja, ali može li to zaustaviti nekoga tko ionako ne želi dobro?

Za to ćemo morati stvoriti svoju lažnu funkciju init(), u kojoj ćemo presresti postavljen LD_PRELOAD i proslijediti ga našem linkeru:

#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;
}

Izvršavamo, provjeravamo:

$ 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/

Međutim, memorija nije posljednje mjesto gdje se može otkriti podmetanje LD_PRELOAD, postoji još i /proc/. Počet ćemo s očiglednim /proc/{PID}/environ.

U stvari, postoji univerzalno rješenje za undetect **environ i /proc/self/environ. Problem leži u "nepravilnom" ponašanju unsetenv(env).

ispravan izbor

void evil_init()
{
  // Prvo pohranimo trenutnu vrijednost 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) {
        // Oslobađamo se trenutnog LD_PRELOAD 
        //unsetenv(env);
        // Umjesto unset jednostavno postavljamo našu varijablu na nulu
        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
$

Ali zamislimo da to nismo pronašli i /proc/self/environ sadrži "problematične" podatke.

Prvo ćemo probati s našim prethodnim "maskiranjem":

$ (LD_PRELOAD=./ld_undetect_environ.so cat /proc/self/environ; echo) | tr " 00" "n" | grep -F LD_PRELOAD
LD_PRELOAD=./ld_undetect_environ.so

cat koristi za otvaranje datoteke još uvijek isti open(), tako da je rješenje slično onome što smo već radili u točki 2.1, ali sada stvaramo privremenu datoteku u koju kopiramo vrijednosti iz stvarne memorije bez redaka koji sadrže LD_PRELOAD.

#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);
}

I ova faza je prošla:

$ (LD_PRELOAD=./ld_undetect_proc_environ.so cat /proc/self/environ; echo) | tr " 00" "n" | grep -F LD_PRELOAD
$

Sljedeće očigledno mjesto — /proc/self/maps. Nema smisla predugo se zadržavati. Rješenje je potpuno identično prethodnom: kopiramo podatke iz datoteke bez redaka između libc.so i ld.so.

2.4. Opcija od Chokepoint

Ovo rješenje mi se posebno svidjelo zbog svoje jednostavnosti. Uspoređujemo adrese funkcija učitanih izravno iz libc, i "NEXT" adresa.

#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;
}

Učitavamo biblioteku s presretanjem "open()" i provjeravamo:

$ export LD_PRELOAD=$PWD/ld_undetect_open.so
$ ./detect_chokepoint
LD_PRELOAD (syscall - open) [+]
Libc adresa: 0x7fa86893b160
Sljedeća adresa: 0x7fa868a26135

Negacija je bila još jednostavnija:

#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

Činilo se da je to sve, ali hajde da još malo istražimo. Ako direktno usmjerimo sistemski poziv prema jezgru, to će omogućiti zaobilaženje cijelog procesa presretanja. Rješenje ispod, naravno, zavisi od arhitekture (x86_64). Pokušajmo implementirati za otkrivanje otvaranja 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) [+]

I ovo pitanje ima rješenje. Izvadak iz man‘a:

ptrace je sredstvo koje omogućava roditeljskom procesu da nadgleda i kontrolira tijek drugog procesa, pregledava i mijenja njegove podatke i registre. Ova funkcija obično se koristi za postavljanje prelomnih tačaka u programima za debagiranje i praćenje sistemskih poziva.

Roditeljski proces može započeti praćenje prvo pozivajući funkciju fork(2), a potom novoustvoreni dječji proces može izvršiti PTRACE_TRACEME, nakon čega obično slijedi izvršenje exec(3). S druge strane, roditeljski proces može započeti debagiranje postojećeg procesa pomoću PTRACE_ATTACH.

Prilikom praćenja, dječji proces se zaustavlja svaki put kada primi signal, čak i ako je taj signal ignorisan. (Izuzetak je SIGKILL koji radi na uobičajen način.) Roditeljski proces bit će obaviješten o tome kada pozove wait(2), nakon čega može pregledati i mijenjati sadržaj dječjeg procesa prije njegovog ponovnog pokretanja. Nakon toga roditeljski proces omogućava dječjem da nastavi s radom, u nekim slučajevima ignorirajući signal koji mu je poslat ili šaljući umjesto toga drugi signal).

Dakle, rješenje leži u nadgledanju procesa, zaustavljajući ga prije svakog sistemskog poziva i, po potrebi, preusmjeravanju toka u funkciju zamke.

#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, &regs);
                        // 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, &regs);
                    }
                }
                ptrace(PTRACE_SYSCALL, program, 0, 0);
                waitpid(program, &status, 0);
            }
        }
        exit(0);
    }
    else {
        sleep(0);
    }
}

Provjeravamo:

$ ./detect_syscall
LD_PRELOAD (open syscall) [+]
$ LD_PRELOAD=./ld_undetect_syscall.so ./detect_syscall
LD_PRELOAD (open syscall) [-]

+0-0=5

Veliko hvala

Charles Hubain
Chokepoint
ValdikSS
Philippe Teuwen
derhass

, čiji su članci, izvori i komentari učinili mnogo više nego ja, da bi ova napomena bila ovdje.

Izvor: habr.com

Kupite pouzdan hosting za web stranice s DDoS zaštitom, VPS VDS servere 🔥 Kupite pouzdan hosting za web stranice s DDoS zaštitom, VPS VDS servere | ProHoster