竞态条件漏洞简介

浅浅的花香味﹌ 2021-07-28 17:20 459阅读 0赞

### 1 竞态条件漏洞 ###

下面的代码段属于某个特权程序（即 Set-UID 程序），它使用 Root 权限运行。

if (!access("/tmp/X", W_OK))
    {
        f = open("/tmp/X", O_WRITE);
        write_to_file(f);
    }
    else
    {
        /* the real user ID does not have access right */
        fprintf(stderr, "Permission denied\n");
    }

`access`系统该调用检查了真实 UID 或者 GID 是否拥有访问文件的权限，有的话返回 0。在代表真实 UID （而不是有效 UID）访问文件之前，该系统调用通常由 Set-UID 程序使用。

`open`系统调用也执行访问控制，但是仅仅检查有效 UID 或 GID 是否拥有访问文件的权限。

上面的程序想要写入文件`/tmp/X`。在这么做之前，它要确保，文件确实由真实 UID 写入。如果没有这种检查，程序可以写入这个文件，无论真实 UID 可不可以写入它，因为程序使用 Root 权限运行（即`open`所检查的有效 UID 是 Root）。

假设上面的程序执行的非常慢。执行程序中的每行语句需要一分钟。请思考下列问题：

你可以使用这个程序来覆盖其它文件，例如`/etc/passwd`嘛？

你不能修改该程序，但是你可以利用每两条语句之前的的一分钟。

`/tmp`目录的权限为`rwxrwxrwx`，这允许任何用户在里面创建文件或链接。

提示：`/tmp/X`不需要是真实文件，他可以是符号链接。

攻击策略：

如果我们让`/tmp/X`在第一行之前打印`/etc/passwd`，`access`调用就会发现，真实 UID 没有权限来修改`/etc/passwd`。因此，执行流会来到`else`分支。在第一行之前，`/tmp/X`必须是一个能被真实 UID 写入的文件。

显然，如果我们在第一行之后不做任何事情，`/tmp/X`会打开，攻击者不能获得任何东西。

让我们专注于第一行和第三行之前的时间间隔。由于我们假设，程序执行得很慢。我们在第一行之后，第三行之前有一分钟的间隔。使用这个时间间隔，我们可以删掉`/tmp/X`并且使用相同名称创建符号链接。并使其指向`/etc/passwd`。

如果我们这么做，会发生什么？

通过遵循符号链接，程序使用`open`来打开`/etc/passwd`。

`open`系统调用只检查有效 UID 或 GID 是否可以访问文件。由于这是个 Set-UID Root 程序，有效 UID 是 Root，它可以读写`/etc/passwd`。

因此，第四行实际上会写入文件`/etc/passwd`。如果写入文件的内容也可以由用户控制，攻击者就可以修改密码文件，并且最终获得 Root 权限。如果内容不能由用户控制，攻击者可以破坏密码文件，组织其他用户登入系统。

回到现实：这个程序执行得很快，并且我们没有一分钟时间间隔。我们可以做什么？

竞态条件攻击

使`/tmp/X`在访问和打开调用中，表现为两个文件。

在`access(/tmp/X, W_OK)`之前，`/tmp/X`就是`/tmp/X`。

在`access(/tmp/X, W_OK)`之后，将`/tmp/X`修改为`/etc/passwd`。

如何实现？

在两个调用之间只有很短的时间间隔。

检查和使用之间的间隔：TOCTOU

CPU 可能在`access`后进行上下文切换，之后执行其它进程。

如果攻击进程在上下文切换之间，得到了机会来执行这种攻击，攻击就会成功。

因为我们不能保证，第一行和第三行之间存在上下文切换，即使攻击程序在上下文切换期间，得到执行机会，攻击也可能失败。但是，如果执行一次不成功，我们可以多次执行攻击和目标程序。

提高成功率：竞态条件攻击的最关键步骤，出现在 TOCTOU 间隔中。由于我们不能修改漏洞程序，我们可以做的只有让我们的攻击程序和目标程序一起运行。并希望链接的时机正好就在间隔之内。不幸的是，我们不能完成完美的时间规划。因此，攻击是否成功是个概率。攻击成功的概率可能很低，如果间隔很小。我们如何提升概率呢？

通过执行多个 CPU 密集的程序来拖慢计算机。

创建多个攻击进程。

另一个例子（Set-UID 程序）：

file = "/tmp/X";
    fileExist = check_file_existence(file);
    if (fileExist == FALSE)
    {
        // The file does not exist, create it.
        f = open(file, O_CREAT);
    }

在 Unix 中，我们使用`open`系统调用来创建文件。

`open(file, O_CREAT)`在文件不存在时创建文件，如果文件存在，它只会打开文件。

为什么存在漏洞？

竞态条件：使文件在检查期间不存在，并使其在检查之后指向`/etc/passwd`。

### 2 预防措施 ###

方式

将检查和使用操作转为一条原子操作。如果我们可以使用一个系统调用来完成这种检查和使用的目的，我们就没有竞态条件。在多数操作系统中，系统条用不可以被另一个用户空间的进程大端，因此，在系统调用期间不可能有上下文切换。

在检查和使用操作期间，确保相同文件名指向相同文件（也就是相同的 inode）。

使赢得竞态条件的可能性非常低。

如果不是必要，不要使用太多的权限。

使用原子操作

如果系统调用可以在一条调用中执行检查和使用操作，它就是安全的，因为系统调用中不会发生上下文切换。

`open(file, O_CREAT | O_EXCL)`可以在一条原子指令中检查和打开文件。如果文件已经存在，它就会返回错误，否则它会创建文件。`mkstemp`函数会按照模板生成一个唯一的临时文件名称。这个函数使用`O_EXCL`来使用`open`。来防止竞态条件问题。

与之类似，我们可以为`open`创建另一个选项，来一起执行`access`和`open`。虽然这种选项不存在于 POSIX 标准中，但是它很容易实现。也就是，我们可以定义一个选项叫做`O_REAL_USER_ID`。当我们使用`open`调用`open(file, O WRITE | O REAL USER ID)`，我们让`open`检查有效和真实 UID，并仅当两个 UID 都有权限打开文件时，才打开文件。实际上，让 POSIX 标准委员会接收这个新的选项并不是很容易。

检查-使用-再检查方式

`lstat(file, &result)`可以获取文件状态。如果文件是个符号链接，它返回链接的状态（不是链接指向的文件）。在 TOCTOW 之前，我们可以使用它来检查文件状态。接着在间隔之后，执行另一个检查。如果结果不同，我们就检测到了竞态条件。让我们看看下面的解决方案：

struct stat statBefore, statAfter;
    
    lstat("/tmp/X", &statBefore);
    
    if (!access("/tmp/X", O_RDWR))    /* the real UID has access right */
    {
        f = open("/tmp/X", O_RDWR);
        lstat("/tmp/X", &statAfter);
    
        if (statAfter.st_ino == statBefore.st_ino)
        {  /* the I-node is still the same */
            Write_to_file(f)
        }
        else
        {
            perror("Race Condition Attacks!");
        }
    }
    else
    {
        fprintf(stderr, "Permission denied\n");
    }

但是，上面的解决方案不能工作（`open`和第二个\`lstat之间存在竞态条件漏洞）。为了利用这个漏洞，攻击者需要执行另个静态条件攻击，第一个在第二行和第三行之间，另一个在第三行和第四行之间。虽然赢得两次竞争的可能性低于前面的情况，但还是可能的。

为了修复漏洞，我们打算在文件描述符`f`上使用`lstat`，而不是在文件名称上。虽然`lstat`不能这样做，但是`fstat`可以。

#include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    
    int main()
    {
        struct stat statBefore, statAfter;
    
        lstat("/tmp/X", &statBefore);
        if (!access("/tmp/X", O_RDWR))   /* the real UID has access right */
        {
            int f = open("/tmp/X", O_RDWR);
            fstat(f, &statAfter);
            if (statAfter.st_ino == statBefore.st_ino)
            { /* the I-node is still the same */
                write_to_file(f);
            }
            else
            {
                perror("Race Condition Attacks!");
            }
        }
        else
        {
            fprintf(stderr, "Permission denied\n");
        }
    }

问题：`lstat`和`fstat`之间有没有竞态条件？如果在第一行使用符号链接（例如到`/etc/shadow`）。之后在第二行之前，快速切换到`/tmp/X`，之后在第三行之前再次快速切换会符号链接呢？

答案：这个攻击是不可行的。函数调用`lstat("/tmp/X",...)`返回链接的状态，如果`/tmp/X`是个符号链接，而不是链接所指向文件的状态。换句话说，当`/tnp/X`指向了`/etc/shadow`，由`lstat(/tmp/X,...)`返回的 inode 就是`/tmp/X`的 inode，但是由`fstat(f, ...)`返回的 unode 是文件的 inode（这里是`/etc/shadow`的 inode）。即使`/tmp/X`指向了`/etc/shadow`，这两个 inode 是不同的。

要注意：所有这类调用都有两个版本，一个用于文件名，另一个用于文件描述符（思考：如果`access`也可以用于文件描述符，解法会简单很多）。

检查-使用-重复方式：在几个迭代内重复访问和打开。在下面的示例中，攻击者需要赢得五个竞态条件（1~2，2~3，3~4，4~5，5~6）：

if (access("tmp/X", O_RDWR)) 
        goto error handling 
    else 
        f1 = open("/tmp/X", O_RDWR); 
    if (access("tmp/X", O_RDWR)) 
        goto error handling 
    else 
        f2 = open("/tmp/X", O_RDWR); 
    if (access("tmp/X", O_RDWR)) 
        goto error handling 
    else 
        f3 = open("/tmp/X", O_RDWR);
    
    // Check whether f1, f2, and f3 has the same i-node (using fstat)

基于最小权限原则：

在使用`access`和`open`的程序中，我们知道`open`比我们想要的更加强大（它只检查有效 UID），这就是我们需要使用`access`来确保我们没有滥用权限的原因。我们从竞态条件攻击中得到的启示，就是这种检查不是始终可靠。

另一个防止程序滥用权限的方法，就是不要给予程序权限。这就是最小权限原则的本质：如果我们暂时不需要这个权限，我们应该禁用他。如果我们永远都不需要这个权限，我们应该移除它。没有了权限，即使程序犯了一些错误，损失也会降低。

在 Unix 中，我们可以使用`seteuid`或者`setuid`系统调用，来开启、禁用或删除权限。

/* disable the root privilege */
    #include <unistd.h>
    #include <sys/types.h>
    uid_t real_uid = getuid(); // get real user id
    uid_t effective_uid = geteuid(); // get effective user id
    seteuid (real_uid);
    
    f = open("/tmp/X", O_WRITE);
    if (f != -1)
    {
        write_to_file(f);
    }
    else
    {
        fprintf(stderr, "Permission denied\n");
    }
    
    /* if needed, enable the root privilege */
    seteuid (effective_uid);