កំពុងរកមើល LD_PRELOAD

កំណត់ចំណាំនេះត្រូវបានសរសេរក្នុងឆ្នាំ 2014 ប៉ុន្តែខ្ញុំទើបតែស្ថិតនៅក្រោមការគាបសង្កត់លើ Habre ហើយវាមិនបានឃើញពន្លឺនៃថ្ងៃទេ។ ក្នុងអំឡុងពេលហាមឃាត់ខ្ញុំភ្លេចអំពីវា ប៉ុន្តែឥឡូវនេះខ្ញុំបានរកឃើញវានៅក្នុងសេចក្តីព្រាង។ ខ្ញុំបានគិតអំពីការលុបវា ប៉ុន្តែប្រហែលជាវានឹងមានប្រយោជន៍សម្រាប់នរណាម្នាក់។

ជាទូទៅអ្នកគ្រប់គ្រងថ្ងៃសុក្របន្តិចអានលើប្រធានបទនៃការស្វែងរក "រួមបញ្ចូល" 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 ./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. ការឈឺចាប់នៃការស្វែងរក

ដោយដឹងពីការគំរាមកំហែងដែលអាចកើតមាន យើងចង់រកឃើញនោះ។ ផ្ទុកជាមុន វាត្រូវបានអនុវត្ត។ វាច្បាស់ណាស់ថាវិធីល្អបំផុតដើម្បីរកឱ្យឃើញគឺរុញវាទៅក្នុងខឺណែល ប៉ុន្តែខ្ញុំចាប់អារម្មណ៍លើជម្រើសនៃការរកឃើញនៅក្នុងតំបន់អ្នកប្រើប្រាស់។

បន្ទាប់មក ដំណោះស្រាយសម្រាប់ការរកឃើញ និងការបដិសេធរបស់ពួកគេនឹងមកជាគូ។

២.១. ចូរចាប់ផ្តើមសាមញ្ញ

ដូចដែលបានរៀបរាប់ខាងលើ អ្នកអាចបញ្ជាក់បណ្ណាល័យដែលត្រូវផ្ទុកដោយប្រើអថេរ 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) [-]

បាទ/ចាស វិធីផ្សេងទៀតដើម្បីចូលប្រើឯកសារអាចត្រូវបានប្រើនៅទីនេះ ដូចជា បើក 64, ស្ថិតិ ជាដើម។ ប៉ុន្តែតាមពិត លេខកូដ 5-10 ដូចគ្នាគឺត្រូវការដើម្បីបញ្ឆោតពួកគេ។

២.២. តោះបន្តទៅមុខទៀត។

ខាងលើយើងបានប្រើ getenv() ដើម្បីទទួលបានតម្លៃ LD_PRELOADប៉ុន្តែក៏មានវិធី "កម្រិតទាប" បន្ថែមទៀតដើម្បីទៅដល់ អេនវី- អថេរ។ យើង​នឹង​មិន​ប្រើ​មុខងារ​កម្រិត​មធ្យម​ទេ ប៉ុន្តែ​នឹង​យោង​ទៅ​លើ​អារេ ** បរិស្ថានដែលរក្សាទុកច្បាប់ចម្លងនៃបរិស្ថាន៖

#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 ពួក Hacker លែងត្រូវការវានៅក្នុងអង្គចងចាំទៀតហើយ ពោលគឺពួកគេអាចអានវា និងលុបវាមុនពេលប្រតិបត្តិការណែនាំណាមួយ។ ជាការពិតណាស់ ការកែសម្រួលអារេនៅក្នុងអង្គចងចាំ ជាអប្បបរមា រចនាប័ទ្មសរសេរកម្មវិធីមិនល្អ ប៉ុន្តែតើនេះអាចបញ្ឈប់នរណាម្នាក់ដែលពិតជាមិនប្រាថ្នាយើងយ៉ាងដូចម្ដេច?

ដើម្បីធ្វើដូចនេះយើងត្រូវបង្កើតមុខងារក្លែងក្លាយផ្ទាល់ខ្លួនរបស់យើង។ នៅ​ក្នុង​វា()ដែលយើងស្ទាក់ចាប់បានដំឡើង 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) [-]

២.៣. /proc/ខ្លួនឯង/

ទោះជាយ៉ាងណាក៏ដោយ ការចងចាំមិនមែនជាកន្លែងចុងក្រោយដែលអ្នកអាចស្វែងរកការជំនួសបានទេ។ 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 и អិល.

២.៤. ជម្រើសពី Chokepoint

ជាពិសេសខ្ញុំចូលចិត្តដំណោះស្រាយនេះសម្រាប់ភាពសាមញ្ញរបស់វា។ យើងប្រៀបធៀបអាសយដ្ឋាននៃមុខងារដែលបានផ្ទុកដោយផ្ទាល់ពី 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) [-]

២.៥. Syscalls

វាហាក់ដូចជាថានេះគឺទាំងអស់ ប៉ុន្តែយើងនឹងនៅតែជួបបញ្ហា។ ប្រសិនបើយើងដឹកនាំការហៅប្រព័ន្ធដោយផ្ទាល់ទៅខឺណែល វានឹងរំលងដំណើរការស្ទាក់ចាប់ទាំងមូល។ ជាការពិតណាស់ ដំណោះស្រាយខាងក្រោមគឺអាស្រ័យលើស្ថាបត្យកម្ម (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) [+]

ហើយបញ្ហានេះមានដំណោះស្រាយ។ ដកស្រង់ចេញពី មួយ'A:

ptrace គឺជាឧបករណ៍ដែលអនុញ្ញាតឱ្យដំណើរការមេដើម្បីសង្កេត និងគ្រប់គ្រងដំណើរការនៃដំណើរការមួយផ្សេងទៀត មើល និងផ្លាស់ប្តូរទិន្នន័យ និងការចុះឈ្មោះរបស់វា។ ជាធម្មតាមុខងារនេះត្រូវបានប្រើដើម្បីបង្កើតចំណុចឈប់នៅក្នុងកម្មវិធីបំបាត់កំហុស និងត្រួតពិនិត្យការហៅតាមប្រព័ន្ធ។

ដំណើរការមេអាចចាប់ផ្តើមតាមដានដោយការហៅទូរសព្ទដំបូង fork(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

អរគុណច្រើន។

លោក Charles Hubain
ចំណុចឆក់
វ៉ាល់ឌីកអេសអេស
Philippe Teuwen
derhass

ដែលអត្ថបទ ប្រភព និងមតិយោបល់បានធ្វើច្រើនជាងអ្វីដែលខ្ញុំបានធ្វើ ដើម្បីធ្វើឱ្យចំណាំនេះលេចឡើងនៅទីនេះ។

ប្រភព: www.habr.com