前言

Tinyproxy 是一个轻量级的 HTTP/HTTPS 代理服务器，主要用于提供基本的代理功能，同时占用较少的系统资源。

CVE-2023-49606 是 http 标头导致的 UAF，比较新鲜，所以分析下

环境搭建

先在 https://github.com/tinyproxy/tinyproxy 拉取 1.11.1 版本的 tinyproxy。

执行以下命令进行编译

./autogen.sh

./configure --enable-debug
make
sudo make install

利用以下命令启动

/usr/local/bin/tinyproxy

然后访问 8888 端口即可

调试方面我选择直接利用 gdb attach 上去

先将对应程序拉取出来 IDA 进行反汇编

接着查看进程号

调试之前需要将机器的 ptrace_scope 设置为 0

sudo sh -c 'echo "0" > /proc/sys/kernel/yama/ptrace_scope'

就可以愉快调试

漏洞分析

通过 git 提交记录 https://github.com/tinyproxy/tinyproxy/commit/12a8484265f7b00591293da492bb3c9987001956 ，可以看到 diff 结果

、

为了方便，把两个版本的源码下载通过 vscode diff

可以看到 diff 结果有好几处不同

修复的地方也被作者写注释了

接着通过网上搜集信息，在 https://talosintelligence.com/vulnerability_reports/TALOS-2023-1889 该文章披露了漏洞细节，所以跟着再走下流程，把 poc 写出来

首先是正常的交互，tinyproxy 是一个代理程序，所以，host 是代理去往目标地址，正常的交互最简单的请求包如下

import requests

url = 'http://127.0.0.1:8888'
headers = {'Connection': 'close', 'Host': '127.0.0.1:8000'}

response = requests.get(url, headers=headers)

print(response.text)

比如我在 Desktop 下利用 python 开启了一个 http 服务器

那么上面请求包的返回结果就是 python http 服务器的内容

host 乱填时候，一直报 500，以为是软件问题，又通过 apt 安装了一个，还是一样的问题，后面我也是看日志才知道 host 是目标服务器地址，host 乱填时候，日志一直报 connect fail，所以就给他填了个能正常访问的地址

其漏洞点在于 connection 关键词的处理，从下面的 diff 中可以看到，函数名为 remove_connection_headers ，是用来处理释放 connection 操作的

结合调试中，可以确定 data 和 ptr 是 connection 关键词的值

然后会利用 orderedmap_remove 函数从 head 的哈希结果表中去除 connetction:close

orderedmap_remove 是一个先计算哈希，再根据哈希结果从哈希表删除哈希结果的函数

1. 会利用 htab_find2 函数取计算 key 的哈希，并且判断结果是否在哈希表中
2. 如果在，那么利用 sblist_get 函数获取哈希表中键对应的键值的堆指针
3. 利用 free 释放值的堆指针
4. 利用 while 处理哈希链表
5. 将键也从哈希表中删除
6. 利用 free 释放键的堆指针

当请求包包含 connection:close 时候，上面一张 gdb 调试截图中因为哈希表中没有 close 关键词，会在 if(!v) return 0 直接退出，进入下面的 orderdmap_remove 函数

如在 gdb 中

poc 如下，如果我们修改请求包中的 connection:close 为 connection:connection 时候

import requests

url = 'http://127.0.0.1:8888'
headers = {'Connection': 'Connection', 'Host': '127.0.0.1:8000'}

response = requests.get(url, headers=headers)

print(response.text)

可以看到，在删除键的时候，先对 Connection 释放一次，这个 Connection 是 Connection 键的值

接下来继续重点看该函数

在这个函数中是不强制区分键和值的，因此 Connect 可以作为键使用的，所以，在 orderedmap_remove 函数处理时候，sblist_get 函数获取键对应的值指针时候，拿到是 Connection 作为键时候的堆指针。

本来上面那一步应该要释放 Connection 作为值的堆指针，但是却因为哈希原因错乱了，这就导致在后面利用 htab_delete 去删除键的哈希时候，会把已经 free 的 Connection 作为键的堆指针给删去。

可以看到已经被放入 bin 了

在这里时候，还不会发生 crash，到了程序末尾，利用 orderedmap_destroy 函数去 free 删去的键堆指针时候，就会发生 double free 导致 crash

实质上是调用 orderedmap_destroy_contents 循环 free 指针，而后 free 哈希表

就在这里导致了 crash

漏洞利用

因为该程序是动态编译，其链接的是本地的 libc.so ，因此堆管理方式取决于 libc 中堆的实现，考虑到该程序一般是运行在 linux 服务器，因此尝试在 ptmalloc glibc_2.27 以上环境进行利用，没有 tcache bin 机制的 ubuntu16 就太老了。

由于是 double free 漏洞，如果要完成利用，那么需要

1.控制堆，比如令其在 fastbin 上进行 double free，并且需要能操控 double free 后的堆块

2.可能泄露内存信息

由于是一个堆漏洞，为了写利用，需要把整个程序的大概实现都看一下。

child.c 中的 child_main_loop 函数是起始函数，在这个函数中，实现了对child 结构体（单线程中存放信息的结构体）和 childs 结构体（存放所有 chlid）的初始化

void child_main_loop (void)
{
        // 其它省略代码

        childs = sblist_new(sizeof (struct child*), config->maxclients);

        // 其它省略代码

        /*
         * We have to wait for connections on multiple fds,
         * so use select/poll/whatever.
         */
        while (!config->quit) {

                collect_threads();

                // 其它省略代码

                /*
                 * We have a socket that is readable.
                 * Continue handling this connection.
                 */

                clilen = sizeof(cliaddr_storage);
                connfd = accept (listenfd, cliaddr, &clilen);


                /*
                 * Make sure no error occurred...
                 */
                if (connfd < 0) {
                        log_message (LOG_ERR,
                                     "Accept returned an error (%s) ... retrying.",
                                     strerror (errno));
                        continue;
                }

                child = safecalloc(1, sizeof(struct child));
                if (!child) {
oom:
                        close(connfd);
                        log_message (LOG_CRIT,
                                     "Could not allocate memory for child.");
                        usleep(16); /* prevent 100% CPU usage in OOM situation */
                        continue;
                }

                child->done = 0;

                if (!sblist_add(childs, &child)) {
                        free(child);
                        goto oom;
                }

                conn_struct_init(&child->conn);
                child->conn.client_fd = connfd;

                memcpy(&child->client.addr, &cliaddr_storage, sizeof(cliaddr_storage));

                attrp = 0;
                if (pthread_attr_init(&attr) == 0) {
                        attrp = &attr;
                        pthread_attr_setstacksize(attrp, 256*1024);
                }

                if (pthread_create(&child->thread, attrp, child_thread, child) != 0) {
                        sblist_delete(childs, sblist_getsize(childs) -1);
                        free(child);
                        goto oom;
		}
        }
	safefree(fds);
}

如上，主要是申请了 child 结构体，将 done 置 0，表示未被启动，并且利用 conn_struct_init 函数初始化，同时赋予 child->conn.client_fd 为被代理机器 socket 接受到的 connfd。后面就是开始线程启动 child_thread，同时将线程标志放入 child 结构体中的 thread

child 结构体如下

struct child {
	pthread_t thread;
	struct client client;
	struct conn_s conn;
	volatile int done;
};

重点关注是存放 http 信息的 conn 结构体，定义如下。

struct conn_s {
        int client_fd;
        int server_fd;

        struct buffer_s *cbuffer;
        struct buffer_s *sbuffer;

        /* The request line (first line) from the client */
        char *request_line;

        /* Booleans */
        unsigned int connect_method;
        unsigned int show_stats;

        /*
         * This structure stores key -> value mappings for substitution
         * in the error HTML files.
         */
        struct htab *error_variables;

        int error_number;
        char *error_string;

        /* A Content-Length value from the remote server */
        struct {
                long int server;
                long int client;
        } content_length;

        /*
         * Store the server's IP (for BindSame)
         */
        char *server_ip_addr;

        /*
         * Store the client's IP information
         */
        char *client_ip_addr;

        /*
         * Store the incoming request's HTTP protocol.
         */
        struct {
                unsigned int major;
                unsigned int minor;
        } protocol;

#ifdef REVERSE_SUPPORT
        /*
         * Place to store the current per-connection reverse proxy path
         */
        char *reversepath;
#endif

        /*
         * Pointer to upstream proxy.
         */
        struct upstream *upstream_proxy;
};

有注释就不解释了

child_thread 函数是执行 handle_connection 函数，同时闯入 conn 和 客户端地址，置 done 为 1

static void* child_thread(void* data)
{
	struct child *c = data;
	handle_connection (&c->conn, &c->client.addr);
	c->done = 1;
	return NULL;
}

handle_connection 函数则执行主要功能

先是接受客户端发送的 http 请求，同时处理 http 标头

if (read_request_line (connptr) < 0) {
               update_stats (STAT_BADCONN);
               goto done;
       }

       /*
        * The "hashofheaders" store the client's headers.
        */
       hashofheaders = orderedmap_create (HEADER_BUCKETS);
       if (hashofheaders == NULL) {
               update_stats (STAT_BADCONN);
               indicate_http_error (connptr, 503, "Internal error",
                                    "detail",
                                    "An internal server error occurred while processing "
                                    "your request. Please contact the administrator.",
                                    NULL);
               HC_FAIL();
       }

       /*
        * Get all the headers from the client in a big hash.
        */
       if (get_all_headers (connptr->client_fd, hashofheaders) < 0) {
               log_message (LOG_WARNING,
                            "Could not retrieve all the headers from the client");
               indicate_http_error (connptr, 400, "Bad Request",
                                    "detail",
                                    "Could not retrieve all the headers from "
                                    "the client.", NULL);
               update_stats (STAT_BADCONN);
               HC_FAIL();
       }
       got_headers = 1;

可以看到，显示利用 orderedmap_create 函数创建了一个哈希链表头，接着利用 get_all_headers 函数去把标头插入哈希链表中

接着再检测是否存在上游代理，如果存在则是通过 connect_to_upstream 去通过上游代理连接目标服务器，否则是直接通过 tinyproxy 运行服务器去连接目标服务器

connptr->upstream_proxy = UPSTREAM_HOST (request->host);
        if (connptr->upstream_proxy != NULL) {
                if (connect_to_upstream (connptr, request) < 0) {
                        HC_FAIL();
                }
        } else {
                connptr->server_fd = opensock (request->host, request->port,
                                               connptr->server_ip_addr);
                if (connptr->server_fd < 0) {
                        indicate_http_error (connptr, 500, "Unable to connect",
                                             "detail",
                                             PACKAGE_NAME " "
                                             "was unable to connect to the remote web server.",
                                             "error", strerror (errno), NULL);
                        HC_FAIL();
                }

                log_message (LOG_CONN,
                             "Established connection to host \"%s\" using "
                             "file descriptor %d.", request->host,
                             connptr->server_fd);

                if (!connptr->connect_method)
                        establish_http_connection (connptr, request);
        }

接下来则是执行

if (process_client_headers (connptr, hashofheaders) < 0) {
                update_stats (STAT_BADCONN);
                log_message (LOG_INFO,
                             "process_client_headers failed: %s. host \"%s\" using "
                             "file descriptor %d.", strerror(errno),
                             request->host,
                             connptr->server_fd);

                HC_FAIL();
        }

process_client_headers 函数功能有两个，一个是处理特殊的标头信息，比如 Content-Length ，connection，proxy-connection，同时发送标头，二是当 Content-Length 大于 0 时候，读入 post 数据

static int
process_client_headers (struct conn_s *connptr, orderedmap hashofheaders)
{
        static const char *skipheaders[] = {
                "host",
                "keep-alive",
                "proxy-connection",
                "te",
                "trailers",
                "upgrade"
        };
        int i;
        size_t iter;
        int ret = 0;

        char *data, *header;

        // 其它省略代码

        /*
         * See if there is a "Content-Length" header.  If so, again we need
         * to do a bit of processing.
         */
        connptr->content_length.client = get_content_length (hashofheaders);

        // 其它省略代码

        /*
         * See if there is a "Connection" header.  If so, we need to do a bit
         * of processing. :)
         */
        remove_connection_headers (hashofheaders);

        /*
         * Delete the headers listed in the skipheaders list
         */
        for (i = 0; i != (sizeof (skipheaders) / sizeof (char *)); i++) {
                orderedmap_remove (hashofheaders, skipheaders[i]);
        }

        /* Send, or add the Via header */
        ret = write_via_header (connptr->server_fd, hashofheaders,
                                connptr->protocol.major,
                                connptr->protocol.minor);
        // 其它省略代码

        /* Write the final "blank" line to signify the end of the headers */
        if (safe_write (connptr->server_fd, "\r\n", 2) < 0)
                return -1;

        /*
         * Spin here pulling the data from the client.
         */
PULL_CLIENT_DATA:
        if (connptr->content_length.client > 0) {
                ret = pull_client_data (connptr,
                                        connptr->content_length.client, 1);
        } else if (connptr->content_length.client == -2)
                ret = pull_client_data_chunked (connptr);

        return ret;
}

可以看到，先是获取了 content_length.client，然后是通过 remove_connection_headers 去释放 connection 和 proxy-connection 标头，这里也就是漏洞函数

remove_connection_headers 函数实现

static int remove_connection_headers (orderedmap hashofheaders)
{
        static const char *headers[] = {
                "connection",
                "proxy-connection"
        };

        char *data;
        char *ptr;
        ssize_t len;
        int i,j,df;

        for (i = 0; i != (sizeof (headers) / sizeof (char *)); ++i) {
                /* Look for the connection header.  If it's not found, return. */
                data = orderedmap_find(hashofheaders, headers[i]);

                if (!data)
                        return 0;

                len = strlen(data);

                /*
                 * Go through the data line and replace any special characters
                 * with a NULL.
                 */
                ptr = data;
                while ((ptr = strpbrk (ptr, "()<>@,;:\\\"/[]?={} \t")))
                        *ptr++ = '\0';

                /*
                 * All the tokens are separated by NULLs.  Now go through the
                 * token and remove them from the hashofheaders.
                 */
                ptr = data;
                while (ptr < data + len) {
                        df = 0;
                        /* check that ptr isn't one of headers to prevent
                           double-free (CVE-2023-49606) */
                        for (j = 0; j != (sizeof (headers) / sizeof (char *)); ++j)
                                if(!strcasecmp(ptr, headers[j])) df = 1;
                        if (!df) orderedmap_remove (hashofheaders, ptr);

                        /* Advance ptr to the next token */
                        ptr += strlen (ptr) + 1;
                        while (ptr < data + len && *ptr == '\0')
                                ptr++;
                }

                /* Now remove the connection header it self. */
                orderedmap_remove (hashofheaders, headers[i]);
        }

        return 0;
}

remove_connection_headers 只会去释放 connection 和 proxy-connection 标头，看到这里其实就差不多看完了，明显 gg 了。

后面就是通过 write_via_header 发送标头到目标服务器，释放非 connection 标头

接着说通过 pull_client_data 读 post 数据，一边读，一边往服务端发送

static int pull_client_data (struct conn_s *connptr, long int length, int iehack)
{
        char *buffer;
        ssize_t len;
        int ret;

        buffer =
            (char *) safemalloc (min (MAXBUFFSIZE, (unsigned long int) length));
        if (!buffer)
                return -1;

        do {
                len = safe_read (connptr->client_fd, buffer,
                                 max (MAXBUFFSIZE, (unsigned long int) length));
                if (len <= 0)
                        goto ERROR_EXIT;

                if (!connptr->error_variables) {
                        if (safe_write (connptr->server_fd, buffer, len) < 0)
                                goto ERROR_EXIT;
                }

                length -= len;
        } while (length > 0);

        if (iehack) {
                /*
                 * BUG FIX: Internet Explorer will leave two bytes (carriage
                 * return and line feed) at the end of a POST message.  These
                 * need to be eaten for tinyproxy to work correctly.
                 */
                ret = socket_nonblocking (connptr->client_fd);
                if (ret != 0) {
                        log_message(LOG_ERR, "Failed to set the client socket "
                                    "to non-blocking: %s", strerror(errno));
                        goto ERROR_EXIT;
                }
        
                len = recv (connptr->client_fd, buffer, 2, MSG_PEEK);
        
                ret = socket_blocking (connptr->client_fd);
                if (ret != 0) {
                        log_message(LOG_ERR, "Failed to set the client socket "
                                    "to blocking: %s", strerror(errno));
                        goto ERROR_EXIT;
                }
        
                if (len < 0 && errno != EAGAIN)
                        goto ERROR_EXIT;
        
                if ((len == 2) && CHECK_CRLF (buffer, len)) {
                        ssize_t bytes_read;
        
                        bytes_read = read (connptr->client_fd, buffer, 2);
                        if (bytes_read == -1) {
                                log_message
                                        (LOG_WARNING,
                                         "Could not read two bytes from POST message");
                        }
                }
        }

        safefree (buffer);
        return 0;

ERROR_EXIT:
        safefree (buffer);
        return -1;
}

handle_connection 函数的后面部分，则是通过 process_server_headers 函数读目标服务器的响应包发送到客户端，和上面分析过 process_client_headers 的差不多，就不继续详细分析了。

整个框架比较简单，通过审计代码可以知道。

1. 是线程执行，因此是使用的线程堆，而在这些代码中，明显没有往堆上申请存放什么结构体，堆上很干净，ptmalloc 下，要攻击只能通过寻常 CTF 中打 ptmalloc 堆的方式。同时是使用完就释放，很难构造堆风水。

2. 由于 1 讲到的线程堆使用后就释放，所以线程开始执行时，不会残留什么堆块，申请和释放堆块的操作只有标头处理时候会涉及，而 connection 和 proxy-connection 标头一定会在其它标头前面释放，并且 connection 和 proxy-connection 标头只有两个，那么无论如何，double free 时候，第一次 free 的堆块总是在 tcahce bin，因为我们无法去释放其它标头来堆满 tcache bin，所以是无法控制的 crash。

后面我试着 patch 成 libc 2.27_1.0 ，即使不会触发 double free 的错误，那么也会在后面直接 crash

这一个漏洞比较有趣的一个点是，如果目标服务器返回的响应包如果带有 poc，也是可以触发 crash 的，因为 process_server_headers 和 process_client_headers 差不多，但是同样的，process_client_headers 执行完之后，标头申请的堆块会被释放，process_server_headers 执行时，堆的初始环境和 process_client_headers 是一样的，同样无法完成利用。

当然可能是我比较菜，在 ptmalloc 高版本下没看到利用的可能，如果有大佬有想法，可以指教下。