From patchwork Tue Jan 18 09:07:28 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Siddhesh Poyarekar X-Patchwork-Id: 50140 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 6D7F4385803A for ; Tue, 18 Jan 2022 09:09:32 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6D7F4385803A DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1642496972; bh=4f/+oJ60A6btGs0y/AovUZlL67b42HER4nAIEoO+Qdo=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=sdCX1snm2OsO8hsFH/gwE410lcaku2VR6W3GJBAhvSNO0XzfmoWzUaf6+jff476eU 108ssa0Kb1uWBXN6aSVZX1f57CpNPhyDj97QHcQkBODcum8TmIjn+RcizPZ5/aWeWq cNpDr4uyLD5Owciz2GQVi+lBy36n74vXbn686Z18= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from antelope.elm.relay.mailchannels.net (antelope.elm.relay.mailchannels.net [23.83.212.4]) by sourceware.org (Postfix) with ESMTPS id 4EF16385803F for ; Tue, 18 Jan 2022 09:07:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 4EF16385803F X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from relay.mailchannels.net (localhost [127.0.0.1]) by relay.mailchannels.net (Postfix) with ESMTP id CE009120D6F; Tue, 18 Jan 2022 09:07:48 +0000 (UTC) Received: from pdx1-sub0-mail-a306.dreamhost.com (unknown [127.0.0.6]) (Authenticated sender: dreamhost) by relay.mailchannels.net (Postfix) with ESMTPA id 11F741214E9; Tue, 18 Jan 2022 09:07:47 +0000 (UTC) X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from pdx1-sub0-mail-a306.dreamhost.com (pop.dreamhost.com [64.90.62.162]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384) by 100.124.238.86 (trex/6.4.3); Tue, 18 Jan 2022 09:07:48 +0000 X-MC-Relay: Neutral X-MailChannels-SenderId: dreamhost|x-authsender|siddhesh@gotplt.org X-MailChannels-Auth-Id: dreamhost X-Macabre-Wide-Eyed: 1c43e595240ece89_1642496868457_2345270998 X-MC-Loop-Signature: 1642496868457:1946554460 X-MC-Ingress-Time: 1642496868457 Received: from rhbox.redhat.com (unknown [1.186.224.209]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: siddhesh@gotplt.org) by pdx1-sub0-mail-a306.dreamhost.com (Postfix) with ESMTPSA id 4JdNG851RTz1PR; Tue, 18 Jan 2022 01:07:44 -0800 (PST) To: libc-alpha@sourceware.org Subject: [PATCH 3/3] getcwd: Set errno to ERANGE for size == 1 (CVE-2021-3999) Date: Tue, 18 Jan 2022 14:37:28 +0530 Message-Id: <20220118090728.1825487-4-siddhesh@sourceware.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20220118090728.1825487-1-siddhesh@sourceware.org> References: <20220118090728.1825487-1-siddhesh@sourceware.org> MIME-Version: 1.0 X-Spam-Status: No, score=-3493.6 required=5.0 tests=BAYES_00, GIT_PATCH_0, JMQ_SPF_NEUTRAL, KAM_DMARC_NONE, KAM_DMARC_STATUS, KAM_SHORT, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NEUTRAL, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Siddhesh Poyarekar via Libc-alpha From: Siddhesh Poyarekar Reply-To: Siddhesh Poyarekar Cc: fweimer@redhat.com, Qualys Security Advisory Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" No valid path returned by getcwd would fit into 1 byte, so reject the size early and return NULL with errno set to ERANGE. This resolves BZ #28769. Signed-off-by: Qualys Security Advisory Signed-off-by: Siddhesh Poyarekar --- NEWS | 6 + sysdeps/posix/getcwd.c | 7 + sysdeps/unix/sysv/linux/Makefile | 7 +- sysdeps/unix/sysv/linux/getcwd.c | 7 + .../unix/sysv/linux/tst-getcwd-smallbuff.c | 245 ++++++++++++++++++ 5 files changed, 271 insertions(+), 1 deletion(-) create mode 100644 sysdeps/unix/sysv/linux/tst-getcwd-smallbuff.c diff --git a/NEWS b/NEWS index 5c63cef156..a7f25aa5b1 100644 --- a/NEWS +++ b/NEWS @@ -167,6 +167,12 @@ Security related changes: function could result in a memory leak and potential access of uninitialized memory. + CVE-2021-3999: Passing a buffer of size exactly 1 byte to the getcwd + function may result in an off-by-one buffer underflow and overflow + when the current working directory is longer than PATH_MAX and also + corresponds to the / directory through an unprivileged mount + namespace. + The following bugs are resolved with this release: [The release manager will add the list generated by diff --git a/sysdeps/posix/getcwd.c b/sysdeps/posix/getcwd.c index e147a31a81..9d5787b6f4 100644 --- a/sysdeps/posix/getcwd.c +++ b/sysdeps/posix/getcwd.c @@ -187,6 +187,13 @@ __getcwd_generic (char *buf, size_t size) size_t allocated = size; size_t used; + /* A size of 1 byte is never useful. */ + if (allocated == 1) + { + __set_errno (ERANGE); + return NULL; + } + #if HAVE_MINIMALLY_WORKING_GETCWD /* If AT_FDCWD is not defined, the algorithm below is O(N**2) and this is much slower than the system getcwd (at least on diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile index 61acc1987d..d54753aae5 100644 --- a/sysdeps/unix/sysv/linux/Makefile +++ b/sysdeps/unix/sysv/linux/Makefile @@ -344,7 +344,12 @@ sysdep_routines += xstatconv internal_statvfs \ sysdep_headers += bits/fcntl-linux.h -tests += tst-fallocate tst-fallocate64 tst-o_path-locks +tests += \ + tst-fallocate \ + tst-fallocate64 \ + tst-getcwd-smallbuff \ + tst-o_path-locks \ +# tests endif ifeq ($(subdir),elf) diff --git a/sysdeps/unix/sysv/linux/getcwd.c b/sysdeps/unix/sysv/linux/getcwd.c index a6b5a7e8b0..5ff678d674 100644 --- a/sysdeps/unix/sysv/linux/getcwd.c +++ b/sysdeps/unix/sysv/linux/getcwd.c @@ -50,6 +50,13 @@ __getcwd (char *buf, size_t size) char *path; char *result; + /* A size of 1 byte is never useful. */ + if (size == 1) + { + __set_errno (ERANGE); + return NULL; + } + #ifndef NO_ALLOCATION size_t alloc_size = size; if (size == 0) diff --git a/sysdeps/unix/sysv/linux/tst-getcwd-smallbuff.c b/sysdeps/unix/sysv/linux/tst-getcwd-smallbuff.c new file mode 100644 index 0000000000..6b2b57f4f7 --- /dev/null +++ b/sysdeps/unix/sysv/linux/tst-getcwd-smallbuff.c @@ -0,0 +1,245 @@ +/* Verify that getcwd returns ERANGE for size 1 byte and does not underflow + buffer when the CWD is too long and is also a mount target of /. See bug + #28769 or CVE-2021-3999 for more context. + Copyright The GNU Toolchain Authors. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#ifndef PATH_MAX +# define PATH_MAX 1024 +#endif + +static char *base; +#define BASENAME "tst-getcwd-smallbuff" +#define MOUNT_NAME "mpoint" +static int sockfd[2]; + +static void +do_cleanup (void) +{ + support_chdir_toolong_temp_directory (base); + TEST_VERIFY_EXIT (rmdir (MOUNT_NAME) == 0); + free (base); +} + +static int +send_fd (const int sock, const int fd) +{ + struct msghdr msg; + union + { + struct cmsghdr hdr; + char buf[CMSG_SPACE (sizeof (int))]; + } cmsgbuf; + struct cmsghdr *cmsg; + struct iovec vec; + char ch = 'A'; + ssize_t n; + + memset (&msg, 0, sizeof (msg)); + memset (&cmsgbuf, 0, sizeof (cmsgbuf)); + msg.msg_control = &cmsgbuf.buf; + msg.msg_controllen = sizeof (cmsgbuf.buf); + + cmsg = CMSG_FIRSTHDR (&msg); + cmsg->cmsg_len = CMSG_LEN (sizeof (int)); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + *(int *) CMSG_DATA (cmsg) = fd; + + vec.iov_base = &ch; + vec.iov_len = 1; + msg.msg_iov = &vec; + msg.msg_iovlen = 1; + + while ((n = sendmsg (sock, &msg, 0)) == -1 && errno == EINTR); + if (n != 1) + return -1; + return 0; +} + +static int +recv_fd (const int sock) +{ + struct msghdr msg; + union + { + struct cmsghdr hdr; + char buf[CMSG_SPACE(sizeof(int))]; + } cmsgbuf; + struct cmsghdr *cmsg; + struct iovec vec; + ssize_t n; + char ch = '\0'; + int fd = -1; + + memset (&msg, 0, sizeof (msg)); + vec.iov_base = &ch; + vec.iov_len = 1; + msg.msg_iov = &vec; + msg.msg_iovlen = 1; + + memset (&cmsgbuf, 0, sizeof (cmsgbuf)); + msg.msg_control = &cmsgbuf.buf; + msg.msg_controllen = sizeof (cmsgbuf.buf); + + while ((n = recvmsg (sock, &msg, 0)) == -1 && errno == EINTR); + if (n != 1 || ch != 'A') + return -1; + + cmsg = CMSG_FIRSTHDR (&msg); + if (cmsg == NULL) + return -1; + if (cmsg->cmsg_type != SCM_RIGHTS) + return -1; + fd = *(const int *) CMSG_DATA (cmsg); + if (fd < 0) + return -1; + return fd; +} + +static int +child_func (void * const arg) +{ + TEST_VERIFY_EXIT (close (sockfd[0]) == 0); + const int sock = sockfd[1]; + char ch; + + TEST_VERIFY_EXIT (read (sock, &ch, 1) == 1); + TEST_VERIFY_EXIT (ch == '1'); + + if (mount ("/", MOUNT_NAME, NULL, MS_BIND | MS_REC, NULL)) + FAIL_EXIT1 ("mount failed: %m\n"); + const int fd = open ("mpoint", + O_RDONLY | O_PATH | O_DIRECTORY | O_NOFOLLOW); + TEST_VERIFY_EXIT (fd >= 0); + + TEST_VERIFY_EXIT (send_fd (sock, fd) == 0); + TEST_VERIFY_EXIT (close (fd) == 0); + + TEST_VERIFY_EXIT (read (sock, &ch, 1) == 1); + TEST_VERIFY_EXIT (ch == 'a'); + + TEST_VERIFY_EXIT (close (sock) == 0); + return 0; +} + +static void +update_map (char * const mapping, const char * const map_file) +{ + const size_t map_len = strlen (mapping); + + const int fd = open (map_file, O_WRONLY); + TEST_VERIFY_EXIT (fd >= 0); + TEST_VERIFY_EXIT (write (fd, mapping, map_len) == (ssize_t) map_len); + TEST_VERIFY_EXIT (close(fd) == 0); +} + +static void +proc_setgroups_write (const long child_pid, const char * const str) +{ + const size_t str_len = strlen(str); + + char setgroups_path[64]; + snprintf (setgroups_path, sizeof (setgroups_path), + "/proc/%ld/setgroups", child_pid); + + const int fd = open (setgroups_path, O_WRONLY); + + if (fd < 0) + { + TEST_VERIFY_EXIT (errno == ENOENT); + return; + } + + TEST_VERIFY_EXIT (write (fd, str, str_len) == (ssize_t) str_len); + TEST_VERIFY_EXIT (close(fd) == 0); +} + +static char child_stack[1024 * 1024]; + +int +do_test (void) +{ + base = support_create_and_chdir_toolong_temp_directory (BASENAME); + + TEST_VERIFY_EXIT (mkdir (MOUNT_NAME, S_IRWXU) == 0); + atexit (do_cleanup); + + TEST_VERIFY_EXIT (socketpair(AF_UNIX, SOCK_STREAM, 0, sockfd) == 0); + const long child_pid = clone (child_func, child_stack + sizeof(child_stack), + CLONE_NEWUSER | CLONE_NEWNS | SIGCHLD, NULL); + + TEST_VERIFY_EXIT (child_pid > 1); + TEST_VERIFY_EXIT (close(sockfd[1]) == 0); + const int sock = sockfd[0]; + + char map_path[64], map_buf[64]; + snprintf (map_path, sizeof (map_path), "/proc/%ld/uid_map", child_pid); + snprintf (map_buf, sizeof (map_buf), "0 %ld 1", (long) getuid()); + update_map (map_buf, map_path); + + proc_setgroups_write (child_pid, "deny"); + snprintf (map_path, sizeof (map_path), "/proc/%ld/gid_map", child_pid); + snprintf (map_buf, sizeof (map_buf), "0 %ld 1", (long) getgid()); + update_map (map_buf, map_path); + + TEST_VERIFY_EXIT (send (sock, "1", 1, MSG_NOSIGNAL) == 1); + const int fd = recv_fd (sock); + TEST_VERIFY_EXIT (fd >= 0); + TEST_VERIFY_EXIT (fchdir(fd) == 0); + + static char buf[2 * 10 + 1]; + memset (buf, 'A', sizeof(buf)); + + /* Finally, call getcwd and check if it resulted in a buffer underflow. */ + char * cwd = getcwd (buf + sizeof(buf) / 2, 1); + TEST_VERIFY (cwd == NULL && errno == ERANGE); + + for (int i = 0; i < sizeof (buf); i++) + if (buf[i] != 'A') + { + printf ("buf[%d] = %02x\n", i, (unsigned int) buf[i]); + support_record_failure (); + } + + TEST_VERIFY_EXIT (send (sock, "a", 1, MSG_NOSIGNAL) == 1); + TEST_VERIFY_EXIT (close (sock) == 0); + TEST_VERIFY_EXIT (waitpid (child_pid, NULL, 0) == child_pid); + + return 0; +} + +#define CLEANUP_HANDLER do_cleanup +#include