Ova beleška je napisana 2014. godine, ali upravo sam bio u problemima na habr-u i nije ugledala svetlost dana. Tokom banovanja sam je zaboravio, a sada sam je našao u nacrtima. Razmišljao sam da je obrišem, ali možda će nekome koristiti.

U suštini, kratko petnaestminutno štivo za administraciju o traženju "uključenog" LD_PRELOAD.
1. Kratko uvodno objašnjenje za one koji nisu upoznati sa zamenskim funkcijama
Drugi mogu odmah preći na tačku 2.
Počnimo sa klasičnim primerom:
#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 opcija:
$ 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 zamislimo da nemamo izvorni kod programa, a ponašanje treba promeniti.
Kreiramo svoju biblioteku sa sopstvenim prototipom funkcije, na primer:
int rand(){
return 42;
}
$ gcc -shared -fPIC ./o_rand.c -o ld_rand.so
I sada je naš nasumični izbor potpuno predvidljiv:
# LD_PRELOAD=$PWD/ld_rand.so ./ld_rand
42
42
42
42
42
Ova fora izgleda još impresivnije ako prvo eksportujemo našu biblioteku putem
$ 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 ni red u kodu samog programa, ali njegovo ponašanje sada zavisi od malene funkcije u našoj biblioteci. Štaviše, u vreme pisanja programa, lažni rand nije čak ni postojao.
Šta je nateralo naš program da koristi lažni rand? Разберем по шагам.
Kada se aplikacija pokrene, učitavaju se određene biblioteke koje sadrže funkcije neophodne za program. Možemo ih pregledati 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 varirati u zavisnosti od verzije OS-a, ali mora sadržavati datoteku libc.so. Ova biblioteka obezbeđuje sistemske pozive i osnovne funkcije kao što su open, malloc, printf i dr. Naš rand takođe spada među njih. Proverimo to:
# nm -D /lib/x86_64-linux-gnu/libc.so.6 | grep " rand$"
000000000003aef0 T rand
Pogledajmo da li će se skup 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 promenljiva LD_PRELOAD prinuđava učitavanje naše ld_rand.so iako je program sam ne zahteva. I, pošto se naša funkcija "rand" učitava pre rand od libc.so, ona ima kontrolu.
U redu, uspjeli smo da zamenimo izvorne funkcije, ali kako da zadržimo njihovu funkcionalnost i dodamo određene akcije. 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 kao naš "dodatak" samo ispisujemo jedan red teksta, nakon čega pravimo pokazivač na izvorne funkcije. rand. Da bismo dobili adresu ove funkcije, potrebno je dlsym — to je funkcija iz biblioteke libdl, koja će pronaći našu rand u steku dinamičkih biblioteka. Nakon toga ćemo pozvati tu funkciju i vratiti njen rezultat. Shodno tome, biće potrebno dodati "-ldl" prilikom kompajliranja:
$ gcc -ldl -shared -fPIC ./o_rand_evil.c -o ld_rand_evil.so
$ LD_PRELOAD=$PWD/ld_rand_evil.so ./ld_rand
Zlonamerni ubrizgani kod
66
Zlonamerni ubrizgani kod
28
Zlonamerni ubrizgani kod
93
Zlonamerni ubrizgani kod
93
Zlonamerni ubrizgani kod
95
I naša aplikacija koristi "nativni" rand, prethodno izvršivši neke nepotrebne radnje.
2. Patnje u potrazi
S obzirom na potencijalnu pretnju, želimo da otkrijemo kada preload je izvršen. Jasno je da je najbolji način detekcije — ubaciti ga u jezgro, ali mene su zanimale opcije određivanja u korisničkom prostoru.
U sledećim delovima će biti rešenja za detekciju i njihovo opovrgavanje.
2.1. Počnimo sa jednostavnim
Kao što je ranije rečeno, učitanu biblioteku je moguće navesti pomoću promenljive LD_PRELOAD ili je navesti u datoteci /etc/ld.so.preload. Da bismo napravili dva najjednostavnija detektora.
Prvi — za proveru postavljene promenljive 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 proveru 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čitać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 uspešnu detekciju.
Shodno tome, [-] označava zaobilaženje detekcije.
Koliko je efikasan takav detektor? Prvo ćemo se baviti promenljivom 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 provere 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, ovde mogu biti korišćene druge metode pristupa datoteci, kao što su, open64, stat i tako dalje, ali, u suštini, za njihovu prevaru potrebno je istiih 5-10 redova koda.
2.2. Idemo dalje
Gore smo koristili getenv() za dobijanje vrednosti LD_PRELOAD, ali postoje i ENVnačin da se dođe do **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;
}
Pošto ovde čitamo podatke direktno iz memorije, taj poziv se ne može presresti, a naš undetect_getenv više ne ometa prepoznavanje upada.
$ LD_PRELOAD=./ld_undetect_getenv.so ./detect_environ
LD_PRELOAD (**environ) [+]
Činilo bi se da je time problem rešen? Sve tek počinje.
Nakon što je program pokrenut, vrednost promenljive LD_PRELOAD u memoriji više nije potrebna hakerima, što znači da je možemo smatrati i obrisati pre nego što se izvrše bilo kakve instrukcije. Naravno, menjati niz u memoriji, barem, je loš stil programiranja, ali da li to može zaustaviti nekoga ko uopšte ne želi dobro?
Za to će nam biti potrebna da kreiramo svoju lažnu funkciju init(), u kojoj ćemo uhvatiti postavljeni LD_PRELOAD i proslediti je 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, proveravamo:
$ 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 poslednje mesto gde se može pronaći zamena LD_PRELOAD, tu je još i /proc/. Počećemo s očiglednim /proc/{PID}/environ.
U stvari, postoji univerzalno rešenje za undetect’anje **environ i /proc/self/environ. Problem leži u "pogrešnom" ponašanju unsetenv(env).
ispravan izbor
void evil_init()
{
// Prvo sačuvamo trenutnu vrednost 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) {
// Uklanjamo trenutni LD_PRELOAD
//unsetenv(env);
// Umesto unset, samo ćemo postaviti našu promenljivu na nul
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 ga nismo pronašli i /proc/self/environ sadrži "problematične" podatke.
Prvo pokušajmo 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 fajla sve to isto open(), tako da je rešenje slično onome što je već radjeno u tački 2.1, ali sada pravimo privremeni fajl, gde kopiramo vrednosti prave memorije bez redova 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 ovaj korak je završen:
$ (LD_PRELOAD=./ld_undetect_proc_environ.so cat /proc/self/environ; echo) | tr " 00" "n" | grep -F LD_PRELOAD
$
Sledeće očigledno mesto — /proc/self/maps. Nema smisla zadržavati se na njemu. Rešenje je apsolutno identično prethodnom: kopiramo podatke iz fajla bez redova između libc.so i ld.so.
2.4. Opcija od Chokepoint
Ovo rešenje mi se posebno dopalo zbog svoje jednostavnosti. Upoređujemo adrese funkcija, učitanih direktno 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 sa presretanjem "open()" i proveravamo:
$ export LD_PRELOAD=$PWD/ld_undetect_open.so
$ ./detect_chokepoint
LD_PRELOAD (sistem poziv - open) [+]
Adresa Libc: 0x7fa86893b160
Sledeć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. Sistemski pozivi
Naizgled tu je sve, ali ćemo se još malo potruditi. Ako direktno usmjerimo sistemski poziv ka jezgru, to će omogućiti zaobilaženje cijelog procesa presretanja. Rješenje je u nastavku, naravno, zavisno od arhitekture (x86_64). Pokušaćemo 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. Izvoda iz man‘a:
ptrace je alat koji omogućava roditeljskom procesu da prati i kontroliše izvođenje drugog procesa, da gleda i mijenja njegove podatke i registre. Obično se ova funkcija koristi za kreiranje tačaka prekida u procesu debagiranja i praćenje sistemskih poziva.
Roditeljski proces može započeti debagovanje najprije pozivajući funkciju fork(2), a zatim dobijeni dječiji proces može izvesti PTRACE_TRACEME, nakon čega slijedi izvršenje exec(3). S druge strane, roditeljski proces može započeti debagovanje postojećeg procesa koristeći PTRACE_ATTACH.
Tokom debagovanja, dječiji proces se zaustavlja svaki put kada primi signal, čak i ako je taj signal ignorisan. (Iznimka je SIGKILL, koji radi na uobičajen način.) Roditeljski proces će biti obaviješten o tome kada pozove wait(2), nakon čega može da pregleda i promijeni sadržaj dječijeg procesa prije njegovog ponovnog pokretanja. Nakon toga, roditeljski proces omogućava djetetu da nastavi rad, u nekim slučajevima ignorišući signal koji mu se šalje ili umjesto toga šaljući drugi signal).
Dakle, rješenje je pratiti proces, zaustavljajući ga prije svakog sistemskog poziva i, po potrebi, preusmjeriti tok u funkciju hvatača.
#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);
}
}
Proveravamo:
$ ./detect_syscall
LD_PRELOAD (open syscall) [+]
$ LD_PRELOAD=./ld_undetect_syscall.so ./detect_syscall
LD_PRELOAD (open syscall) [-]
+0-0=5
Ogromno hvala
, čiji su radovi, izvorni kodovi i komentari uradili mnogo više nego što sam ja, da se ova bilješka pojavi ovde.
Izvor: habr.com
