LD_PRELOAD ਦੀ ਭਾਲ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ

ਇਹ ਨੋਟ 2014 ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਸੀ, ਪਰ ਮੈਂ ਹੁਣੇ ਹੀ ਹੈਬਰੇ 'ਤੇ ਜਬਰ ਦੇ ਅਧੀਨ ਆਇਆ ਹਾਂ ਅਤੇ ਇਸ ਨੇ ਦਿਨ ਦੀ ਰੌਸ਼ਨੀ ਨਹੀਂ ਵੇਖੀ। ਪਾਬੰਦੀ ਦੇ ਦੌਰਾਨ ਮੈਂ ਇਸ ਬਾਰੇ ਭੁੱਲ ਗਿਆ ਸੀ, ਪਰ ਹੁਣ ਮੈਂ ਇਸਨੂੰ ਡਰਾਫਟ ਵਿੱਚ ਪਾਇਆ ਹੈ. ਮੈਂ ਇਸਨੂੰ ਮਿਟਾਉਣ ਬਾਰੇ ਸੋਚਿਆ, ਪਰ ਸ਼ਾਇਦ ਇਹ ਕਿਸੇ ਲਈ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ.

ਆਮ ਤੌਰ 'ਤੇ, "ਸ਼ਾਮਲ" ਦੀ ਖੋਜ ਕਰਨ ਦੇ ਵਿਸ਼ੇ 'ਤੇ ਥੋੜਾ ਜਿਹਾ ਸ਼ੁੱਕਰਵਾਰ ਐਡਮਿਨ ਰੀਡਿੰਗ LD_PRELOAD.

1. ਉਹਨਾਂ ਲਈ ਇੱਕ ਛੋਟਾ ਵਿਸ਼ਾ ਜੋ ਫੰਕਸ਼ਨ ਬਦਲ ਤੋਂ ਜਾਣੂ ਨਹੀਂ ਹਨ

ਬਾਕੀ ਸਿੱਧੇ ਜਾ ਸਕਦੇ ਹਨ п...

ਆਉ ਇੱਕ ਕਲਾਸਿਕ ਉਦਾਹਰਨ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ:

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

ਅਸੀਂ ਬਿਨਾਂ ਕਿਸੇ ਝੰਡੇ ਦੇ ਕੰਪਾਇਲ ਕਰਦੇ ਹਾਂ:

$ gcc ./ld_rand.c -o ld_rand

ਅਤੇ, ਜਿਵੇਂ ਕਿ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਸੀ, ਸਾਨੂੰ 5 ਤੋਂ ਘੱਟ 100 ਬੇਤਰਤੀਬੇ ਨੰਬਰ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ:

$ ./ld_rand
53
93
48
57
20

ਪਰ ਆਓ ਕਲਪਨਾ ਕਰੀਏ ਕਿ ਸਾਡੇ ਕੋਲ ਪ੍ਰੋਗਰਾਮ ਦਾ ਸਰੋਤ ਕੋਡ ਨਹੀਂ ਹੈ, ਪਰ ਸਾਨੂੰ ਵਿਵਹਾਰ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ।

ਆਉ ਆਪਣੇ ਖੁਦ ਦੇ ਫੰਕਸ਼ਨ ਪ੍ਰੋਟੋਟਾਈਪ ਨਾਲ ਆਪਣੀ ਲਾਇਬ੍ਰੇਰੀ ਬਣਾਈਏ, ਉਦਾਹਰਨ ਲਈ:

int rand(){
  return 42;
}

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

ਅਤੇ ਹੁਣ ਸਾਡੀ ਬੇਤਰਤੀਬ ਚੋਣ ਕਾਫ਼ੀ ਅਨੁਮਾਨਯੋਗ ਹੈ:

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

ਇਹ ਚਾਲ ਹੋਰ ਵੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ ਜੇਕਰ ਅਸੀਂ ਪਹਿਲਾਂ ਆਪਣੀ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਇਸ ਰਾਹੀਂ ਨਿਰਯਾਤ ਕਰਦੇ ਹਾਂ

$ export LD_PRELOAD=$PWD/ld_rand.so

ਜਾਂ ਅਸੀਂ ਇਸਨੂੰ ਪਹਿਲਾਂ ਕਰਾਂਗੇ

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

ਅਤੇ ਫਿਰ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਆਮ ਵਾਂਗ ਚਲਾਓ। ਅਸੀਂ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਕੋਡ ਦੀ ਇੱਕ ਲਾਈਨ ਨੂੰ ਨਹੀਂ ਬਦਲਿਆ ਹੈ, ਪਰ ਇਸਦਾ ਵਿਵਹਾਰ ਹੁਣ ਸਾਡੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਇੱਕ ਛੋਟੇ ਫੰਕਸ਼ਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪ੍ਰੋਗਰਾਮ ਲਿਖਣ ਦੇ ਸਮੇਂ, ਦ ਰੈਡ ਮੌਜੂਦ ਵੀ ਨਹੀਂ ਸੀ।

ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇੱਕ ਨਕਲੀ ਵਰਤਣ ਲਈ ਕੀ ਬਣਾਇਆ ਰੈਡ? ਆਓ ਇਸ ਨੂੰ ਕਦਮ ਦਰ ਕਦਮ ਚੁੱਕੀਏ।
ਜਦੋਂ ਕੋਈ ਐਪਲੀਕੇਸ਼ਨ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ, ਕੁਝ ਲਾਇਬ੍ਰੇਰੀਆਂ ਲੋਡ ਹੁੰਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਦੁਆਰਾ ਲੋੜੀਂਦੇ ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ। ਅਸੀਂ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦੇਖ ਸਕਦੇ ਹਾਂ 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)

ਇਹ ਸੂਚੀ OS ਸੰਸਕਰਣ ਦੇ ਆਧਾਰ 'ਤੇ ਵੱਖਰੀ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਉੱਥੇ ਇੱਕ ਫਾਈਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ libc.so. ਇਹ ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ ਸਿਸਟਮ ਕਾਲਾਂ ਅਤੇ ਬੁਨਿਆਦੀ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ ਜਿਵੇਂ ਕਿ ਓਪਨ, malloc, printf ਆਦਿ ਸਾਡੇ ਰੈਡ ਵੀ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹੈ। ਆਓ ਇਹ ਯਕੀਨੀ ਕਰੀਏ:

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

ਆਓ ਦੇਖੀਏ ਕਿ ਕੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦਾ ਸੈੱਟ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ 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)

ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਵੇਰੀਏਬਲ ਸੈੱਟ ਹੈ LD_PRELOAD ਸਾਨੂੰ ਲੋਡ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ ld_rand.so ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਖੁਦ ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਹੈ. ਅਤੇ, ਸਾਡੇ ਫੰਕਸ਼ਨ ਤੋਂ "ਰੈਂਡ" ਤੋਂ ਪਹਿਲਾਂ ਲੋਡ ਹੁੰਦਾ ਹੈ ਰੈਡ ਤੱਕ libc.so, ਫਿਰ ਉਹ ਰੂਸਟ 'ਤੇ ਰਾਜ ਕਰਦੀ ਹੈ।

ਠੀਕ ਹੈ, ਅਸੀਂ ਨੇਟਿਵ ਫੰਕਸ਼ਨ ਨੂੰ ਬਦਲਣ ਦਾ ਪ੍ਰਬੰਧ ਕੀਤਾ ਹੈ, ਪਰ ਅਸੀਂ ਇਹ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹਾਂ ਕਿ ਇਸਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਿਆ ਗਿਆ ਹੈ ਅਤੇ ਕੁਝ ਕਿਰਿਆਵਾਂ ਜੋੜੀਆਂ ਗਈਆਂ ਹਨ। ਆਉ ਸਾਡੇ ਬੇਤਰਤੀਬੇ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਕਰੀਏ:

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

ਇੱਥੇ, ਸਾਡੇ "ਜੋੜ" ਵਜੋਂ, ਅਸੀਂ ਟੈਕਸਟ ਦੀ ਸਿਰਫ ਇੱਕ ਲਾਈਨ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦੇ ਹਾਂ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਅਸਲ ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਬਣਾਉਂਦੇ ਹਾਂ ਰੈਡ. ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਪਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਸਾਨੂੰ ਲੋੜ ਹੈ dlsym ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ libdlਜੋ ਸਾਡੇ ਲੱਭ ਜਾਵੇਗਾ ਰੈਡ ਗਤੀਸ਼ੀਲ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਸਟੈਕ ਵਿੱਚ. ਜਿਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਾਂਗੇ ਅਤੇ ਇਸਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰਾਂਗੇ। ਇਸ ਅਨੁਸਾਰ, ਸਾਨੂੰ ਜੋੜਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ "-ldl" ਅਸੈਂਬਲੀ ਦੇ ਦੌਰਾਨ:

$ 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

ਅਤੇ ਸਾਡਾ ਪ੍ਰੋਗਰਾਮ "ਦੇਸੀ" ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਰੈਡ, ਪਹਿਲਾਂ ਕੁਝ ਅਸ਼ਲੀਲ ਹਰਕਤਾਂ ਕਰ ਚੁੱਕੇ ਹਨ।

2. ਖੋਜ ਦਾ ਦਰਦ

ਕਿਸੇ ਸੰਭਾਵੀ ਖਤਰੇ ਬਾਰੇ ਜਾਣਦੇ ਹੋਏ, ਅਸੀਂ ਇਸਦਾ ਪਤਾ ਲਗਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਪ੍ਰੀਲੋਡ ਪੂਰਾ ਕੀਤਾ ਗਿਆ ਸੀ. ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਖੋਜ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਇਸ ਨੂੰ ਕਰਨਲ ਵਿੱਚ ਧੱਕਣਾ ਹੈ, ਪਰ ਮੈਂ ਯੂਜ਼ਰਸਪੇਸ ਵਿੱਚ ਖੋਜ ਵਿਕਲਪਾਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦਾ ਸੀ.

ਅੱਗੇ, ਖੋਜ ਅਤੇ ਉਹਨਾਂ ਦੇ ਖੰਡਨ ਲਈ ਹੱਲ ਜੋੜਿਆਂ ਵਿੱਚ ਆਉਣਗੇ।

2.1 ਆਉ ਸਧਾਰਨ ਸ਼ੁਰੂ ਕਰੀਏ

ਜਿਵੇਂ ਪਹਿਲਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਤੁਸੀਂ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲੋਡ ਕਰਨ ਲਈ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ LD_PRELOAD ਜਾਂ ਇਸਨੂੰ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਲਿਖ ਕੇ /etc/ld.so.preload. ਆਉ ਦੋ ਸਧਾਰਨ ਡਿਟੈਕਟਰ ਬਣਾਉ.

ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਸੈੱਟ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲ ਦੀ ਜਾਂਚ ਕਰਨਾ ਹੈ:

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

ਦੂਜਾ ਇਹ ਜਾਂਚ ਕਰਨਾ ਹੈ ਕਿ ਕੀ ਫਾਈਲ ਖੁੱਲ੍ਹੀ ਹੈ:

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

ਆਓ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਲੋਡ ਕਰੀਏ:

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

ਇੱਥੇ ਅਤੇ ਹੇਠਾਂ, [+] ਸਫਲ ਖੋਜ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
ਇਸ ਅਨੁਸਾਰ, [-] ਦਾ ਅਰਥ ਹੈ ਖੋਜ ਨੂੰ ਬਾਈਪਾਸ ਕਰਨਾ।

ਅਜਿਹਾ ਡਿਟੈਕਟਰ ਕਿੰਨਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ? ਆਓ ਪਹਿਲਾਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ:

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

ਇਸੇ ਤਰ੍ਹਾਂ, ਅਸੀਂ ਚੈੱਕ ਤੋਂ ਛੁਟਕਾਰਾ ਪਾਉਂਦੇ ਹਾਂ ਓਪਨ:

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

ਹਾਂ, ਫਾਈਲ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੇ ਹੋਰ ਤਰੀਕੇ ਇੱਥੇ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ, open64, ਸਟੈਟ ਆਦਿ, ਪਰ, ਅਸਲ ਵਿੱਚ, ਉਹਨਾਂ ਨੂੰ ਧੋਖਾ ਦੇਣ ਲਈ ਕੋਡ ਦੀਆਂ ਉਹੀ 5-10 ਲਾਈਨਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

2.2 ਚਲੋ ਅੱਗੇ ਵਧਦੇ ਹਾਂ

ਉੱਪਰ ਅਸੀਂ ਵਰਤਿਆ getenv() ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ LD_PRELOAD, ਪਰ ਪਹੁੰਚਣ ਲਈ ਇੱਕ ਹੋਰ "ਨੀਵੇਂ-ਪੱਧਰ" ਦਾ ਤਰੀਕਾ ਵੀ ਹੈ ENV- ਵੇਰੀਏਬਲ। ਅਸੀਂ ਵਿਚਕਾਰਲੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਾਂਗੇ, ਪਰ ਐਰੇ ਦਾ ਹਵਾਲਾ ਦੇਵਾਂਗੇ ** ਵਾਤਾਵਰਣ, ਜੋ ਵਾਤਾਵਰਣ ਦੀ ਇੱਕ ਕਾਪੀ ਸਟੋਰ ਕਰਦਾ ਹੈ:

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

ਕਿਉਂਕਿ ਇੱਥੇ ਅਸੀਂ ਮੈਮੋਰੀ ਤੋਂ ਸਿੱਧਾ ਡੇਟਾ ਪੜ੍ਹ ਰਹੇ ਹਾਂ, ਅਜਿਹੀ ਕਾਲ ਨੂੰ ਰੋਕਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ, ਅਤੇ ਸਾਡੀ undetect_getenv ਇਹ ਹੁਣ ਘੁਸਪੈਠ ਦੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਦਖਲ ਨਹੀਂ ਦਿੰਦਾ।

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

ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਸਮੱਸਿਆ ਹੱਲ ਹੋ ਗਈ ਹੈ? ਇਹ ਅਜੇ ਤਾਂ ਸ਼ੁਰੂਆਤ ਹੈ।

ਪ੍ਰੋਗਰਾਮ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ LD_PRELOAD ਹੈਕਰਾਂ ਨੂੰ ਹੁਣ ਮੈਮੋਰੀ ਵਿੱਚ ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਯਾਨੀ ਉਹ ਇਸਨੂੰ ਪੜ੍ਹ ਸਕਦੇ ਹਨ ਅਤੇ ਕਿਸੇ ਵੀ ਨਿਰਦੇਸ਼ ਨੂੰ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਮਿਟਾ ਸਕਦੇ ਹਨ। ਬੇਸ਼ੱਕ, ਮੈਮੋਰੀ ਵਿੱਚ ਇੱਕ ਐਰੇ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨਾ, ਘੱਟੋ ਘੱਟ, ਇੱਕ ਮਾੜੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਸ਼ੈਲੀ ਹੈ, ਪਰ ਇਹ ਕਿਸੇ ਅਜਿਹੇ ਵਿਅਕਤੀ ਨੂੰ ਕਿਵੇਂ ਰੋਕ ਸਕਦਾ ਹੈ ਜੋ ਅਸਲ ਵਿੱਚ ਸਾਡੀ ਭਲਾਈ ਨਹੀਂ ਚਾਹੁੰਦਾ ਹੈ?

ਅਜਿਹਾ ਕਰਨ ਲਈ ਸਾਨੂੰ ਆਪਣਾ ਫਰਜ਼ੀ ਫੰਕਸ਼ਨ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਇਸ ਵਿੱਚ(), ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਇੰਸਟਾਲ ਨੂੰ ਰੋਕਦੇ ਹਾਂ LD_PRELOAD ਅਤੇ ਇਸਨੂੰ ਸਾਡੇ ਲਿੰਕਰ ਨੂੰ ਭੇਜੋ:

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

ਅਸੀਂ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਜਾਂਚ ਕਰਦੇ ਹਾਂ:

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

ਹਾਲਾਂਕਿ, ਮੈਮੋਰੀ ਆਖਰੀ ਥਾਂ ਨਹੀਂ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਇੱਕ ਬਦਲ ਲੱਭ ਸਕਦੇ ਹੋ LD_PRELOAD, ਵੀ ਹੈ /proc/. ਆਉ ਸਪੱਸ਼ਟ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ /proc/{PID}/ਵਾਤਾਵਰਣ.

ਵਾਸਤਵ ਵਿੱਚ, ਲਈ ਇੱਕ ਵਿਆਪਕ ਹੱਲ ਹੈ ਪਤਾ ਲਗਾਉਣਾ ** ਵਾਤਾਵਰਣ и /proc/self/environ. ਸਮੱਸਿਆ "ਗਲਤ" ਵਿਵਹਾਰ ਹੈ unsetenv(env).

ਸਹੀ ਚੋਣ

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
$

ਪਰ ਆਓ ਕਲਪਨਾ ਕਰੀਏ ਕਿ ਸਾਨੂੰ ਇਹ ਨਹੀਂ ਮਿਲਿਆ ਅਤੇ /proc/self/environ "ਸਮੱਸਿਆ ਵਾਲਾ" ਡੇਟਾ ਰੱਖਦਾ ਹੈ।

ਪਹਿਲਾਂ ਆਪਣੇ ਪਿਛਲੇ "ਭੇਸ" ਨਾਲ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ:

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

ਬਿੱਲੀ ਫਾਇਲ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ ਉਸੇ ਨੂੰ ਵਰਤਦਾ ਹੈ ਖੋਲ੍ਹੋ(), ਇਸ ਲਈ ਹੱਲ ਉਸੇ ਤਰ੍ਹਾਂ ਦਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਹੀ ਸੈਕਸ਼ਨ 2.1 ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ ਹੁਣ ਅਸੀਂ ਇੱਕ ਅਸਥਾਈ ਫਾਈਲ ਬਣਾਉਂਦੇ ਹਾਂ ਜਿੱਥੇ ਅਸੀਂ ਸੱਚੀ ਮੈਮੋਰੀ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਬਿਨਾਂ ਲਾਈਨਾਂ ਦੇ ਕਾਪੀ ਕਰਦੇ ਹਾਂ 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);
}

ਅਤੇ ਇਹ ਪੜਾਅ ਪਾਸ ਕੀਤਾ ਗਿਆ ਹੈ:

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

ਅਗਲਾ ਸਪੱਸ਼ਟ ਸਥਾਨ ਹੈ /proc/self/maps. ਇਸ 'ਤੇ ਟਿਕੇ ਰਹਿਣ ਦਾ ਕੋਈ ਮਤਲਬ ਨਹੀਂ ਹੈ। ਹੱਲ ਬਿਲਕੁਲ ਪਿਛਲੇ ਇੱਕ ਦੇ ਸਮਾਨ ਹੈ: ਫਾਈਲ ਤੋਂ ਡੇਟਾ ਨੂੰ ਕਾਪੀ ਕਰੋ libc.so и ld.so.

2.4 ਚੋਕਪੁਆਇੰਟ ਤੋਂ ਵਿਕਲਪ

ਮੈਨੂੰ ਖਾਸ ਤੌਰ 'ਤੇ ਇਸਦੀ ਸਾਦਗੀ ਲਈ ਇਹ ਹੱਲ ਪਸੰਦ ਆਇਆ. ਅਸੀਂ ਸਿੱਧੇ ਲੋਡ ਕੀਤੇ ਫੰਕਸ਼ਨਾਂ ਦੇ ਪਤਿਆਂ ਦੀ ਤੁਲਨਾ ਕਰਦੇ ਹਾਂ libc, ਅਤੇ "ਅੱਗੇ" ਪਤੇ।

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

ਇੰਟਰਸੈਪਸ਼ਨ ਨਾਲ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ "ਓਪਨ()" ਅਤੇ ਜਾਂਚ ਕਰੋ:

$ export LD_PRELOAD=$PWD/ld_undetect_open.so
$ ./detect_chokepoint
LD_PRELOAD (syscall - open) [+]
Libc address: 0x7fa86893b160
Next address: 0x7fa868a26135

ਖੰਡਨ ਹੋਰ ਵੀ ਸਰਲ ਨਿਕਲਿਆ:

#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 ਸਿਸਕੈਲਸ

ਇਹ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਸਭ ਹੈ, ਪਰ ਅਸੀਂ ਫਿਰ ਵੀ ਭਟਕ ਜਾਵਾਂਗੇ. ਜੇਕਰ ਅਸੀਂ ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਸਿੱਧਾ ਕਰਨਲ 'ਤੇ ਭੇਜਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਪੂਰੀ ਇੰਟਰਸੈਪਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਾਈਪਾਸ ਕਰ ਦੇਵੇਗਾ। ਹੇਠਾਂ ਦਿੱਤਾ ਹੱਲ ਹੈ, ਬੇਸ਼ਕ, ਆਰਕੀਟੈਕਚਰ-ਨਿਰਭਰ (x86_64). ਆਉ ਇੱਕ ਖੁੱਲਣ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਇਸਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ 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) [+]

ਅਤੇ ਇਸ ਸਮੱਸਿਆ ਦਾ ਇੱਕ ਹੱਲ ਹੈ. ਤੋਂ ਅੰਸ਼ ਆਦਮੀ'ਏ:

ptrace ਇੱਕ ਅਜਿਹਾ ਟੂਲ ਹੈ ਜੋ ਇੱਕ ਪੇਰੈਂਟ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਿਸੇ ਹੋਰ ਪ੍ਰਕਿਰਿਆ ਦੀ ਪ੍ਰਗਤੀ ਨੂੰ ਦੇਖਣ ਅਤੇ ਨਿਯੰਤਰਣ ਕਰਨ, ਇਸਦੇ ਡੇਟਾ ਅਤੇ ਰਜਿਸਟਰਾਂ ਨੂੰ ਵੇਖਣ ਅਤੇ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਫੰਕਸ਼ਨ ਡੀਬੱਗਿੰਗ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਬ੍ਰੇਕਪੁਆਇੰਟ ਬਣਾਉਣ ਅਤੇ ਸਿਸਟਮ ਕਾਲਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਪੇਰੈਂਟ ਪ੍ਰਕਿਰਿਆ ਪਹਿਲਾਂ ਫੋਰਕ (2) ਨੂੰ ਕਾਲ ਕਰਕੇ ਟਰੇਸਿੰਗ ਸ਼ੁਰੂ ਕਰ ਸਕਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਨਤੀਜੇ ਵਜੋਂ ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆ PTRACE_TRACEME ਨੂੰ ਚਲਾ ਸਕਦੀ ਹੈ, (ਆਮ ਤੌਰ 'ਤੇ) exec(3) ਨੂੰ ਲਾਗੂ ਕਰਕੇ। ਦੂਜੇ ਪਾਸੇ, ਇੱਕ ਪੇਰੈਂਟ ਪ੍ਰਕਿਰਿਆ PTRACE_ATTACH ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੀ ਹੈ।

ਜਦੋਂ ਟਰੇਸਿੰਗ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਬੱਚੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਹਰ ਵਾਰ ਸਿਗਨਲ ਪ੍ਰਾਪਤ ਕਰਨ 'ਤੇ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ, ਭਾਵੇਂ ਸਿਗਨਲ ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। (ਅਪਵਾਦ SIGKILL ਹੈ, ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ।) ਮਾਤਾ-ਪਿਤਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਉਡੀਕ (2) ਨੂੰ ਕਾਲ ਕਰਕੇ ਇਸ ਬਾਰੇ ਸੂਚਿਤ ਕੀਤਾ ਜਾਵੇਗਾ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਹ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਬੱਚੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਦੇਖ ਅਤੇ ਸੋਧ ਸਕਦਾ ਹੈ। ਮਾਤਾ-ਪਿਤਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਫਿਰ ਬੱਚੇ ਨੂੰ ਦੌੜਨਾ ਜਾਰੀ ਰੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ, ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਸ ਨੂੰ ਭੇਜੇ ਗਏ ਸਿਗਨਲ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ ਜਾਂ ਇਸ ਦੀ ਬਜਾਏ ਕੋਈ ਹੋਰ ਸਿਗਨਲ ਭੇਜਣਾ)।

ਇਸ ਤਰ੍ਹਾਂ, ਹੱਲ ਪ੍ਰਕਿਰਿਆ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨਾ ਹੈ, ਹਰੇਕ ਸਿਸਟਮ ਕਾਲ ਤੋਂ ਪਹਿਲਾਂ ਇਸ ਨੂੰ ਬੰਦ ਕਰਨਾ ਅਤੇ, ਜੇ ਜਰੂਰੀ ਹੈ, ਤਾਂ ਥਰਿੱਡ ਨੂੰ ਹੁੱਕ ਫੰਕਸ਼ਨ ਤੇ ਰੀਡਾਇਰੈਕਟ ਕਰਨਾ ਹੈ।

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

ਅਸੀਂ ਜਾਂਚਦੇ ਹਾਂ:

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

+0-0=5

ਬਹੁਤ ਸਾਰਾ ਧੰਨਵਾਦ

ਚਾਰਲਸ ਹੁਬੇਨ
ਚੋਕਪੁਆਇੰਟ
ValdikSS
ਫਿਲਿਪ ਟੂਵੇਨ
derhass

, ਜਿਨ੍ਹਾਂ ਦੇ ਲੇਖਾਂ, ਸਰੋਤਾਂ ਅਤੇ ਟਿੱਪਣੀਆਂ ਨੇ ਇਸ ਨੋਟ ਨੂੰ ਇੱਥੇ ਪ੍ਰਗਟ ਕਰਨ ਲਈ ਮੇਰੇ ਨਾਲੋਂ ਕਿਤੇ ਵੱਧ ਕੀਤਾ ਹੈ।

ਸਰੋਤ: www.habr.com