LD_PRELOAD keresés

Ez a jegyzet 2014-ben készült, de éppen a Hubra aláírási tilalom alá kerültem, így nem láthatta a napvilágot. A tilalom alatt elfeledkeztem róla, most viszont rátaláltam a vázlatok között. Gondoltam, törlöm, de lehet, hogy valakinek hasznos lesz.

Összességében egy kis pénteki admin olvasnivaló a „bekapcsolt” keresés témakörében. LD_PRELOAD.

1. Kis eltérés azok számára, akik nem ismerik a funkciók helyettesítését

A többiek közvetlenül ugrhatnak a 2. pontra..

Kezdjük a 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);
  }
}

Fordítás zászlók nélkül:

$ gcc ./ld_rand.c -o ld_rand

És, várhatóan, 5 véletlenszerű számot kapunk, kevesebb mint 100:

$ ./ld_rand
53
93
48
57
20

De képzeljük el, hogy nincs a programnak forráskódja, de a viselkedését módosítani kellene.

Készítsünk egy saját könyvtárat a saját funkció prototípusunkkal, például:

int rand(){
  return 42;
}

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

Most pedig a véletlenszerű választásunk teljesen 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 a könyvtárunkat a

$ export LD_PRELOAD=$PWD/ld_rand.so

vagy előzetesen végrehajtjuk,

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

majd elindítjuk a programot normál módban. Nem módosítottunk egy sort sem a program kódján, de annak viselkedése most már egy apró funkción múlik a könyvtárunkban. Ráadásul, amíg a program íródott, a hamis rand még nem is létezett.

Miért használta a programunk a hamisat? rand? Разберем по шагам.
Amikor egy alkalmazás elindul, bizonyos könyvtárak töltődnek be, amelyek tartalmazzák a program számára szükséges funkciókat. Megnézhetjük őket a 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 változó lehet az OS verziójától függően, de mindenképpen tartalmaznia kell a fájlt libc.so. Ez a könyvtár biztosítja a rendszerhívásokat és az alapvető funkciókat, mint például open, malloc, printf stb. A mi rand is közéjük tartozik. Ellenőrizzük ezt:

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

Nézzük meg, változik-e a könyvtárak készlete a 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)

használatával. LD_PRELOAD Kiderül, hogy a beállított változó betölti a ld_rand.so-t, még ha a program magának nem is igényli. És, mivel a mi „rand” rand tól libc.soelőbb töltődik be, ő irányítja a játékot.

Rendben, sikerült helyettesítenünk az alapértelmezett funkciót, de hogyan lehetne úgy cselekedni, hogy a funkciója megmaradjon, és bizonyos műveleteket hozzáadjuk. Módosítjuk a véletlenszámunkat:

#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 a „hozzáadásunkként” csak kiírunk egy sort, majd létrehozunk egy mutatót az eredeti funkcióra. rand. A funkció címének megszerzéséhez szükség lesz dlsym — ez egy funkció a könyvtárban libdl, amely megtalálja a mi rand a dinamikus könyvtárak stack-jében. Ezt követően meghívjuk ezt a funkciót és visszaadjuk az értékét. Ennek megfelelően hozzá kell adnunk «-ldl» a fordítá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
Gonosz injektált kód
66
Gonosz injektált kód
28
Gonosz injektált kód
93
Gonosz injektált kód
93
Gonosz injektált kód
95

És a programunk a «helyi» rand, miután végrehajtott néhány nem kívánatos lépést.

2. Keresési nehézségek

Tudva a potenciális fenyegetést, szeretnénk észlelni, hogy preload megvalósult. Nyilvánvaló, hogy a legjobb módja a detektálásnak az, ha a kernelbe rakjuk, de engem az user space-es észlelési lehetőségek érdekeltek.

Ezután párba állítva következnek a detektálási megoldások és azok cáfolatai.

2.1. Kezdjük a legegyszerűbbel

Ahogy korábban említettem, a betölteni kívánt könyvtárat a környezeti változó segítségével lehet megadni, LD_PRELOAD vagy beírva azt a fájlba /etc/ld.so.preload. Készítsünk két egyszerű detektort.

Az első — a beállított környezeti változó ellenőrzésére:

#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 — a fájl megnyitásának ellenőrzésére:

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

Betöltjük 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 tovább [+] a sikeres észlelésre utal.
Ennek megfelelően, [-] a detektálás megkerülését jelzi.

Mennyire hatékony ez a detektor? Először foglalkozzunk a környezeti változóval:

#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ó módon megszabadulunk a vizsgálattól is 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) [-]

Igen, itt más módszerek is használhatók a fájlhoz való hozzáférésre, mint például, open64, stat stb., de lényegében ezek megkerüléséhez az ugyanaz 5-10 soros kód szükséges.

2.2. Továbbhaladva

Fent a getenv() használatával kaptuk meg az értéket, LD_PRELOAD, de létezik egy „alacsonyabb szintű” mód is a ENV-változókhoz való hozzáférésre. Ne használjunk közbenső funkciókat, hanem forduljunk a **environ, 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 olvasunk adatokat a memóriából, ez a hívás nem kerülhet észlelésre, tehát a mi undetect_getenv már nem akadályozza meg a behatolás észlelését.

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

Úgy tűnik, hogy ezzel a probléma megoldódott? Még csak most kezdődik.

Miután a program elindult, a változó értéke LD_PRELOAD a memóriában már nem szükséges a hackereknek, tehát számításba vehetjük és törölhetjük a különböző utasítások végrehajtása előtt. Természetesen, a memóriában lévő tömb módosítása, legalábbis, rossz programozási stílus, de vajon ez megakadályozza azt, aki amúgy sem kíván nekünk jót?

Ehhez létre kell hoznunk egy hamis funkciót init(), amelyben elkapjuk a megadott LD_PRELOAD és átadjuk a linkernek:

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

Futtatás, ellenőrzés:

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

Azonban a memória nem az utolsó hely, ahol a hamisítást észlelhetjük, LD_PRELOAD, van még más is /proc/. Kezdjük az evidenssel: /proc/{PID}/environ.

Valójában van egy univerzális megoldás a hamisítókészítésre **environ és /proc/self/environ. A probléma a "nem megfelelő" viselkedésben rejlik: unsetenv(env).

a helyes változat:

void evil_init()
{
  // Először is, meg kell őriznünk a jelenlegi LD_PRELOAD értéket
  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) {
        // Megszabadulunk a jelenlegi LD_PRELOAD-tól
        //unsetenv(env);
        // A unset helyett egyszerűen nullázni fogjuk a változónkat
        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 tegyük fel, hogy nem találtuk meg, és /proc/self/environ olyan "problémás" adatokat tartalmaz.

Először próbálkozunk a korábbi "camouflage" megoldással:

$ (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 a fájl megnyitásához ugyanazt használja, open(), tehát a megoldás hasonló a már említettekhez a 2.1 pontban, de most egy ideiglenes fájlt hozunk létre, ahová átmásoljuk a valódi memória értékeit, anélkül, hogy 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);
}

És ez a lépés megtörtént:

$ (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 rajta időzni. A megoldás pontosan ugyanaz, mint az előző: a fájl adatait másoljuk ki a közöttük lévő sorok teljes kihagyásával. libc.so és ld.so.

2.4. Chokepoint megoldása

Ez a megoldás különösen tetszik a egyszerűsége miatt. Azoknak a funkcióknak a címét hasonlítjuk össze, amelyek közvetlenül libc, és a „NEXT” címek.

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

Betöltjük a könyvtárat az „open()” elkapásával, és ellenőrizzük:

$ export LD_PRELOAD=$PWD/ld_undetect_open.so
$ ./detect_chokepoint
LD_PRELOAD (syscall - open) [+]
Libc cím: 0x7fa86893b160
Következő cím: 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. Rendszerhívások

Úgy tűnik, hogy ezzel mindent elmondtunk, de még egy kicsit kutakodjunk. Ha közvetlenül a kernellhez irányítjuk a rendszerhívást, az lehetővé teszi, hogy megkerüljük az egész megfigyelési folyamatot. Az alábbi megoldás természetesen architektúra-függő (x86_64). Próbáljuk megvalósítani a nyitá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 feladatnak van megoldása. Kivonat a man‘ból:

A ptrace egy eszköz, amely lehetővé teszi a szülő folyamat számára, hogy figyelemmel kísérje és irányítsa egy másik folyamat végrehajtását, megtekintse és módosítsa annak adatait és regisztereit. Ezt a funkciót általában a hibakereséshez használt töréspontok létrehozására és a rendszerhívások nyomon követésére használják.

A szülő folyamat pontosan először a fork(2) függvényt hívja meg, majd a létrejött leányfolyamat végrehajthatja a PTRACE_TRACEME-t, amit (általában) az exec(3) végrehajtása követ. Másfelől a szülő folyamat egy meglévő folyamat hibakeresését indíthatja el a PTRACE_ATTACH segítségével.

A nyomkövetés során a leányfolyamat minden alkalommal megáll, amikor jelet kap, még akkor is, ha ez a jel figyelmen kívül van hagyva. (Kivételt képez a SIGKILL, amely normálisan működik.) A szülő folyamat értesül erről a wait(2) hívásakor, amit követően megtekintheti és módosíthatja a leányfolyamat tartalmát annak elindítása előtt. Ezt követően a szülő folyamat engedélyezi a leányfolyamat számára a folytatást, bizonyos esetekben figyelmen kívül hagyva a küldött jelet, vagy helyette egy másik jelet küldve.

Tehát a megoldás az, hogy nyomkövetjük a folyamatot, megállítva azt minden egyes rendszerhívás előtt, és szükség esetén átirányítjuk a vezérlést a csapda függvénybe.

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

Ellenőrizzük:

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

+0-0=5

Hatalmas köszönet

Charles Hubain
Chokepoint
ValdikSS
Philippe Teuwen
derhass

, akinek cikkek, forráskódok és megjegyzések tettek sokkal többet, mint én, hogy ez a megjegyzés itt megjelenhessen.

Forrás: habr.com