blob: 2a2f09b5be023783edda9f60a6bc43e5f5a8ea45 [file]
// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <arpa/inet.h>
#include <fcntl.h>
#include <lib/fit/defer.h>
#include <net/ethernet.h>
#include <netinet/icmp6.h>
#include <netinet/in.h>
#include <netinet/ip_icmp.h>
#include <netinet/tcp.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/un.h>
#include <unistd.h>
#include <fstream>
#include <limits>
#include <optional>
#include <set>
#include <thread>
#include <vector>
#include <asm-generic/socket.h>
#include <fbl/unaligned.h>
#include <fbl/unique_fd.h>
#include <gtest/gtest.h>
#include <linux/bpf.h>
#include <linux/capability.h>
#include <linux/filter.h>
#include <linux/if_ether.h>
#include <linux/if_packet.h>
#include <linux/ipv6.h>
#include <linux/netfilter/x_tables.h>
#include <linux/rtnetlink.h>
#include "fault_test.h"
#include "src/lib/fxl/strings/string_printf.h"
#include "src/starnix/tests/syscalls/cpp/capabilities_helper.h"
#include "src/starnix/tests/syscalls/cpp/syscall_matchers.h"
#include "test_helper.h"
#if !defined(__NR_memfd_create)
#if defined(__x86_64__)
#define __NR_memfd_create 319
#elif defined(__i386__)
#define __NR_memfd_create 356
#elif defined(__aarch64__)
#define __NR_memfd_create 279
#elif defined(__arm__)
#define __NR_memfd_create 385
#endif
#endif // !defined(__NR_memfd_create)
// `IPT_SO_GET_REVISION_TARGET` is defined in `linux/netfilter_ipv4/ip_tables.h`,
// but that header is not usable with `clang` due to broken pointer math in
// `ipt_get_target()`. Bionic's version of that header is usable.
#if defined(__BIONIC__)
#include <linux/netfilter_ipv4/ip_tables.h>
#else
#define IPT_BASE_CTL 64
#define IPT_SO_GET_REVISION_TARGET (IPT_BASE_CTL + 3)
#endif
namespace {
class ParameterizedUnixSocketTest : public testing::TestWithParam<int> {
protected:
int GetSocketType() const { return GetParam(); }
};
INSTANTIATE_TEST_SUITE_P(
UnixSocket, ParameterizedUnixSocketTest, testing::Values(SOCK_STREAM, SOCK_DGRAM),
[](const testing::TestParamInfo<ParameterizedUnixSocketTest::ParamType>& info) {
return info.param == SOCK_STREAM ? "SOCK_STREAM" : "SOCK_DGRAM";
});
TEST(UnixSocket, ReadAfterClose) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
ASSERT_EQ(1, write(fds[0], "0", 1));
ASSERT_EQ(0, close(fds[0]));
char buf[1];
ASSERT_EQ(1, read(fds[1], buf, 1));
ASSERT_EQ('0', buf[0]);
ASSERT_EQ(0, read(fds[1], buf, 1));
close(fds[1]);
}
TEST(UnixSocket, ReadAfterCloseDgram) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_DGRAM, 0, fds));
int flags = fcntl(fds[1], F_GETFL, 0);
ASSERT_EQ(0, fcntl(fds[1], F_SETFL, flags | O_NONBLOCK));
ASSERT_EQ(1, write(fds[0], "0", 1));
ASSERT_EQ(0, close(fds[0]));
char buf[1];
ASSERT_EQ(1, read(fds[1], buf, 1));
ASSERT_EQ('0', buf[0]);
ASSERT_THAT(read(fds[1], buf, 1), SyscallFailsWithErrno(EAGAIN));
close(fds[1]);
}
TEST_P(ParameterizedUnixSocketTest, ReadAfterReadShutdown) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, GetSocketType(), 0, fds));
ASSERT_EQ(1, write(fds[0], "0", 1));
ASSERT_EQ(0, shutdown(fds[1], SHUT_RD));
char buf[1];
ASSERT_EQ(1, read(fds[1], buf, 1));
ASSERT_EQ('0', buf[0]);
ASSERT_EQ(0, read(fds[1], buf, 1));
close(fds[0]);
close(fds[1]);
}
TEST_P(ParameterizedUnixSocketTest, PeerWriteAfterReadShutdown) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, GetSocketType(), 0, fds));
ASSERT_EQ(0, shutdown(fds[1], SHUT_RD));
auto old_handler = signal(SIGPIPE, SIG_IGN);
ASSERT_THAT(write(fds[0], "0", 1), SyscallFailsWithErrno(EPIPE));
signal(SIGPIPE, old_handler);
close(fds[0]);
close(fds[1]);
}
TEST(UnixSocket, PeerWriteAfterCloseStream) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
close(fds[1]);
auto old_handler = signal(SIGPIPE, SIG_IGN);
ASSERT_THAT(write(fds[0], "0", 1), SyscallFailsWithErrno(EPIPE));
signal(SIGPIPE, old_handler);
close(fds[0]);
}
TEST(UnixSocket, PeerWriteAfterCloseDgram) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_DGRAM, 0, fds));
close(fds[1]);
auto old_handler = signal(SIGPIPE, SIG_IGN);
ASSERT_THAT(write(fds[0], "0", 1), SyscallFailsWithErrno(ECONNREFUSED));
signal(SIGPIPE, old_handler);
close(fds[0]);
}
TEST(UnixSocket, PeerWriteAfterCloseDgramTwice) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_DGRAM, 0, fds));
close(fds[1]);
auto old_handler = signal(SIGPIPE, SIG_IGN);
ASSERT_THAT(write(fds[0], "0", 1), SyscallFailsWithErrno(ECONNREFUSED));
// Second write should return ENOTCONN because the socket was disconnected
// by the first failed write.
ASSERT_THAT(write(fds[0], "0", 1), SyscallFailsWithErrno(ENOTCONN));
signal(SIGPIPE, old_handler);
close(fds[0]);
}
TEST(UnixSocket, PeerWriteAfterShutdownAndCloseDgram) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_DGRAM, 0, fds));
ASSERT_EQ(0, shutdown(fds[1], SHUT_RD));
close(fds[1]);
auto old_handler = signal(SIGPIPE, SIG_IGN);
ASSERT_THAT(write(fds[0], "0", 1), SyscallFailsWithErrno(ECONNREFUSED));
ASSERT_THAT(write(fds[0], "0", 1), SyscallFailsWithErrno(ENOTCONN));
signal(SIGPIPE, old_handler);
close(fds[0]);
}
TEST(UnixSocket, UnconnectedShutdownStream) {
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
ASSERT_LT(-1, fd);
ASSERT_EQ(0, shutdown(fd, SHUT_RDWR));
close(fd);
}
TEST(UnixSocket, UnconnectedShutdownDgram) {
int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
ASSERT_LT(-1, fd);
ASSERT_EQ(0, shutdown(fd, SHUT_RDWR));
close(fd);
}
TEST(UnixSocket, DatagramDisconnectAfUnspec) {
fbl::unique_fd sock1;
ASSERT_TRUE(sock1 = fbl::unique_fd(socket(AF_UNIX, SOCK_DGRAM, 0))) << strerror(errno);
fbl::unique_fd sock2;
ASSERT_TRUE(sock2 = fbl::unique_fd(socket(AF_UNIX, SOCK_DGRAM, 0))) << strerror(errno);
struct sockaddr_un addr2 = {.sun_family = AF_UNIX};
const char name[] = "\0test_unix_dgram_unspec";
memcpy(addr2.sun_path, name, sizeof(name));
ASSERT_THAT(bind(sock2.get(), reinterpret_cast<struct sockaddr*>(&addr2), sizeof(addr2)),
SyscallSucceeds());
// Connect sock1 to sock2.
ASSERT_THAT(connect(sock1.get(), reinterpret_cast<struct sockaddr*>(&addr2), sizeof(addr2)),
SyscallSucceeds());
// getpeername should succeed while connected.
struct sockaddr_un peer_addr = {};
socklen_t addrlen = sizeof(peer_addr);
ASSERT_THAT(getpeername(sock1.get(), reinterpret_cast<struct sockaddr*>(&peer_addr), &addrlen),
SyscallSucceeds());
// Disconnect sock1 using AF_UNSPEC.
struct sockaddr unspec_addr = {.sa_family = AF_UNSPEC};
ASSERT_THAT(connect(sock1.get(), &unspec_addr, sizeof(unspec_addr)), SyscallSucceeds());
// getpeername should now fail with ENOTCONN.
ASSERT_THAT(getpeername(sock1.get(), reinterpret_cast<struct sockaddr*>(&peer_addr), &addrlen),
SyscallFailsWithErrno(ENOTCONN));
}
TEST(UnixSocket, HupEvent) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
int epfd = epoll_create1(0);
ASSERT_LT(-1, epfd);
epoll_event ev = {EPOLLIN, {.u64 = 42}};
ASSERT_EQ(0, epoll_ctl(epfd, EPOLL_CTL_ADD, fds[0], &ev));
epoll_event outev = {0, {.u64 = 0}};
int no_ready = epoll_wait(epfd, &outev, 1, 0);
ASSERT_EQ(0, no_ready);
close(fds[1]);
no_ready = epoll_wait(epfd, &outev, 1, 0);
ASSERT_EQ(1, no_ready);
ASSERT_EQ(EPOLLIN | EPOLLHUP, outev.events);
ASSERT_EQ(42ul, fbl::UnalignedLoad<uint64_t>(&outev.data.u64));
close(fds[0]);
close(epfd);
}
// Tests the behavior of a unix domain socket after it connects to a peer and that peer is closed.
TEST(UnixSocket, PeerNameAfterPeerClosed) {
char* tmp = getenv("TEST_TMPDIR");
auto socket_path =
tmp == nullptr ? "/tmp/socktest_stream_hup" : std::string(tmp) + "/socktest_stream_hup";
struct sockaddr_un sun;
sun.sun_family = AF_UNIX;
strcpy(sun.sun_path, socket_path.c_str());
struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&sun);
fbl::unique_fd server(SAFE_SYSCALL(socket(AF_UNIX, SOCK_STREAM, 0)));
SAFE_SYSCALL(bind(server.get(), addr, sizeof(sun)));
auto cleanup_sockpath = fit::defer([&socket_path]() { unlink(socket_path.c_str()); });
SAFE_SYSCALL(listen(server.get(), 1));
fbl::unique_fd client(SAFE_SYSCALL(socket(AF_UNIX, SOCK_STREAM, 0)));
SAFE_SYSCALL(connect(client.get(), addr, sizeof(sun)));
fbl::unique_fd accepted(SAFE_SYSCALL(accept(server.get(), nullptr, nullptr)));
// getpeername() on client while connected.
struct sockaddr_un peer_name{};
socklen_t peer_name_len = sizeof(peer_name);
SAFE_SYSCALL(
getpeername(client.get(), reinterpret_cast<struct sockaddr*>(&peer_name), &peer_name_len));
EXPECT_GT(peer_name_len, sizeof(sa_family_t));
EXPECT_STREQ(sun.sun_path, peer_name.sun_path);
peer_name = {};
accepted.reset();
// Even though the peer of |client| is now closed, getpeername() on client still returns the
// address that the connection used to have.
EXPECT_EQ(
0, getpeername(client.get(), reinterpret_cast<struct sockaddr*>(&peer_name), &peer_name_len));
EXPECT_GT(peer_name_len, sizeof(sa_family_t));
EXPECT_STREQ(sun.sun_path, peer_name.sun_path);
}
TEST(UnixSocket, ReadConnReset) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
ASSERT_EQ(1, write(fds[1], "A", 1));
ASSERT_EQ(1, write(fds[0], "B", 1));
ASSERT_EQ(0, close(fds[0]));
char buf[1];
ASSERT_EQ(1, read(fds[1], buf, 1));
ASSERT_EQ('B', buf[0]);
ASSERT_EQ(-1, read(fds[1], buf, 1));
EXPECT_EQ(errno, ECONNRESET);
}
TEST(UnixSocket, ReadConnResetEmptyBuffer) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
ASSERT_EQ(1, write(fds[1], "A", 1));
ASSERT_EQ(0, close(fds[0]));
char buf[1];
ASSERT_EQ(0, read(fds[1], buf, 0));
}
TEST(UnixSocket, ReadConnResetAndShutdown) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
ASSERT_EQ(1, write(fds[1], "A", 1));
ASSERT_EQ(1, write(fds[0], "B", 1));
ASSERT_EQ(0, close(fds[0]));
ASSERT_EQ(0, shutdown(fds[1], SHUT_RD));
char buf[1];
ASSERT_EQ(1, read(fds[1], buf, 1));
ASSERT_EQ('B', buf[0]);
ASSERT_EQ(-1, read(fds[1], buf, 1));
EXPECT_EQ(errno, ECONNRESET);
}
struct read_info_spec {
unsigned char* mem;
size_t length;
size_t bytes_read;
int fd;
};
void* reader(void* arg) {
read_info_spec* read_info = reinterpret_cast<read_info_spec*>(arg);
while (read_info->bytes_read < read_info->length) {
size_t to_read = read_info->length - read_info->bytes_read;
fflush(stdout);
ssize_t bytes_read = read(read_info->fd, read_info->mem + read_info->bytes_read, to_read);
EXPECT_LT(-1, bytes_read) << strerror(errno);
if (bytes_read < 0) {
return nullptr;
}
read_info->bytes_read += bytes_read;
}
return nullptr;
}
TEST(UnixSocket, BigWrite) {
const size_t write_size = 300000;
unsigned char* send_mem = new unsigned char[write_size];
ASSERT_TRUE(send_mem != nullptr);
for (size_t i = 0; i < write_size; i++) {
send_mem[i] = 0xff & random();
}
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds)) << strerror(errno);
read_info_spec read_info;
read_info.mem = new unsigned char[write_size];
bzero(read_info.mem, sizeof(unsigned char) * write_size);
ASSERT_TRUE(read_info.mem != nullptr);
read_info.length = write_size;
read_info.fd = fds[1];
read_info.bytes_read = 0;
pthread_t read_thread;
ASSERT_EQ(0, pthread_create(&read_thread, nullptr, reader, &read_info));
size_t write_count = 0;
while (write_count < write_size) {
size_t to_send = write_size - write_count;
ssize_t bytes_read = write(fds[0], send_mem + write_count, to_send);
ASSERT_LT(-1, bytes_read) << strerror(errno);
write_count += bytes_read;
}
ASSERT_EQ(0, pthread_join(read_thread, nullptr)) << strerror(errno);
close(fds[0]);
close(fds[1]);
ASSERT_EQ(write_count, read_info.bytes_read);
ASSERT_EQ(0, memcmp(send_mem, read_info.mem, sizeof(unsigned char) * write_size));
delete[] send_mem;
delete[] read_info.mem;
}
TEST(UnixSocket, SeqPacket) {
char* tmp = getenv("TEST_TMPDIR");
auto socket_path =
tmp == nullptr ? "/tmp/socktest_seqpacket" : std::string(tmp) + "/socktest_seqpacket";
struct sockaddr_un sun;
sun.sun_family = AF_UNIX;
strcpy(sun.sun_path, socket_path.c_str());
struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&sun);
auto server = socket(AF_UNIX, SOCK_SEQPACKET, 0);
ASSERT_GE(server, 0);
ASSERT_EQ(bind(server, addr, sizeof(sun)), 0);
ASSERT_EQ(listen(server, 1), 0);
int pipes[2];
ASSERT_EQ(pipe(pipes), 0);
pid_t pid = fork();
if (pid == 0) {
// Child
auto client = socket(AF_UNIX, SOCK_SEQPACKET, 0);
if (client < 0) {
exit(1);
}
if (connect(client, addr, sizeof(sun)) < 0) {
exit(1);
}
const char* message = "hello";
if (send(client, message, strlen(message), 0) < 0) {
exit(1);
}
char data;
read(pipes[0], &data, 1);
close(pipes[0]);
close(client);
exit(0);
}
// Parent
auto accepted_fd = accept(server, nullptr, nullptr);
ASSERT_GE(accepted_fd, 0);
char byte = 0;
write(accepted_fd, &byte, 1);
char buf[1024];
ssize_t bytes_read = recv(accepted_fd, buf, sizeof(buf), 0);
ASSERT_EQ(bytes_read, 5);
ASSERT_EQ(memcmp(buf, "hello", 5), 0);
char buffer[256];
struct iovec iov[1];
iov[0].iov_base = buffer;
iov[0].iov_len = sizeof(buffer);
struct msghdr msg;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = iov;
msg.msg_iovlen = 1;
ASSERT_EQ(write(pipes[1], buffer, 1), 1);
int status;
ASSERT_EQ(waitpid(pid, &status, 0), pid);
ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
// recvmsg should return ECONNRESET when the peer closes the connection
// followed by 0 on the subsequent read.
ssize_t n = recvmsg(accepted_fd, &msg, MSG_CMSG_CLOEXEC);
ASSERT_EQ(errno, ECONNRESET);
ASSERT_EQ(n, -1);
n = recvmsg(accepted_fd, &msg, MSG_CMSG_CLOEXEC);
ASSERT_EQ(n, 0);
ASSERT_EQ(unlink(socket_path.c_str()), 0);
ASSERT_EQ(close(accepted_fd), 0);
ASSERT_EQ(close(server), 0);
close(pipes[1]);
}
TEST(UnixSocket, ConnectZeroBacklog) {
char* tmp = getenv("TEST_TMPDIR");
auto socket_path =
tmp == nullptr ? "/tmp/socktest_connect" : std::string(tmp) + "/socktest_connect";
struct sockaddr_un sun;
sun.sun_family = AF_UNIX;
strcpy(sun.sun_path, socket_path.c_str());
struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&sun);
auto server = socket(AF_UNIX, SOCK_STREAM, 0);
ASSERT_EQ(bind(server, addr, sizeof(sun)), 0);
ASSERT_EQ(listen(server, 0), 0);
auto client = socket(AF_UNIX, SOCK_STREAM, 0);
ASSERT_GT(client, -1);
ASSERT_EQ(connect(client, addr, sizeof(sun)), 0);
ASSERT_EQ(unlink(socket_path.c_str()), 0);
ASSERT_EQ(close(client), 0);
ASSERT_EQ(close(server), 0);
}
TEST(UnixSocket, ConnectLargeSize) {
struct sockaddr_un sun;
sun.sun_family = AF_UNIX;
strcpy(sun.sun_path, "/bogus/path/value");
struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&sun);
auto client = socket(AF_UNIX, SOCK_STREAM, 0);
ASSERT_GT(client, -1);
ASSERT_EQ(connect(client, addr, sizeof(struct sockaddr_un) + 1), -1);
EXPECT_EQ(errno, EINVAL);
}
TEST(InetSocket, ConnectLargeSize) {
struct sockaddr_in in;
in.sin_family = AF_INET;
struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&in);
auto client = socket(AF_INET, SOCK_STREAM, 0);
ASSERT_GT(client, -1);
ASSERT_EQ(connect(client, addr, sizeof(struct sockaddr_storage) + 1), -1);
EXPECT_EQ(errno, EINVAL);
}
class UnixSocketTest : public testing::Test {
// SetUp() - make socket
protected:
void SetUp() override {
char* tmp = getenv("TEST_TMPDIR");
socket_path_ = tmp == nullptr ? "/tmp/socktest" : std::string(tmp) + "/socktest";
struct sockaddr_un sun;
sun.sun_family = AF_UNIX;
strcpy(sun.sun_path, socket_path_.c_str());
struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&sun);
server_ = socket(AF_UNIX, SOCK_STREAM, 0);
ASSERT_GT(server_, -1);
ASSERT_EQ(bind(server_, addr, sizeof(sun)), 0);
ASSERT_EQ(listen(server_, 1), 0);
client_ = socket(AF_UNIX, SOCK_STREAM, 0);
ASSERT_GT(client_, -1);
ASSERT_EQ(connect(client_, addr, sizeof(sun)), 0);
}
void TearDown() override {
ASSERT_EQ(unlink(socket_path_.c_str()), 0);
ASSERT_EQ(close(client_), 0);
ASSERT_EQ(close(server_), 0);
}
int client() const { return client_; }
private:
int client_ = 0;
int server_ = 0;
std::string socket_path_;
};
TEST_F(UnixSocketTest, ImmediatePeercredCheck) {
struct ucred cred;
socklen_t cred_size = sizeof(cred);
ASSERT_EQ(getsockopt(client(), SOL_SOCKET, SO_PEERCRED, &cred, &cred_size), 0);
ASSERT_NE(cred.pid, 0);
ASSERT_EQ(cred.uid, getuid());
ASSERT_EQ(cred.gid, getgid());
}
TEST(UnixSocket, SendZeroFds) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
char data[] = "a";
struct iovec iov[] = {{
.iov_base = data,
.iov_len = 1,
}};
char buf[CMSG_SPACE(0)];
struct msghdr msg = {
.msg_iov = iov,
.msg_iovlen = 1,
.msg_control = buf,
.msg_controllen = sizeof(buf),
};
*CMSG_FIRSTHDR(&msg) = (struct cmsghdr){
.cmsg_len = CMSG_LEN(0),
.cmsg_level = SOL_SOCKET,
.cmsg_type = SCM_RIGHTS,
};
ASSERT_EQ(sendmsg(fds[0], &msg, 0), 1);
memset(data, 0, sizeof(data));
memset(buf, 0, sizeof(buf));
ASSERT_EQ(recvmsg(fds[1], &msg, 0), 1);
EXPECT_EQ(data[0], 'a');
EXPECT_EQ(msg.msg_controllen, 0u);
EXPECT_EQ(msg.msg_flags, 0);
}
#if defined(__NR_memfd_create)
TEST(UnixSocket, SendMemFd) {
int fds[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
int memfd = static_cast<int>(syscall(__NR_memfd_create, "test_memfd", 0));
char data[] = "";
struct iovec iov[] = {{
.iov_base = data,
.iov_len = 1,
}};
char buf[CMSG_SPACE(sizeof(int))];
struct msghdr msg = {
.msg_iov = iov,
.msg_iovlen = 1,
.msg_control = buf,
.msg_controllen = sizeof(buf),
};
struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
*cmsg = (struct cmsghdr){
.cmsg_len = CMSG_LEN(sizeof(int)),
.cmsg_level = SOL_SOCKET,
.cmsg_type = SCM_RIGHTS,
};
memmove(CMSG_DATA(cmsg), &memfd, sizeof(int));
msg.msg_controllen = cmsg->cmsg_len;
ASSERT_EQ(sendmsg(fds[0], &msg, 0), 1);
memset(data, 0, sizeof(data));
memset(buf, 0, sizeof(buf));
ASSERT_EQ(recvmsg(fds[1], &msg, 0), 1);
EXPECT_EQ(data[0], '\0');
EXPECT_GT(msg.msg_controllen, 0u);
EXPECT_EQ(msg.msg_flags, 0);
}
#endif // defined(__NR_memfd_create)
TEST(UnixSocket, ScmRightsTruncation) {
int sv_raw[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, sv_raw));
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
constexpr int kSendFdCount = 4;
fbl::unique_fd send_fds[kSendFdCount];
for (int i = 0; i < kSendFdCount; i++) {
int p[2];
ASSERT_EQ(0, pipe(p));
send_fds[i].reset(p[0]);
close(p[1]);
}
char data = 'x';
struct iovec iov = {.iov_base = &data, .iov_len = 1};
char sendbuf[CMSG_SPACE(kSendFdCount * sizeof(int))];
memset(sendbuf, 0, sizeof(sendbuf));
struct msghdr send_msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = sendbuf,
.msg_controllen = sizeof(sendbuf),
};
struct cmsghdr* cmsg = CMSG_FIRSTHDR(&send_msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(kSendFdCount * sizeof(int));
int* cmsg_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
for (int i = 0; i < kSendFdCount; i++) {
cmsg_fds[i] = send_fds[i].get();
}
ASSERT_THAT(sendmsg(sv[0].get(), &send_msg, 0), SyscallSucceedsWithValue(1));
constexpr int kMaxNumberOfFileDescriptors = 1024;
std::set<int> open_fds_before;
for (int fd = 0; fd < kMaxNumberOfFileDescriptors; fd++) {
if (fcntl(fd, F_GETFD) != -1) {
open_fds_before.insert(fd);
}
}
char recvbuf[CMSG_LEN(sizeof(int))];
memset(recvbuf, 0, sizeof(recvbuf));
char rdata = 0;
struct iovec riov = {.iov_base = &rdata, .iov_len = 1};
struct msghdr recv_msg = {
.msg_iov = &riov,
.msg_iovlen = 1,
.msg_control = recvbuf,
.msg_controllen = sizeof(recvbuf),
};
ASSERT_THAT(recvmsg(sv[1].get(), &recv_msg, 0), SyscallSucceedsWithValue(1));
EXPECT_NE(0, recv_msg.msg_flags & MSG_CTRUNC);
int new_fds = 0;
for (int fd = 0; fd < kMaxNumberOfFileDescriptors; fd++) {
if (fcntl(fd, F_GETFD) != -1 && !open_fds_before.count(fd)) {
new_fds++;
close(fd);
}
}
int parsed_fds = 0;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&recv_msg); c; c = CMSG_NXTHDR(&recv_msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_RIGHTS) {
ASSERT_GE(c->cmsg_len, CMSG_LEN(0));
parsed_fds = static_cast<int>((c->cmsg_len - CMSG_LEN(0)) / sizeof(int));
}
}
EXPECT_EQ(1, parsed_fds);
EXPECT_EQ(parsed_fds, new_fds);
}
class CmsgAlignmentTest : public testing::TestWithParam<int> {};
TEST_P(CmsgAlignmentTest, ScmRightsFollowedByCredentials) {
const int num_fds = GetParam();
int sv_raw[2];
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, sv_raw));
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
int one = 1;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
constexpr int kMaxFds = 3;
ASSERT_LE(num_fds, kMaxFds);
fbl::unique_fd pipes[kMaxFds];
for (int i = 0; i < num_fds; i++) {
int p[2];
ASSERT_EQ(0, pipe(p));
pipes[i].reset(p[0]);
close(p[1]);
}
char payload = 'A';
struct iovec iov = {.iov_base = &payload, .iov_len = 1};
char sendbuf[CMSG_SPACE(kMaxFds * sizeof(int))];
memset(sendbuf, 0, sizeof(sendbuf));
struct msghdr send_msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = sendbuf,
.msg_controllen = CMSG_SPACE(num_fds * sizeof(int)),
};
struct cmsghdr* cmsg = CMSG_FIRSTHDR(&send_msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(num_fds * sizeof(int));
int* fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
for (int i = 0; i < num_fds; i++) {
fds[i] = pipes[i].get();
}
ASSERT_THAT(sendmsg(sv[0].get(), &send_msg, 0), SyscallSucceedsWithValue(1));
char recvbuf[CMSG_SPACE(kMaxFds * sizeof(int)) + CMSG_SPACE(sizeof(struct ucred))];
memset(recvbuf, 0, sizeof(recvbuf));
char rdata = 0;
struct iovec riov = {.iov_base = &rdata, .iov_len = 1};
struct msghdr recv_msg = {
.msg_iov = &riov,
.msg_iovlen = 1,
.msg_control = recvbuf,
.msg_controllen = sizeof(recvbuf),
};
ASSERT_THAT(recvmsg(sv[1].get(), &recv_msg, 0), SyscallSucceedsWithValue(1));
EXPECT_EQ(recv_msg.msg_flags & MSG_CTRUNC, 0);
int cmsg_count = 0;
bool found_rights = false;
bool found_creds = false;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&recv_msg); c; c = CMSG_NXTHDR(&recv_msg, c)) {
cmsg_count++;
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_RIGHTS) {
found_rights = true;
ASSERT_GE(c->cmsg_len, CMSG_LEN(0));
int received_fds = static_cast<int>((c->cmsg_len - CMSG_LEN(0)) / sizeof(int));
ASSERT_EQ(received_fds, num_fds);
const int* recv_fds = reinterpret_cast<const int*>(CMSG_DATA(c));
for (int i = 0; i < received_fds; i++) {
int recv_fd = recv_fds[i];
EXPECT_GE(recv_fd, 0);
close(recv_fd);
}
}
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_CREDENTIALS) {
found_creds = true;
EXPECT_EQ(c->cmsg_len, CMSG_LEN(sizeof(struct ucred)));
struct ucred cred;
memcpy(&cred, CMSG_DATA(c), sizeof(cred));
EXPECT_EQ(cred.pid, getpid());
EXPECT_EQ(cred.uid, geteuid());
EXPECT_EQ(cred.gid, getegid());
}
}
EXPECT_EQ(cmsg_count, 2);
EXPECT_TRUE(found_rights);
EXPECT_TRUE(found_creds);
}
INSTANTIATE_TEST_SUITE_P(UnixSocket, CmsgAlignmentTest, testing::Values(1, 2, 3));
TEST(UnixSocket, StreamPasscredCoalescing) {
int sv_raw[2];
ASSERT_THAT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv_raw), SyscallSucceeds());
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
int one = 1;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
ASSERT_THAT(write(sv[0].get(), "ab", 2), SyscallSucceedsWithValue(2));
ASSERT_THAT(write(sv[0].get(), "c", 1), SyscallSucceedsWithValue(1));
pid_t child_pid = fork();
ASSERT_GE(child_pid, 0);
if (child_pid == 0) {
if (write(sv[0].get(), "de", 2) != 2) {
_exit(1);
}
_exit(0);
}
int status = 0;
ASSERT_THAT(waitpid(child_pid, &status, 0), SyscallSucceedsWithValue(child_pid));
ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
auto recv_with_creds = [&](int flags, std::string* out_data,
std::optional<struct ucred>* out_cred) {
char data[10] = {};
struct iovec iov = {.iov_base = data, .iov_len = sizeof(data)};
char cmsg_buf[CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
ssize_t n = recvmsg(sv[1].get(), &msg, flags);
ASSERT_GE(n, 0) << strerror(errno);
*out_data = std::string(data, static_cast<size_t>(n));
*out_cred = std::nullopt;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_CREDENTIALS) {
ASSERT_EQ(c->cmsg_len, CMSG_LEN(sizeof(struct ucred)));
struct ucred cred;
memcpy(&cred, CMSG_DATA(c), sizeof(cred));
*out_cred = cred;
}
}
};
// With SO_PASSCRED disabled on the receiver, all queued messages coalesce regardless of sender
// credentials and no SCM_CREDENTIALS control message is returned.
int zero = 0;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &zero, sizeof(zero)),
SyscallSucceeds());
std::string data;
std::optional<struct ucred> cred;
ASSERT_NO_FATAL_FAILURE(recv_with_creds(MSG_PEEK, &data, &cred));
EXPECT_EQ(data, "abcde");
EXPECT_FALSE(cred.has_value());
// With SO_PASSCRED enabled on the receiver, only adjacent messages with matching credentials
// coalesce.
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(recv_with_creds(MSG_PEEK, &data, &cred));
EXPECT_EQ(data, "abc");
ASSERT_TRUE(cred.has_value());
EXPECT_EQ(cred->pid, getpid());
EXPECT_EQ(cred->uid, getuid());
EXPECT_EQ(cred->gid, getgid());
ASSERT_NO_FATAL_FAILURE(recv_with_creds(0, &data, &cred));
EXPECT_EQ(data, "abc");
ASSERT_TRUE(cred.has_value());
EXPECT_EQ(cred->pid, getpid());
EXPECT_EQ(cred->uid, getuid());
EXPECT_EQ(cred->gid, getgid());
ASSERT_NO_FATAL_FAILURE(recv_with_creds(0, &data, &cred));
EXPECT_EQ(data, "de");
ASSERT_TRUE(cred.has_value());
EXPECT_EQ(cred->pid, child_pid);
EXPECT_EQ(cred->uid, getuid());
EXPECT_EQ(cred->gid, getgid());
}
TEST(UnixSocket, StreamChunkedSendmsgRetainsCredentials) {
int sv_raw[2];
ASSERT_THAT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv_raw), SyscallSucceeds());
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
int sndbuf = 4096;
ASSERT_THAT(setsockopt(sv[0].get(), SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)),
SyscallSucceeds());
int actual_sndbuf = 0;
socklen_t optlen = sizeof(actual_sndbuf);
ASSERT_THAT(getsockopt(sv[0].get(), SOL_SOCKET, SO_SNDBUF, &actual_sndbuf, &optlen),
SyscallSucceeds());
ASSERT_GT(actual_sndbuf, 1024);
int pipe_fds[2];
ASSERT_THAT(pipe(pipe_fds), SyscallSucceeds());
fbl::unique_fd pipe_read(pipe_fds[0]);
fbl::unique_fd pipe_write(pipe_fds[1]);
const size_t total_len = static_cast<size_t>(actual_sndbuf) * 2;
std::thread sender([&] {
std::vector<char> payload(total_len, 'x');
struct iovec iov = {.iov_base = payload.data(), .iov_len = payload.size()};
char cmsg_buf[CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
int fd_to_send = pipe_read.get();
memcpy(CMSG_DATA(cmsg), &fd_to_send, sizeof(int));
cmsg = CMSG_NXTHDR(&msg, cmsg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_CREDENTIALS;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
struct ucred creds = {
.pid = getpid(),
.uid = getuid(),
.gid = getgid(),
};
memcpy(CMSG_DATA(cmsg), &creds, sizeof(creds));
EXPECT_THAT(sendmsg(sv[0].get(), &msg, 0), SyscallSucceedsWithValue(total_len));
});
auto cleanup = fit::defer([&] {
sv[1].reset();
if (sender.joinable()) {
sender.join();
}
});
// Read the first chunk while SO_PASSCRED is still disabled. Because the first chunk carries
// SCM_RIGHTS, recvmsg stops at the end of the first chunk and frees its buffer space.
size_t total_received = 0;
int received_rights_fds = 0;
{
std::vector<char> buf(total_len);
struct iovec iov = {.iov_base = buf.data(), .iov_len = buf.size()};
char cmsg_buf[CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
ssize_t n = recvmsg(sv[1].get(), &msg, 0);
ASSERT_GT(n, 0) << strerror(errno);
ASSERT_LT(static_cast<size_t>(n), total_len);
total_received += static_cast<size_t>(n);
for (struct cmsghdr* c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_RIGHTS) {
int count = static_cast<int>((c->cmsg_len - CMSG_LEN(0)) / sizeof(int));
const int* fds = reinterpret_cast<const int*>(CMSG_DATA(c));
for (int i = 0; i < count; ++i) {
close(fds[i]);
received_rights_fds++;
}
}
}
}
EXPECT_EQ(received_rights_fds, 1);
// Wait for the next chunk of the split sendmsg to be queued while SO_PASSCRED is still disabled.
struct pollfd pfd = {.fd = sv[1].get(), .events = POLLIN};
ASSERT_THAT(poll(&pfd, 1, -1), SyscallSucceedsWithValue(1));
// Enable SO_PASSCRED on the receiver and read the remaining chunk(s). Each read must still carry
// the explicit SCM_CREDENTIALS from the multi-chunk sendmsg and must not duplicate SCM_RIGHTS.
int one = 1;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
while (total_received < total_len) {
std::vector<char> buf(total_len - total_received);
struct iovec iov = {.iov_base = buf.data(), .iov_len = buf.size()};
char cmsg_buf[CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
ssize_t n = recvmsg(sv[1].get(), &msg, 0);
ASSERT_GT(n, 0) << strerror(errno);
total_received += static_cast<size_t>(n);
std::optional<struct ucred> cred;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
EXPECT_FALSE(c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_RIGHTS);
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_CREDENTIALS) {
ASSERT_EQ(c->cmsg_len, CMSG_LEN(sizeof(struct ucred)));
struct ucred received_cred;
memcpy(&received_cred, CMSG_DATA(c), sizeof(received_cred));
cred = received_cred;
}
}
ASSERT_TRUE(cred.has_value());
EXPECT_EQ(cred->pid, getpid());
EXPECT_EQ(cred->uid, getuid());
EXPECT_EQ(cred->gid, getgid());
}
sender.join();
}
TEST(UnixSocket, StreamChunkedWriteDoesNotLeakImplicitCredentials) {
int sv_raw[2];
ASSERT_THAT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv_raw), SyscallSucceeds());
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
int sndbuf = 4096;
ASSERT_THAT(setsockopt(sv[0].get(), SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)),
SyscallSucceeds());
int actual_sndbuf = 0;
socklen_t optlen = sizeof(actual_sndbuf);
ASSERT_THAT(getsockopt(sv[0].get(), SOL_SOCKET, SO_SNDBUF, &actual_sndbuf, &optlen),
SyscallSucceeds());
ASSERT_GT(actual_sndbuf, 1024);
const size_t total_len = static_cast<size_t>(actual_sndbuf) + 1024;
std::vector<char> buf(total_len, 'a');
ssize_t fill_len = send(sv[0].get(), buf.data(), buf.size(), MSG_DONTWAIT);
ASSERT_GT(fill_len, 0) << strerror(errno);
ASSERT_LT(static_cast<size_t>(fill_len), total_len);
EXPECT_THAT(send(sv[0].get(), "x", 1, MSG_DONTWAIT), SyscallFailsWithErrno(EAGAIN));
ASSERT_THAT(recv(sv[1].get(), buf.data(), static_cast<size_t>(fill_len), MSG_WAITALL),
SyscallSucceedsWithValue(fill_len));
int one = 1;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
std::thread sender([&] {
std::vector<char> payload(total_len, 'y');
EXPECT_THAT(write(sv[0].get(), payload.data(), payload.size()),
SyscallSucceedsWithValue(total_len));
});
auto cleanup = fit::defer([&] {
sv[1].reset();
if (sender.joinable()) {
sender.join();
}
});
// Wait for the initial buffer fill to be queued while SO_PASSCRED is enabled. On Linux, the
// initial fill may be split across multiple skbs and wake poll() after the first skb before the
// send buffer is full.
struct pollfd pfd = {.fd = sv[1].get(), .events = POLLIN};
ASSERT_THAT(poll(&pfd, 1, -1), SyscallSucceedsWithValue(1));
while (true) {
int queued = 0;
ASSERT_THAT(ioctl(sv[1].get(), FIONREAD, &queued), SyscallSucceeds());
if (queued >= fill_len) {
ASSERT_EQ(queued, fill_len);
break;
}
usleep(1000);
}
// Disable SO_PASSCRED before draining the initial buffer fill so the remaining bytes are queued
// while SO_PASSCRED is disabled. Read only `fill_len` bytes so that if the sender wakes up and
// queues the trailing chunk before recv() returns, recv() does not coalesce the trailing chunk.
int zero = 0;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &zero, sizeof(zero)),
SyscallSucceeds());
ssize_t first_read = recv(sv[1].get(), buf.data(), static_cast<size_t>(fill_len), MSG_WAITALL);
ASSERT_EQ(first_read, fill_len) << strerror(errno);
sender.join();
// Re-enable SO_PASSCRED and read the second chunk. Because the second chunk was queued while
// SO_PASSCRED was disabled and without explicit SCM_CREDENTIALS, it must carry unknown_creds.
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
const size_t remaining = total_len - static_cast<size_t>(first_read);
struct iovec iov = {.iov_base = buf.data(), .iov_len = buf.size()};
char cmsg_buf[CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
ASSERT_THAT(recvmsg(sv[1].get(), &msg, 0), SyscallSucceedsWithValue(remaining));
std::optional<struct ucred> cred;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_CREDENTIALS) {
ASSERT_EQ(c->cmsg_len, CMSG_LEN(sizeof(struct ucred)));
struct ucred received_cred;
memcpy(&received_cred, CMSG_DATA(c), sizeof(received_cred));
cred = received_cred;
}
}
ASSERT_TRUE(cred.has_value());
EXPECT_EQ(cred->pid, 0);
EXPECT_EQ(cred->uid, static_cast<uid_t>(65534));
EXPECT_EQ(cred->gid, static_cast<gid_t>(65534));
}
TEST(UnixSocket, FailedListenDoesNotCorruptPeercred) {
// 1. Failed listen() on an unbound socket must leave SO_PEERCRED at {0, -1, -1}.
fbl::unique_fd unbound(socket(AF_UNIX, SOCK_STREAM, 0));
ASSERT_TRUE(unbound.is_valid()) << strerror(errno);
EXPECT_THAT(listen(unbound.get(), 5), SyscallFailsWithErrno(EINVAL));
struct ucred cred = {};
socklen_t cred_len = sizeof(cred);
ASSERT_THAT(getsockopt(unbound.get(), SOL_SOCKET, SO_PEERCRED, &cred, &cred_len),
SyscallSucceeds());
EXPECT_EQ(cred.pid, 0);
EXPECT_EQ(cred.uid, static_cast<uid_t>(-1));
EXPECT_EQ(cred.gid, static_cast<gid_t>(-1));
// 2. Failed listen() on a connected socket from another process must not overwrite SO_PEERCRED.
int sv_raw[2];
ASSERT_THAT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv_raw), SyscallSucceeds());
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
test_helper::ForkHelper helper;
helper.RunInForkedProcess(
[&] { EXPECT_THAT(listen(sv[0].get(), 5), SyscallFailsWithErrno(EINVAL)); });
ASSERT_TRUE(helper.WaitForChildren());
for (const auto& fd : sv) {
cred = {};
cred_len = sizeof(cred);
ASSERT_THAT(getsockopt(fd.get(), SOL_SOCKET, SO_PEERCRED, &cred, &cred_len), SyscallSucceeds());
EXPECT_EQ(cred.pid, getpid());
EXPECT_EQ(cred.uid, getuid());
EXPECT_EQ(cred.gid, getgid());
}
}
TEST(UnixSocket, MultipleCredentialsCmsgsDeduplicated) {
for (int sock_type : {SOCK_STREAM, SOCK_DGRAM}) {
int sv_raw[2];
ASSERT_THAT(socketpair(AF_UNIX, sock_type, 0, sv_raw), SyscallSucceeds());
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
auto send_two_creds = [&]() {
char payload = 'a';
struct iovec iov = {.iov_base = &payload, .iov_len = 1};
char cmsg_buf[2 * CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
struct ucred creds = {
.pid = getpid(),
.uid = getuid(),
.gid = getgid(),
};
struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_CREDENTIALS;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
memcpy(CMSG_DATA(cmsg), &creds, sizeof(creds));
cmsg = CMSG_NXTHDR(&msg, cmsg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_CREDENTIALS;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
memcpy(CMSG_DATA(cmsg), &creds, sizeof(creds));
ASSERT_THAT(sendmsg(sv[0].get(), &msg, 0), SyscallSucceedsWithValue(1));
};
auto recv_cred_count = [&]() -> int {
char rbuf = 0;
struct iovec iov = {.iov_base = &rbuf, .iov_len = 1};
char cmsg_buf[2 * CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
EXPECT_THAT(recvmsg(sv[1].get(), &msg, 0), SyscallSucceedsWithValue(1));
int count = 0;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_CREDENTIALS) {
count++;
}
}
return count;
};
// With SO_PASSCRED disabled on the receiver, no SCM_CREDENTIALS should be delivered.
ASSERT_NO_FATAL_FAILURE(send_two_creds());
EXPECT_EQ(recv_cred_count(), 0);
// With SO_PASSCRED enabled on the receiver, exactly one SCM_CREDENTIALS should be delivered.
int one = 1;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
ASSERT_NO_FATAL_FAILURE(send_two_creds());
EXPECT_EQ(recv_cred_count(), 1);
}
}
TEST(UnixSocket, WriteBeforeAcceptPreservesCredentials) {
fbl::unique_fd listener(socket(AF_UNIX, SOCK_STREAM, 0));
ASSERT_TRUE(listener.is_valid()) << strerror(errno);
struct sockaddr_un addr = {};
addr.sun_family = AF_UNIX;
// Bind to a unique abstract socket address.
std::string abstract_name = fxl::StringPrintf("pre_accept_passcred_%d", getpid());
memcpy(addr.sun_path + 1, abstract_name.data(), abstract_name.size());
socklen_t addr_len =
static_cast<socklen_t>(offsetof(struct sockaddr_un, sun_path) + 1 + abstract_name.size());
ASSERT_THAT(bind(listener.get(), reinterpret_cast<struct sockaddr*>(&addr), addr_len),
SyscallSucceeds());
ASSERT_THAT(listen(listener.get(), 5), SyscallSucceeds());
fbl::unique_fd client(socket(AF_UNIX, SOCK_STREAM, 0));
ASSERT_TRUE(client.is_valid()) << strerror(errno);
ASSERT_THAT(connect(client.get(), reinterpret_cast<struct sockaddr*>(&addr), addr_len),
SyscallSucceeds());
// Write to the client socket BEFORE the server calls accept() or enables SO_PASSCRED.
ASSERT_THAT(write(client.get(), "hi", 2), SyscallSucceedsWithValue(2));
fbl::unique_fd accepted(accept(listener.get(), nullptr, nullptr));
ASSERT_TRUE(accepted.is_valid()) << strerror(errno);
int one = 1;
ASSERT_THAT(setsockopt(accepted.get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
char rbuf[4] = {};
struct iovec iov = {.iov_base = rbuf, .iov_len = sizeof(rbuf)};
char cmsg_buf[CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
ASSERT_THAT(recvmsg(accepted.get(), &msg, 0), SyscallSucceedsWithValue(2));
EXPECT_EQ(std::string(rbuf, 2), "hi");
std::optional<struct ucred> cred;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_CREDENTIALS) {
ASSERT_EQ(c->cmsg_len, CMSG_LEN(sizeof(struct ucred)));
struct ucred received_cred;
memcpy(&received_cred, CMSG_DATA(c), sizeof(received_cred));
cred = received_cred;
}
}
ASSERT_TRUE(cred.has_value());
EXPECT_EQ(cred->pid, getpid());
EXPECT_EQ(cred->uid, getuid());
EXPECT_EQ(cred->gid, getgid());
}
TEST(UnixSocket, StreamWaitAllPasscred) {
int sv_raw[2];
ASSERT_THAT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv_raw), SyscallSucceeds());
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
int sndbuf = 4096;
ASSERT_THAT(setsockopt(sv[0].get(), SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)),
SyscallSucceeds());
int actual_sndbuf = 0;
socklen_t optlen = sizeof(actual_sndbuf);
ASSERT_THAT(getsockopt(sv[0].get(), SOL_SOCKET, SO_SNDBUF, &actual_sndbuf, &optlen),
SyscallSucceeds());
ASSERT_GT(actual_sndbuf, 1024);
int one = 1;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
// 1. MSG_WAITALL across multiple writes with the same credentials must coalesce the data and
// emit only a single SCM_CREDENTIALS control message. Fill the send buffer first so the second
// writer blocks on POLLOUT until recvmsg consumes the initial chunk.
std::vector<char> fill_buf(actual_sndbuf, 'a');
ssize_t fill_len = send(sv[0].get(), fill_buf.data(), fill_buf.size(), MSG_DONTWAIT);
ASSERT_GT(fill_len, 0) << strerror(errno);
EXPECT_THAT(send(sv[0].get(), "x", 1, MSG_DONTWAIT), SyscallFailsWithErrno(EAGAIN));
std::thread delayed_writer(
[&] { EXPECT_THAT(write(sv[0].get(), "cd", 2), SyscallSucceedsWithValue(2)); });
auto cleanup_writer = fit::defer([&] {
sv[1].reset();
if (delayed_writer.joinable()) {
delayed_writer.join();
}
});
std::vector<char> rbuf(static_cast<size_t>(fill_len) + 2, 0);
struct iovec iov = {.iov_base = rbuf.data(), .iov_len = rbuf.size()};
char cmsg_buf[2 * CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
ASSERT_THAT(recvmsg(sv[1].get(), &msg, MSG_WAITALL), SyscallSucceedsWithValue(rbuf.size()));
delayed_writer.join();
cleanup_writer.cancel();
EXPECT_EQ(rbuf[rbuf.size() - 2], 'c');
EXPECT_EQ(rbuf[rbuf.size() - 1], 'd');
int cred_count = 0;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_CREDENTIALS) {
cred_count++;
}
}
EXPECT_EQ(cred_count, 1);
// 2. MSG_WAITALL must stop at a credential boundary when messages with differing credentials are
// already queued.
ASSERT_THAT(write(sv[0].get(), "ef", 2), SyscallSucceedsWithValue(2));
pid_t child_pid = fork();
ASSERT_GE(child_pid, 0);
if (child_pid == 0) {
if (write(sv[0].get(), "gh", 2) != 2) {
_exit(1);
}
_exit(0);
}
int status = 0;
ASSERT_THAT(waitpid(child_pid, &status, 0), SyscallSucceedsWithValue(child_pid));
ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
char small_buf[4] = {};
iov = {.iov_base = small_buf, .iov_len = sizeof(small_buf)};
memset(cmsg_buf, 0, sizeof(cmsg_buf));
msg.msg_controllen = sizeof(cmsg_buf);
ASSERT_THAT(recvmsg(sv[1].get(), &msg, MSG_WAITALL), SyscallSucceedsWithValue(2));
EXPECT_EQ(std::string(small_buf, 2), "ef");
memset(small_buf, 0, sizeof(small_buf));
memset(cmsg_buf, 0, sizeof(cmsg_buf));
msg.msg_controllen = sizeof(cmsg_buf);
ASSERT_THAT(recvmsg(sv[1].get(), &msg, 0), SyscallSucceedsWithValue(2));
EXPECT_EQ(std::string(small_buf, 2), "gh");
// 3. MSG_WAITALL must also stop when a message with differing credentials arrives while recvmsg
// is blocked waiting for additional bytes after reading an initial message.
fill_len = send(sv[0].get(), fill_buf.data(), fill_buf.size(), MSG_DONTWAIT);
ASSERT_GT(fill_len, 0) << strerror(errno);
EXPECT_THAT(send(sv[0].get(), "x", 1, MSG_DONTWAIT), SyscallFailsWithErrno(EAGAIN));
child_pid = fork();
ASSERT_GE(child_pid, 0);
if (child_pid == 0) {
if (write(sv[0].get(), "kl", 2) != 2) {
_exit(1);
}
_exit(0);
}
auto cleanup_child = fit::defer([&] {
sv[1].reset();
if (child_pid > 0) {
int child_status = 0;
waitpid(child_pid, &child_status, 0);
}
});
rbuf.assign(static_cast<size_t>(fill_len) + 2, 0);
iov = {.iov_base = rbuf.data(), .iov_len = rbuf.size()};
memset(cmsg_buf, 0, sizeof(cmsg_buf));
msg.msg_controllen = sizeof(cmsg_buf);
ASSERT_THAT(recvmsg(sv[1].get(), &msg, MSG_WAITALL), SyscallSucceedsWithValue(fill_len));
status = 0;
ASSERT_THAT(waitpid(child_pid, &status, 0), SyscallSucceedsWithValue(child_pid));
child_pid = -1;
cleanup_child.cancel();
ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
memset(small_buf, 0, sizeof(small_buf));
iov = {.iov_base = small_buf, .iov_len = sizeof(small_buf)};
memset(cmsg_buf, 0, sizeof(cmsg_buf));
msg.msg_controllen = sizeof(cmsg_buf);
ASSERT_THAT(recvmsg(sv[1].get(), &msg, 0), SyscallSucceedsWithValue(2));
EXPECT_EQ(std::string(small_buf, 2), "kl");
}
TEST(UnixSocket, DatagramBlockingSendmsgRetainsCredentials) {
int sv_raw[2];
ASSERT_THAT(socketpair(AF_UNIX, SOCK_DGRAM, 0, sv_raw), SyscallSucceeds());
fbl::unique_fd sv[2] = {fbl::unique_fd(sv_raw[0]), fbl::unique_fd(sv_raw[1])};
int sndbuf = 4096;
ASSERT_THAT(setsockopt(sv[0].get(), SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)),
SyscallSucceeds());
// Fill the socket buffer while SO_PASSCRED is disabled so the filler datagrams carry no
// credentials. Use 1024-byte datagrams rather than a single SO_SNDBUF-sized datagram because
// Linux charges sk_buff overhead against SO_SNDBUF and rejects an SO_SNDBUF-sized datagram with
// EMSGSIZE.
std::vector<char> filler(1024, 'f');
size_t filler_count = 0;
while (true) {
ssize_t res = send(sv[0].get(), filler.data(), filler.size(), MSG_DONTWAIT);
if (res == -1) {
ASSERT_EQ(errno, EAGAIN) << strerror(errno);
break;
}
ASSERT_EQ(res, static_cast<ssize_t>(filler.size()));
filler_count++;
}
ASSERT_GT(filler_count, 0u);
// Spawn a sender thread that sends a datagram with explicit SCM_CREDENTIALS while SO_PASSCRED is
// still disabled on both ends. Its initial write attempt inside sendmsg will hit EAGAIN on the
// full buffer and block until the filler datagrams are drained.
std::thread sender([&] {
char payload = 'z';
struct iovec iov = {.iov_base = &payload, .iov_len = 1};
char cmsg_buf[CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_CREDENTIALS;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
struct ucred creds = {
.pid = getpid(),
.uid = getuid(),
.gid = getgid(),
};
memcpy(CMSG_DATA(cmsg), &creds, sizeof(creds));
EXPECT_THAT(sendmsg(sv[0].get(), &msg, 0), SyscallSucceedsWithValue(1));
});
auto cleanup = fit::defer([&] {
sv[1].reset();
if (sender.joinable()) {
sender.join();
}
});
// Allow the sender thread to enter sendmsg and block on EAGAIN, then drain the filler datagrams.
usleep(20000);
std::vector<char> drain_buf(filler.size());
for (size_t i = 0; i < filler_count; ++i) {
ASSERT_THAT(recv(sv[1].get(), drain_buf.data(), drain_buf.size(), 0),
SyscallSucceedsWithValue(filler.size()));
}
sender.join();
// Enable SO_PASSCRED on the receiver after the second datagram has been queued. Because the
// explicit SCM_CREDENTIALS cmsg must be preserved across the EAGAIN retry in sendmsg, the
// receiver must observe the sender's credentials rather than unknown_creds.
int one = 1;
ASSERT_THAT(setsockopt(sv[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
SyscallSucceeds());
char rbuf = 0;
struct iovec iov = {.iov_base = &rbuf, .iov_len = 1};
char cmsg_buf[2 * CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsg_buf,
.msg_controllen = sizeof(cmsg_buf),
};
ASSERT_THAT(recvmsg(sv[1].get(), &msg, 0), SyscallSucceedsWithValue(1));
EXPECT_EQ(rbuf, 'z');
int cred_count = 0;
std::optional<struct ucred> cred;
for (struct cmsghdr* c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_CREDENTIALS) {
ASSERT_EQ(c->cmsg_len, CMSG_LEN(sizeof(struct ucred)));
struct ucred received_cred;
memcpy(&received_cred, CMSG_DATA(c), sizeof(received_cred));
cred = received_cred;
cred_count++;
}
}
EXPECT_EQ(cred_count, 1);
ASSERT_TRUE(cred.has_value());
EXPECT_EQ(cred->pid, getpid());
EXPECT_EQ(cred->uid, getuid());
EXPECT_EQ(cred->gid, getgid());
}
// This test verifies that we can concurrently attempt to create the same type of socket from
// multiple threads.
TEST(Socket, ConcurrentCreate) {
std::atomic_int barrier{0};
std::atomic_int child_ready{0};
auto child = std::thread([&] {
child_ready.store(1);
while (barrier.load() == 0) {
}
fbl::unique_fd fd;
EXPECT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
});
while (child_ready.load() == 0) {
}
barrier.store(1);
fbl::unique_fd fd;
EXPECT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
child.join();
}
TEST(Socket, SocketCookie) {
fbl::unique_fd fd;
// Create a socket and get its cookie.
EXPECT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
uint64_t cookie1 = 0;
socklen_t optlen = sizeof(cookie1);
ASSERT_EQ(getsockopt(fd.get(), SOL_SOCKET, SO_COOKIE, &cookie1, &optlen), 0) << strerror(errno);
EXPECT_EQ(optlen, sizeof(cookie1));
// Create another socket verify that it has a different cookie value.
EXPECT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_DGRAM, 0))) << strerror(errno);
uint64_t cookie2 = 0;
ASSERT_EQ(getsockopt(fd.get(), SOL_SOCKET, SO_COOKIE, &cookie2, &optlen), 0) << strerror(errno);
EXPECT_EQ(optlen, sizeof(cookie2));
EXPECT_NE(cookie1, cookie2);
}
class SocketFault : public FaultTest, public testing::WithParamInterface<std::pair<int, int>> {
protected:
void SetUp() override {
const auto [type, protocol] = GetParam();
// TODO(https://fxbug.dev/317285180) don't skip on baseline
if (type == SOCK_DGRAM && protocol == IPPROTO_ICMP && getuid() != 0) {
GTEST_SKIP() << "Ping sockets require root.";
}
sockaddr_in addr = {
.sin_family = AF_INET,
.sin_addr = {htonl(INADDR_LOOPBACK)},
};
socklen_t addrlen = sizeof(addr);
ASSERT_TRUE(recv_fd_ = fbl::unique_fd(socket(AF_INET, type, protocol))) << strerror(errno);
ASSERT_EQ(bind(recv_fd_.get(), reinterpret_cast<sockaddr*>(&addr), addrlen), 0)
<< strerror(errno);
ASSERT_EQ(getsockname(recv_fd_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen), 0)
<< strerror(errno);
ASSERT_EQ(addrlen, sizeof(addr));
if (type == SOCK_STREAM) {
ASSERT_EQ(listen(recv_fd_.get(), 0), 0) << strerror(errno);
listen_fd_ = std::move(recv_fd_);
}
ASSERT_TRUE(send_fd_ = fbl::unique_fd(socket(AF_INET, type, protocol))) << strerror(errno);
ASSERT_EQ(connect(send_fd_.get(), reinterpret_cast<const sockaddr*>(&addr), sizeof(addr)), 0)
<< strerror(errno);
if (type == SOCK_STREAM) {
ASSERT_TRUE(recv_fd_ = fbl::unique_fd(accept(listen_fd_.get(), nullptr, nullptr)))
<< strerror(errno);
} else if (protocol == IPPROTO_ICMP) {
// ICMP sockets only get the packet on the sending socket since sockets do not
// receive ICMP requests, only replies. Note that the netstack internally
// responds to ICMP requests without any user-application needing to handle
// requests.
ASSERT_TRUE(recv_fd_ = fbl::unique_fd(dup(send_fd_.get()))) << strerror(errno);
}
}
void TearDown() override {
send_fd_.reset();
recv_fd_.reset();
listen_fd_.reset();
}
void SetRecvFdNonBlocking() {
int flags = fcntl(recv_fd_.get(), F_GETFL, 0);
ASSERT_GE(flags, 0) << strerror(errno);
ASSERT_EQ(fcntl(recv_fd_.get(), F_SETFL, flags | O_NONBLOCK), 0) << strerror(errno);
}
fbl::unique_fd recv_fd_;
fbl::unique_fd listen_fd_;
fbl::unique_fd send_fd_;
};
// Test sending a packet from invalid memory.
TEST_P(SocketFault, Write) {
EXPECT_EQ(write(send_fd_.get(), faulting_ptr_, kFaultingSize_), -1);
EXPECT_EQ(errno, EFAULT);
}
// Test receiving a packet to invalid memory.
TEST_P(SocketFault, Read) {
// First send a valid message that we can read.
//
// We send an ICMP message since this test is generic over UDP/TCP/ICMP.
// UDP/TCP do not care about the shape of the payload but ICMP does so we just
// use an ICMP compatible payload for simplicity.
constexpr icmphdr kSendIcmp = {
.type = ICMP_ECHO,
};
ASSERT_EQ(write(send_fd_.get(), &kSendIcmp, sizeof(kSendIcmp)),
static_cast<ssize_t>(sizeof(kSendIcmp)));
pollfd p = {
.fd = recv_fd_.get(),
.events = POLLIN,
};
ASSERT_EQ(poll(&p, 1, -1), 1);
ASSERT_EQ(p.revents, POLLIN);
static_assert(kFaultingSize_ >= sizeof(kSendIcmp));
EXPECT_EQ(read(recv_fd_.get(), faulting_ptr_, sizeof(kSendIcmp)), -1);
EXPECT_EQ(errno, EFAULT);
}
TEST_P(SocketFault, ReadV) {
// First send a valid message that we can read.
//
// We send an ICMP message since this test is generic over UDP/TCP/ICMP.
// UDP/TCP do not care about the shape of the payload but ICMP does so we just
// use an ICMP compatible payload for simplicity.
constexpr icmphdr kSendIcmp = {
.type = ICMP_ECHO,
};
ASSERT_EQ(write(send_fd_.get(), &kSendIcmp, sizeof(kSendIcmp)),
static_cast<ssize_t>(sizeof(kSendIcmp)));
pollfd p = {
.fd = recv_fd_.get(),
.events = POLLIN,
};
ASSERT_EQ(poll(&p, 1, -1), 1);
ASSERT_EQ(p.revents, POLLIN);
char base0[1];
char base2[sizeof(kSendIcmp) - 1];
iovec iov[] = {
{
.iov_base = base0,
.iov_len = sizeof(base0),
},
{
.iov_base = faulting_ptr_,
.iov_len = sizeof(kFaultingSize_),
},
{
.iov_base = base2,
.iov_len = sizeof(base2),
},
};
// Read once with iov holding the invalid pointer.
ASSERT_EQ(readv(recv_fd_.get(), iov, std::size(iov)), -1);
EXPECT_EQ(errno, EFAULT);
// Read again after clearing the invalid buffer. This read will fail on UDP/ICMP
// sockets since they deque the message before checking the validity of buffers
// but TCP sockets will not remove bytes from the unread bytes held by the kernel
// if any buffer faults. Note that what UDP/ICMP does is ~acceptable since they are
// not meant to be a reliable protocol and the behaviour for TCP also makes sense
// because when the socket returns EFAULT, there is no way to know how many
// bytes the kernel write into our buffers. Since the kernel has no way to tell us
// how many bytes were read when a fault occurred, it has no other option than to
// keep the bytes before the fault to prevent userspace from dropping part of a
// byte stream.
ASSERT_NO_FATAL_FAILURE(SetRecvFdNonBlocking());
const auto [type, protocol] = GetParam();
iov[1] = iovec{};
if (type == SOCK_STREAM) {
ASSERT_EQ(readv(recv_fd_.get(), iov, std::size(iov)), static_cast<ssize_t>(sizeof(kSendIcmp)));
} else {
ASSERT_EQ(readv(recv_fd_.get(), iov, std::size(iov)), -1);
EXPECT_EQ(errno, EAGAIN);
}
}
TEST_P(SocketFault, WriteV) {
icmphdr kSendIcmp = {
.type = ICMP_ECHO,
};
constexpr size_t kBase0Size = 1;
iovec iov[] = {
{
.iov_base = &kSendIcmp,
.iov_len = kBase0Size,
},
{
.iov_base = faulting_ptr_,
.iov_len = sizeof(kFaultingSize_),
},
{
.iov_base = reinterpret_cast<char*>(&kSendIcmp) + kBase0Size,
.iov_len = sizeof(kSendIcmp) - kBase0Size,
},
};
ASSERT_EQ(writev(send_fd_.get(), iov, std::size(iov)), -1);
EXPECT_EQ(errno, EFAULT);
// Reading should fail since nothing should have been written.
ASSERT_NO_FATAL_FAILURE(SetRecvFdNonBlocking());
char recv_buf[sizeof(kSendIcmp)];
ASSERT_EQ(read(recv_fd_.get(), &recv_buf, sizeof(recv_buf)), -1);
EXPECT_EQ(errno, EAGAIN);
}
TEST_P(SocketFault, SendmsgENOBUFS) {
int sockfd;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
ASSERT_GT(sockfd, 0) << strerror(errno);
char data[] = "a";
struct iovec iov[] = {{
.iov_base = data,
.iov_len = 1,
}};
char buf[CMSG_SPACE(0)];
struct msghdr msg = {
.msg_iov = iov,
.msg_iovlen = 1,
.msg_control = buf,
.msg_controllen = UINT_MAX,
};
*CMSG_FIRSTHDR(&msg) = (struct cmsghdr){
.cmsg_len = UINT_MAX,
.cmsg_level = SOL_SOCKET,
.cmsg_type = SCM_RIGHTS,
};
ASSERT_EQ(sendmsg(sockfd, &msg, 0), -1);
ASSERT_EQ(errno, ENOBUFS);
}
INSTANTIATE_TEST_SUITE_P(SocketFault, SocketFault,
testing::Values(std::make_pair(SOCK_DGRAM, 0),
std::make_pair(SOCK_DGRAM, IPPROTO_ICMP),
std::make_pair(SOCK_STREAM, 0)));
class SndRcvBufSockOpt : public testing::TestWithParam<int> {};
// This test asserts that the value of SO_RCVBUF and SO_SNDBUF are doubled on
// set, and this doubled value is returned on get, as described in the Linux
// socket(7) man page.
TEST_P(SndRcvBufSockOpt, DoubledOnGet) {
fbl::unique_fd fd;
EXPECT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
int buf_size;
socklen_t optlen = sizeof(buf_size);
ASSERT_EQ(getsockopt(fd.get(), SOL_SOCKET, GetParam(), &buf_size, &optlen), 0) << strerror(errno);
ASSERT_EQ(setsockopt(fd.get(), SOL_SOCKET, GetParam(), &buf_size, optlen), 0) << strerror(errno);
int new_buf_size;
ASSERT_EQ(getsockopt(fd.get(), SOL_SOCKET, GetParam(), &new_buf_size, &optlen), 0)
<< strerror(errno);
ASSERT_EQ(new_buf_size, 2 * buf_size);
}
INSTANTIATE_TEST_SUITE_P(SndRcvBufSockOpt, SndRcvBufSockOpt, testing::Values(SO_SNDBUF, SO_RCVBUF),
[](const testing::TestParamInfo<int>& info) {
switch (info.param) {
case SO_SNDBUF:
return std::string("SO_SNDBUF");
case SO_RCVBUF:
return std::string("SO_RCVBUF");
}
return std::string("UNKNOWN(") + std::to_string(info.param) + ")";
});
struct PrivilegedSockOptParam {
int domain;
int type;
int level;
int optname;
};
class PrivilegedSockOptTest : public testing::TestWithParam<PrivilegedSockOptParam> {
protected:
void SetUp() override {
if (!test_helper::HasCapability(CAP_NET_ADMIN) || !test_helper::HasCapability(CAP_NET_RAW)) {
GTEST_SKIP()
<< "Need CAP_NET_ADMIN and CAP_NET_RAW to run capability-restricted sockopt tests";
}
auto param = GetParam();
EXPECT_TRUE(fd_ = fbl::unique_fd(socket(param.domain, param.type, 0))) << strerror(errno);
}
fbl::unique_fd fd_;
};
std::string PrintPrivilegedSockOptParam(
const testing::TestParamInfo<PrivilegedSockOptParam>& info) {
auto param = info.param;
std::string domain_str = (param.domain == AF_INET) ? "IPv4" : "IPv6";
std::string type_str = (param.type == SOCK_STREAM) ? "TCP" : "UDP";
std::string level_str = (param.level == SOL_SOCKET) ? "SOL_SOCKET" : "SOL_IP";
std::string optname_str = (param.optname == SO_MARK) ? "SO_MARK" : "IP_TRANSPARENT";
return domain_str + "_" + type_str + "_" + level_str + "_" + optname_str;
}
TEST_P(PrivilegedSockOptTest, SetAndGet) {
auto param = GetParam();
// Verify initial value is 0.
int initial_val = -1;
socklen_t optlen = sizeof(initial_val);
ASSERT_EQ(getsockopt(fd_.get(), param.level, param.optname, &initial_val, &optlen), 0)
<< strerror(errno);
ASSERT_EQ(initial_val, 0);
// Set to 1.
int val = 1;
ASSERT_EQ(setsockopt(fd_.get(), param.level, param.optname, &val, sizeof(val)), 0)
<< strerror(errno);
// Get and verify.
int retrieved_val = 0;
optlen = sizeof(retrieved_val);
ASSERT_EQ(getsockopt(fd_.get(), param.level, param.optname, &retrieved_val, &optlen), 0)
<< strerror(errno);
ASSERT_EQ(optlen, sizeof(val));
ASSERT_EQ(val, retrieved_val);
}
TEST_P(PrivilegedSockOptTest, NoCapabilities) {
auto param = GetParam();
test_helper::ForkHelper fork_helper;
fork_helper.RunInForkedProcess([&]() {
test_helper::UnsetCapabilityEffective(CAP_NET_ADMIN);
test_helper::UnsetCapabilityEffective(CAP_NET_RAW);
// `setsockopt` must fail with EPERM.
int val = 1;
EXPECT_EQ(setsockopt(fd_.get(), param.level, param.optname, &val, sizeof(val)), -1);
EXPECT_EQ(errno, EPERM);
});
}
TEST_P(PrivilegedSockOptTest, RawCapability) {
auto param = GetParam();
test_helper::ForkHelper fork_helper;
fork_helper.RunInForkedProcess([&]() {
// Drop the `NET_ADMIN` capability, but keep `NET_RAW`.
test_helper::UnsetCapabilityEffective(CAP_NET_ADMIN);
int val = 1;
ASSERT_EQ(setsockopt(fd_.get(), param.level, param.optname, &val, sizeof(val)), 0)
<< strerror(errno);
});
}
TEST_P(PrivilegedSockOptTest, AdminCapability) {
auto param = GetParam();
test_helper::ForkHelper fork_helper;
fork_helper.RunInForkedProcess([&]() {
// Drop the `NET_RAW` capability, but keep `NET_ADMIN`.
test_helper::UnsetCapabilityEffective(CAP_NET_RAW);
int val = 1;
ASSERT_EQ(setsockopt(fd_.get(), param.level, param.optname, &val, sizeof(val)), 0)
<< strerror(errno);
});
}
INSTANTIATE_TEST_SUITE_P(PrivilegedSockOpt, PrivilegedSockOptTest,
testing::Values(
// SO_MARK
PrivilegedSockOptParam{AF_INET, SOCK_STREAM, SOL_SOCKET, SO_MARK},
PrivilegedSockOptParam{AF_INET, SOCK_DGRAM, SOL_SOCKET, SO_MARK},
PrivilegedSockOptParam{AF_INET6, SOCK_STREAM, SOL_SOCKET, SO_MARK},
PrivilegedSockOptParam{AF_INET6, SOCK_DGRAM, SOL_SOCKET, SO_MARK},
// IP_TRANSPARENT
PrivilegedSockOptParam{AF_INET, SOCK_DGRAM, SOL_IP, IP_TRANSPARENT},
PrivilegedSockOptParam{AF_INET6, SOCK_DGRAM, SOL_IP, IP_TRANSPARENT}),
PrintPrivilegedSockOptParam);
class BpfTest : public testing::Test {
protected:
void SetUp() override {
if (!test_helper::HasCapability(CAP_NET_RAW)) {
GTEST_SKIP() << "Need CAP_NET_RAW to run BpfTest";
}
packet_socket_fd_ = fbl::unique_fd(socket(AF_PACKET, SOCK_RAW, 0));
ASSERT_TRUE(packet_socket_fd_) << strerror(errno);
}
void AttachFilterAndBind(const sock_fprog& filter);
void SendPacketAndCheckReceived(int domain, uint16_t dst_port, bool expected);
fbl::unique_fd packet_socket_fd_;
};
void BpfTest::AttachFilterAndBind(const sock_fprog& filter) {
// Attach the BPF filter before binding to ETH_P_ALL so no unfiltered packets
// (e.g. asynchronous loopback ICMP errors from prior tests) can be queued
// between bind() and setsockopt(SO_ATTACH_FILTER).
ASSERT_EQ(
setsockopt(packet_socket_fd_.get(), SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter)), 0)
<< strerror(errno);
sockaddr_ll addr_ll = {
.sll_family = AF_PACKET,
.sll_protocol = htons(ETH_P_ALL),
};
ASSERT_EQ(bind(packet_socket_fd_.get(), reinterpret_cast<sockaddr*>(&addr_ll), sizeof(addr_ll)),
0)
<< strerror(errno);
}
void BpfTest::SendPacketAndCheckReceived(int domain, uint16_t dst_port, bool expected) {
sockaddr_in addr4 = {
.sin_family = AF_INET,
.sin_port = htons(dst_port),
.sin_addr =
{
.s_addr = htonl(INADDR_LOOPBACK),
},
};
sockaddr_in6 addr6 = {
.sin6_family = AF_INET6,
.sin6_port = htons(dst_port),
.sin6_addr = IN6ADDR_LOOPBACK_INIT,
};
sockaddr* addr = domain == AF_INET6 ? reinterpret_cast<sockaddr*>(&addr6)
: reinterpret_cast<sockaddr*>(&addr4);
socklen_t addrlen = domain == AF_INET6 ? sizeof(addr6) : sizeof(addr4);
const char data[] = "test message";
fbl::unique_fd sendfd;
ASSERT_TRUE(sendfd = fbl::unique_fd(socket(domain, SOCK_DGRAM, 0))) << strerror(errno);
ASSERT_EQ(sendto(sendfd.get(), data, sizeof(data), 0, addr, addrlen),
static_cast<int>(sizeof(data)))
<< strerror(errno);
pollfd pfd = {
.fd = packet_socket_fd_.get(),
.events = POLLIN,
};
const int kPositiveCheckTimeoutMs = 10000;
const int kNegativeCheckTimeoutMs = 1000;
int timeout = expected ? kPositiveCheckTimeoutMs : kNegativeCheckTimeoutMs;
int n = poll(&pfd, 1, timeout);
ASSERT_GE(n, 0) << strerror(errno);
if (expected) {
ASSERT_EQ(n, 1);
char buf[4096];
ASSERT_GT(recv(packet_socket_fd_.get(), buf, sizeof(buf), 0), 0);
// The packet was sent to loopback, so we expect to receive it twice.
ASSERT_EQ(poll(&pfd, 1, 1000), 1);
ASSERT_GT(recv(packet_socket_fd_.get(), buf, sizeof(buf), 0), 0);
} else {
ASSERT_EQ(n, 0);
}
}
TEST_F(BpfTest, SoAttachFilter) {
const uint16_t kTestDstPortIpv4 = 1234;
const uint16_t kTestDstPortIpv6 = 1236;
// This filter accepts IPv4 UDP packets on port kTestDstPortIpv4 and IPv6 UDP
// packets on port kTestDstPortIpv6.
static sock_filter filter_code[] = {
// Load the protocol.
BPF_STMT(BPF_LD | BPF_H | BPF_ABS, (__u32)SKF_AD_OFF + SKF_AD_PROTOCOL),
// Check if this is IPv4, skip below otherwise.
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ETHERTYPE_IP, 0, 8),
// Check that the protocol is UDP.
BPF_STMT(BPF_LD | BPF_B | BPF_ABS, (__u32)SKF_NET_OFF + 9),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, IPPROTO_UDP, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Get the IP header length.
BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, (__u32)SKF_NET_OFF),
// Check the destination port.
BPF_STMT(BPF_LD | BPF_H | BPF_IND, (__u32)SKF_NET_OFF + 2),
// Reject if not kTestDstPortIpv4.
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, kTestDstPortIpv4, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Accept.
BPF_STMT(BPF_RET | BPF_K, 0xFFFFFFFF),
// Check if this is IPv6.
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ETHERTYPE_IPV6, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Check the protocol is UDP.
BPF_STMT(BPF_LD | BPF_B | BPF_ABS, (__u32)SKF_NET_OFF + 6),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, IPPROTO_UDP, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Load destination port, assuming standard, 40-byte IPv6 packet.
BPF_STMT(BPF_LD | BPF_H | BPF_ABS, (__u32)SKF_NET_OFF + 42),
// Check destination port.
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, kTestDstPortIpv6, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Accept.
BPF_STMT(BPF_RET | BPF_K, 0xFFFFFFFF),
};
static const sock_fprog filter = {
sizeof(filter_code) / sizeof(filter_code[0]),
filter_code,
};
ASSERT_NO_FATAL_FAILURE(AttachFilterAndBind(filter));
ASSERT_NO_FATAL_FAILURE(SendPacketAndCheckReceived(AF_INET, kTestDstPortIpv4, true));
ASSERT_NO_FATAL_FAILURE(SendPacketAndCheckReceived(AF_INET6, kTestDstPortIpv6, true));
ASSERT_NO_FATAL_FAILURE(SendPacketAndCheckReceived(AF_INET, kTestDstPortIpv6, false));
ASSERT_NO_FATAL_FAILURE(SendPacketAndCheckReceived(AF_INET6, kTestDstPortIpv4, false));
}
TEST_F(BpfTest, SoAttachFilterBpfLen) {
constexpr uint16_t kTestDstPortIpv4 = 1235;
static sock_filter filter_code[] = {
// Check if this is IPv4.
BPF_STMT(BPF_LD | BPF_H | BPF_ABS, (__u32)SKF_AD_OFF + SKF_AD_PROTOCOL),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ETHERTYPE_IP, 0, 6),
// Check that the protocol is UDP.
BPF_STMT(BPF_LD | BPF_B | BPF_ABS, (__u32)SKF_NET_OFF + 9),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, IPPROTO_UDP, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Get the IP header length.
BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, (__u32)SKF_NET_OFF),
// Check the destination port.
BPF_STMT(BPF_LD | BPF_H | BPF_IND, (__u32)SKF_NET_OFF + 2),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, kTestDstPortIpv4, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Accept up to packet length loaded via BPF_LEN.
BPF_STMT(BPF_LDX | BPF_W | BPF_LEN, 0),
BPF_STMT(BPF_LD | BPF_W | BPF_LEN, 0),
BPF_STMT(BPF_RET | BPF_A, 0),
};
static const sock_fprog filter = {
sizeof(filter_code) / sizeof(filter_code[0]),
filter_code,
};
ASSERT_NO_FATAL_FAILURE(AttachFilterAndBind(filter));
ASSERT_NO_FATAL_FAILURE(SendPacketAndCheckReceived(AF_INET, kTestDstPortIpv4, true));
}
TEST_F(BpfTest, SoAttachFilterPktType) {
constexpr uint16_t kTestDstPortIpv4 = 1237;
auto make_filter = [](uint8_t packet_type) -> std::vector<sock_filter> {
return {
// Check packet type == packet_type.
BPF_STMT(BPF_LD | BPF_B | BPF_ABS, (__u32)SKF_AD_OFF + SKF_AD_PKTTYPE),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, packet_type, 0, 8),
// Check if this is IPv4.
BPF_STMT(BPF_LD | BPF_H | BPF_ABS, (__u32)SKF_AD_OFF + SKF_AD_PROTOCOL),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ETHERTYPE_IP, 0, 6),
// Check that the protocol is UDP.
BPF_STMT(BPF_LD | BPF_B | BPF_ABS, (__u32)SKF_NET_OFF + 9),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, IPPROTO_UDP, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Get the IP header length.
BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, (__u32)SKF_NET_OFF),
// Check the destination port.
BPF_STMT(BPF_LD | BPF_H | BPF_IND, (__u32)SKF_NET_OFF + 2),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, kTestDstPortIpv4, 1, 0),
BPF_STMT(BPF_RET | BPF_K, 0),
// Accept.
BPF_STMT(BPF_RET | BPF_K, 0xFFFFFFFF),
};
};
// This filter accepts IPv4 UDP packets on port kTestDstPortIpv4 only if they are PACKET_OUTGOING.
std::vector<sock_filter> filter_outgoing_code = make_filter(PACKET_OUTGOING);
const sock_fprog filter_outgoing = {
.len = static_cast<unsigned short>(filter_outgoing_code.size()),
.filter = filter_outgoing_code.data(),
};
ASSERT_NO_FATAL_FAILURE(AttachFilterAndBind(filter_outgoing));
// Send a packet to loopback. When sent to loopback without a filter, the packet is captured twice
// (once as PACKET_OUTGOING on egress, once as PACKET_HOST on ingress). With the filter above,
// only the outgoing packet is received.
sockaddr_in addr4 = {
.sin_family = AF_INET,
.sin_port = htons(kTestDstPortIpv4),
.sin_addr =
{
.s_addr = htonl(INADDR_LOOPBACK),
},
};
const char data[] = "test message";
fbl::unique_fd sendfd;
ASSERT_TRUE(sendfd = fbl::unique_fd(socket(AF_INET, SOCK_DGRAM, 0))) << strerror(errno);
ASSERT_EQ(sendto(sendfd.get(), data, sizeof(data), 0, reinterpret_cast<sockaddr*>(&addr4),
sizeof(addr4)),
static_cast<int>(sizeof(data)))
<< strerror(errno);
pollfd pfd = {
.fd = packet_socket_fd_.get(),
.events = POLLIN,
};
ASSERT_EQ(poll(&pfd, 1, 10000), 1);
char buf[4096];
ASSERT_GT(recv(packet_socket_fd_.get(), buf, sizeof(buf), 0), 0);
// The second packet (PACKET_HOST on ingress) should be dropped by the filter.
ASSERT_EQ(poll(&pfd, 1, 1000), 0);
// Now test with PACKET_HOST filter.
std::vector<sock_filter> filter_host_code = make_filter(PACKET_HOST);
const sock_fprog filter_host = {
.len = static_cast<unsigned short>(filter_host_code.size()),
.filter = filter_host_code.data(),
};
ASSERT_EQ(setsockopt(packet_socket_fd_.get(), SOL_SOCKET, SO_ATTACH_FILTER, &filter_host,
sizeof(filter_host)),
0);
ASSERT_EQ(sendto(sendfd.get(), data, sizeof(data), 0, reinterpret_cast<sockaddr*>(&addr4),
sizeof(addr4)),
static_cast<int>(sizeof(data)))
<< strerror(errno);
ASSERT_EQ(poll(&pfd, 1, 10000), 1);
ASSERT_GT(recv(packet_socket_fd_.get(), buf, sizeof(buf), 0), 0);
// Egress packet was dropped, only one packet (PACKET_HOST on ingress) received.
ASSERT_EQ(poll(&pfd, 1, 1000), 0);
}
TEST(IpTables, IpTablesAdminCap) {
if (!test_helper::HasCapability(CAP_NET_ADMIN)) {
GTEST_SKIP() << "Need CAP_NET_ADMIN to access iptables";
}
fbl::unique_fd sock;
ASSERT_TRUE(sock = fbl::unique_fd(socket(AF_INET, SOCK_RAW, IPPROTO_ICMP))) << strerror(errno);
struct xt_get_revision optval = {};
strncpy(optval.name, "REDIRECT", sizeof(optval.name));
optval.revision = 0;
socklen_t optval_size = sizeof(optval);
ASSERT_EQ(getsockopt(sock.get(), SOL_IP, IPT_SO_GET_REVISION_TARGET, &optval, &optval_size), 0);
test_helper::UnsetCapabilityEffective(CAP_NET_ADMIN);
ASSERT_EQ(getsockopt(sock.get(), SOL_IP, IPT_SO_GET_REVISION_TARGET, &optval, &optval_size), -1);
EXPECT_EQ(errno, EPERM);
test_helper::SetCapabilityEffective(CAP_NET_ADMIN);
}
// Helper to override `/proc/sys/net/ipv4/ping_group_range`.
class IcmpPingGidOverride {
public:
static constexpr char FILE_NAME[] = "/proc/sys/net/ipv4/ping_group_range";
IcmpPingGidOverride() {
{
// First check that the file is writable.
std::ofstream outfile(FILE_NAME);
can_override_ = outfile.is_open();
}
if (can_override_) {
std::tie(original_min_gid_, original_max_gid_) = Get();
}
}
~IcmpPingGidOverride() {
if (can_override_) {
Set(original_min_gid_, original_max_gid_);
}
}
bool can_override() { return can_override_; }
std::pair<gid_t, gid_t> Get() {
std::ifstream ping_group_range_file(FILE_NAME);
EXPECT_TRUE(ping_group_range_file.is_open()) << strerror(errno);
gid_t min, max;
ping_group_range_file >> min >> max;
return std::make_pair(min, max);
}
void Set(gid_t min, gid_t max) {
std::ofstream ping_group_range_file(FILE_NAME);
ASSERT_TRUE(ping_group_range_file.is_open()) << strerror(errno);
ping_group_range_file << min << " " << max;
ping_group_range_file.close();
EXPECT_FALSE(ping_group_range_file.fail());
}
void SetMin(gid_t min) {
std::ofstream ping_group_range_file(FILE_NAME);
ASSERT_TRUE(ping_group_range_file.is_open()) << strerror(errno);
ping_group_range_file << min;
ping_group_range_file.close();
EXPECT_FALSE(ping_group_range_file.fail());
}
private:
bool can_override_ = false;
gid_t original_min_gid_ = 0;
gid_t original_max_gid_ = 0;
};
class IcmpPingSocket : public testing::Test {
protected:
void SetUp() override {
if (!test_helper::HasCapability(CAP_SETGID)) {
GTEST_SKIP() << "Need CAP_SET_GID to access iptables";
}
if (!gid_range_.can_override()) {
GTEST_SKIP() << "Need writable " << IcmpPingGidOverride::FILE_NAME;
}
}
int TryCreateSocket(bool use_v6 = false) {
fbl::unique_fd sock(
socket(use_v6 ? AF_INET6 : AF_INET, SOCK_DGRAM,
use_v6 ? static_cast<int>(IPPROTO_ICMPV6) : static_cast<int>(IPPROTO_ICMP)));
if (sock) {
return 0;
} else {
return -errno;
}
}
void TestWriteRangeFail(const char contents[]) {
std::ofstream ping_group_range_file(IcmpPingGidOverride::FILE_NAME);
ASSERT_TRUE(ping_group_range_file.is_open()) << strerror(errno);
ping_group_range_file << contents;
ping_group_range_file.close();
EXPECT_TRUE(ping_group_range_file.fail());
}
void TryCreateSocketWithGid(gid_t gid, int expected_result, bool use_v6 = false) {
SCOPED_TRACE(fxl::StringPrintf("GID: %d", gid));
ASSERT_EQ(setegid(gid), 0) << strerror(errno);
ASSERT_EQ(TryCreateSocket(use_v6), expected_result);
}
IcmpPingGidOverride gid_range_;
};
TEST_F(IcmpPingSocket, UpdateGidRange) {
gid_range_.Set(10, 100);
ASSERT_EQ(gid_range_.Get(), std::make_pair(10, 100));
gid_range_.Set(10, 0);
ASSERT_EQ(gid_range_.Get(), std::make_pair(1, 0));
gid_range_.Set(10, 30);
ASSERT_EQ(gid_range_.Get(), std::make_pair(10, 30));
gid_range_.SetMin(20);
ASSERT_EQ(gid_range_.Get(), std::make_pair(20, 30));
gid_range_.SetMin(30);
ASSERT_EQ(gid_range_.Get(), std::make_pair(30, 30));
gid_range_.SetMin(31);
ASSERT_EQ(gid_range_.Get(), std::make_pair(1, 0));
}
TEST_F(IcmpPingSocket, CreateSocket) {
gid_t original_gid = getegid();
gid_range_.Set(10, 100);
TryCreateSocketWithGid(9, -EACCES);
TryCreateSocketWithGid(10, 0);
TryCreateSocketWithGid(50, 0);
TryCreateSocketWithGid(100, 0);
TryCreateSocketWithGid(101, -EACCES);
ASSERT_EQ(setegid(original_gid), 0) << strerror(errno);
}
TEST_F(IcmpPingSocket, CreateSocketV6) {
gid_t original_gid = getegid();
gid_range_.Set(10, 100);
TryCreateSocketWithGid(9, -EACCES, true);
TryCreateSocketWithGid(10, 0, true);
TryCreateSocketWithGid(50, 0, true);
TryCreateSocketWithGid(100, 0, true);
TryCreateSocketWithGid(101, -EACCES, true);
ASSERT_EQ(setegid(original_gid), 0) << strerror(errno);
}
// Verifies that attempts to write an out-of-range value to the
// `ping_group_range` file are rejected. Starnix and current versions of Linux
// (e.g. 6.12) allow any values in range [0, 2^32-2] (i.e. any uint32_t, except
// UINT32_MAX). Older Linux versions (e.g. 5.15) allow only values in range
// [0, 2^31-1] (i.e. non-negative int32_t), which will cause this test to fail.
TEST_F(IcmpPingSocket, SetInvalid) {
TestWriteRangeFail("---");
// Min and max cannot be higher than 2^32-2.
TestWriteRangeFail("0 4294967295");
TestWriteRangeFail("0 4294967296");
TestWriteRangeFail("4294967295 0");
TestWriteRangeFail("4294967296 0");
// We should be able to set both values to 2^32-2.
gid_range_.Set(0, 4294967294);
gid_range_.Set(4294967294, 0);
}
TEST(InetSocket, BindToDevice) {
if (!test_helper::HasCapability(CAP_NET_RAW)) {
GTEST_SKIP() << "Need CAP_NET_RAW to access SO_BINDTODEVICE";
}
if (!test_helper::IsStarnix()) {
GTEST_SKIP() << "This test verifies behavior specific to Starnix";
}
test_helper::UnsetCapabilityEffective(CAP_NET_RAW);
fbl::unique_fd sock;
ASSERT_TRUE(sock = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
char iface[] = "lo";
EXPECT_EQ(setsockopt(sock.get(), SOL_SOCKET, SO_BINDTODEVICE, iface, sizeof(iface)), -1);
EXPECT_EQ(errno, EPERM);
test_helper::SetCapabilityEffective(CAP_NET_RAW);
}
class ReusePortSharingTest : public testing::Test {
protected:
void SetUp() override {
if (!test_helper::HasCapability(CAP_SETUID)) {
GTEST_SKIP() << "Need CAP_SETUID to access seteuid()";
}
}
void SetReusePort(int fd) {
int optval = 1;
EXPECT_THAT(setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval)),
SyscallSucceeds());
}
};
TEST_F(ReusePortSharingTest, ReusePortSharing) {
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(12345);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
// Bind first socket from UID=1.
EXPECT_THAT(seteuid(1), SyscallSucceeds());
fbl::unique_fd sock1;
EXPECT_TRUE(sock1 = fbl::unique_fd(socket(AF_INET, SOCK_DGRAM, 0))) << strerror(errno);
SetReusePort(sock1.get());
EXPECT_THAT(bind(sock1.get(), (struct sockaddr*)(&addr), sizeof(addr)), SyscallSucceeds());
{
// Should be able to bind another socket from the same UID.
fbl::unique_fd sock2;
EXPECT_TRUE(sock2 = fbl::unique_fd(socket(AF_INET, SOCK_DGRAM, 0))) << strerror(errno);
SetReusePort(sock2.get());
EXPECT_THAT(bind(sock2.get(), (struct sockaddr*)(&addr), sizeof(addr)), SyscallSucceeds());
}
// Restore `CAP_SETUID`, otherwise `seteuid()` will fail.
test_helper::SetCapabilityEffective(CAP_SETUID);
EXPECT_THAT(seteuid(2), SyscallSucceeds());
fbl::unique_fd sock3;
EXPECT_TRUE(sock3 = fbl::unique_fd(socket(AF_INET, SOCK_DGRAM, 0))) << strerror(errno);
SetReusePort(sock3.get());
// Should not be able to bind another socket from a different UID.
EXPECT_THAT(bind(sock3.get(), (struct sockaddr*)(&addr), sizeof(addr)),
SyscallFailsWithErrno(EADDRINUSE));
// Restore original uid.
EXPECT_THAT(setresuid(0, 0, 0), SyscallSucceeds());
}
TEST(Socket, GetSockOptZeroSize) {
fbl::unique_fd fd;
ASSERT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
uint8_t buf = 'x';
socklen_t optlen = 0;
// This might return an error or succeed depending on the platform/kernel version,
// but importantly, it shouldn't crash the kernel (b/356896105).
getsockopt(fd.get(), SOL_SOCKET, SO_BINDTODEVICE, &buf, &optlen);
// And the original TCP_CONGESTION option
optlen = 0;
getsockopt(fd.get(), SOL_TCP, TCP_CONGESTION, &buf, &optlen);
}
void VerifyGetsockoptTruncation(int fd, int level, int optname, socklen_t expected_full_size) {
ASSERT_LE(expected_full_size, 248u);
// First, get the full option value.
uint8_t full_buf[256] = {0};
socklen_t full_len = sizeof(full_buf);
ASSERT_THAT(getsockopt(fd, level, optname, full_buf, &full_len), SyscallSucceeds());
ASSERT_EQ(full_len, expected_full_size);
uint8_t truncated_buf[256];
constexpr uint8_t kPresetValue = 0xcd;
// Test different truncation lengths.
for (socklen_t optlen = 0; optlen <= expected_full_size + 8; ++optlen) {
memset(truncated_buf, kPresetValue, sizeof(truncated_buf));
socklen_t optlen_out = optlen;
ASSERT_THAT(getsockopt(fd, level, optname, truncated_buf, &optlen_out), SyscallSucceeds())
<< "Failed for optlen=" << optlen;
if (optlen > expected_full_size) {
EXPECT_EQ(optlen_out, expected_full_size);
} else {
EXPECT_EQ(optlen_out, optlen);
}
// Verify that the first `optlen_out` bytes match the full option value.
for (socklen_t i = 0; i < optlen_out; ++i) {
EXPECT_EQ(truncated_buf[i], full_buf[i])
<< "Mismatch at index " << i << " for optlen=" << optlen;
}
// Verify that the bytes after `optlen_out` are untouched.
for (size_t i = optlen_out; i < sizeof(truncated_buf); ++i) {
EXPECT_EQ(truncated_buf[i], kPresetValue)
<< "Buffer overflow at index " << i << " for optlen=" << optlen;
}
}
}
TEST(GetsockoptTruncationTest, TcpNodelay) {
fbl::unique_fd fd;
ASSERT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
int one = 1;
ASSERT_EQ(setsockopt(fd.get(), SOL_TCP, TCP_NODELAY, &one, sizeof(one)), 0) << strerror(errno);
VerifyGetsockoptTruncation(fd.get(), SOL_TCP, TCP_NODELAY, sizeof(int));
}
TEST(GetsockoptTruncationTest, TcpReuseAddr) {
fbl::unique_fd fd;
ASSERT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
int one = 1;
ASSERT_EQ(setsockopt(fd.get(), SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)), 0)
<< strerror(errno);
VerifyGetsockoptTruncation(fd.get(), SOL_SOCKET, SO_REUSEADDR, sizeof(int));
}
TEST(GetsockoptTruncationTest, UdpReuseAddr) {
fbl::unique_fd fd;
ASSERT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_DGRAM, 0))) << strerror(errno);
int one = 1;
ASSERT_EQ(setsockopt(fd.get(), SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)), 0)
<< strerror(errno);
VerifyGetsockoptTruncation(fd.get(), SOL_SOCKET, SO_REUSEADDR, sizeof(int));
}
TEST(GetsockoptTruncationTest, UnixReuseAddr) {
fbl::unique_fd fd;
ASSERT_TRUE(fd = fbl::unique_fd(socket(AF_UNIX, SOCK_STREAM, 0))) << strerror(errno);
int one = 1;
ASSERT_EQ(setsockopt(fd.get(), SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)), 0)
<< strerror(errno);
VerifyGetsockoptTruncation(fd.get(), SOL_SOCKET, SO_REUSEADDR, sizeof(int));
}
TEST(GetsockoptTruncationTest, RcvTimeo) {
fbl::unique_fd fd;
ASSERT_TRUE(fd = fbl::unique_fd(socket(AF_INET, SOCK_STREAM, 0))) << strerror(errno);
struct timeval tv = {.tv_sec = 42, .tv_usec = 123456};
ASSERT_EQ(setsockopt(fd.get(), SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)), 0) << strerror(errno);
VerifyGetsockoptTruncation(fd.get(), SOL_SOCKET, SO_RCVTIMEO, sizeof(struct timeval));
}
class ScmCredentialsTest : public testing::Test {
protected:
void SetUp() override {
int tmp[2];
int one = 1;
if (geteuid() != 0 && !test_helper::HasCapabilityEffective(CAP_SYS_ADMIN)) {
GTEST_SKIP() << "Test requires root or CAP_SYS_ADMIN to setresuid/setresgid";
}
ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, tmp));
sv_[0].reset(tmp[0]);
sv_[1].reset(tmp[1]);
setsockopt(sv_[1].get(), SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
memset(cmsgbuf_, 0, sizeof(cmsgbuf_));
msg_.msg_iov = &iov_;
msg_.msg_iovlen = 1;
msg_.msg_control = cmsgbuf_;
msg_.msg_controllen = sizeof(cmsgbuf_);
}
struct SenderCredentials {
uid_t uid, euid, suid;
gid_t gid, egid, sgid;
};
struct Caps {
bool has_cap_sys_admin = false;
bool has_cap_setuid = false;
bool has_cap_setgid = false;
};
struct Outcome {
bool success = false;
int error;
};
void TestForgery(std::optional<pid_t> forged_pid, uid_t forged_uid, gid_t forged_gid,
SenderCredentials sender, Caps caps, Outcome expected_outcome) {
test_helper::ForkHelper helper;
helper.RunInForkedProcess([this, forged_pid, forged_uid, forged_gid, sender, caps,
expected_outcome] {
ASSERT_EQ(0, prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0));
ASSERT_THAT(setresgid(sender.gid, sender.egid, sender.sgid), SyscallSucceeds());
ASSERT_THAT(setresuid(sender.uid, sender.euid, sender.suid), SyscallSucceeds());
if (caps.has_cap_sys_admin) {
test_helper::SetCapabilityEffective(CAP_SYS_ADMIN);
} else {
test_helper::UnsetCapabilityEffective(CAP_SYS_ADMIN);
}
if (caps.has_cap_setuid) {
test_helper::SetCapabilityEffective(CAP_SETUID);
} else {
test_helper::UnsetCapabilityEffective(CAP_SETUID);
}
if (caps.has_cap_setgid) {
test_helper::SetCapabilityEffective(CAP_SETGID);
} else {
test_helper::UnsetCapabilityEffective(CAP_SETGID);
}
struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg_);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_CREDENTIALS;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
struct ucred cred;
cred.pid = forged_pid.value_or(getpid());
cred.uid = forged_uid;
cred.gid = forged_gid;
fbl::UnalignedStore(CMSG_DATA(cmsg), cred);
if (expected_outcome.success) {
EXPECT_THAT(sendmsg(sv_[0].get(), &msg_, 0), SyscallSucceeds());
} else {
EXPECT_THAT(sendmsg(sv_[0].get(), &msg_, 0), SyscallFailsWithErrno(expected_outcome.error));
}
});
ASSERT_TRUE(helper.WaitForChildren());
}
fbl::unique_fd sv_[2] = {};
char data_[1] = {'x'};
struct iovec iov_ = {.iov_base = data_, .iov_len = 1};
char cmsgbuf_[CMSG_SPACE(sizeof(struct ucred))] = {};
struct msghdr msg_ = {};
};
TEST_F(ScmCredentialsTest, PidForgeryRequiresCapSysAdmin) {
Caps no_caps = {};
SenderCredentials sender = {
.uid = 100, .euid = 100, .suid = 100, .gid = 200, .egid = 200, .sgid = 200};
// PID mismatch rejected
TestForgery(1, 100, 200, sender, no_caps, {.error = EPERM});
// PID mismatch allowed by CAP_SYS_ADMIN
TestForgery(1, 100, 200, sender, {.has_cap_sys_admin = true}, {.success = true});
}
TEST_F(ScmCredentialsTest, ZombiePidForgeryFails) {
Caps no_caps = {};
SenderCredentials sender = {
.uid = 100, .euid = 100, .suid = 100, .gid = 200, .egid = 200, .sgid = 200};
pid_t zombie_pid;
test_helper::ForkHelper helper;
zombie_pid = helper.RunInForkedProcess([] { _exit(0); });
fbl::unique_fd pid_fd(static_cast<int>(syscall(SYS_pidfd_open, zombie_pid, 0u)));
ASSERT_THAT(pid_fd.get(), SyscallSucceeds());
// The child's SIGCHLD can interrupt the wait, so retry on EINTR.
pollfd pfd = {.fd = pid_fd.get(), .events = POLLIN};
ASSERT_THAT(HANDLE_EINTR(poll(&pfd, 1, -1)), SyscallSucceedsWithValue(1));
EXPECT_EQ(pfd.revents, POLLIN);
// Without CAP_SYS_ADMIN, it should fail with EPERM (forgery not allowed).
TestForgery(zombie_pid, 100, 200, sender, no_caps, {.error = EPERM});
// With CAP_SYS_ADMIN, it fails with ESRCH because the process is a zombie.
TestForgery(zombie_pid, 100, 200, sender, {.has_cap_sys_admin = true}, {.error = ESRCH});
ASSERT_TRUE(helper.WaitForChildren());
}
TEST_F(ScmCredentialsTest, ForgeryUid) {
Caps no_caps = {};
SenderCredentials sender = {
.uid = 100, .euid = 101, .suid = 102, .gid = 200, .egid = 200, .sgid = 200};
// UID mismatch (matches none of ruid, euid, suid) rejected
TestForgery(std::nullopt, 103, 200, sender, no_caps, {.error = EPERM});
// UID mismatch allowed by CAP_SETUID
TestForgery(std::nullopt, 103, 200, sender, {.has_cap_setuid = true}, {.success = true});
// Success if at least one UID matches
TestForgery(std::nullopt, 100, 200, sender, no_caps, {.success = true});
TestForgery(std::nullopt, 101, 200, sender, no_caps, {.success = true});
TestForgery(std::nullopt, 102, 200, sender, no_caps, {.success = true});
}
TEST_F(ScmCredentialsTest, ForgeryGid) {
Caps no_caps = {};
SenderCredentials sender = {
.uid = 100, .euid = 100, .suid = 100, .gid = 200, .egid = 201, .sgid = 202};
// GID mismatch (matches none of rgid, egid, sgid) rejected
TestForgery(std::nullopt, 100, 203, sender, no_caps, {.error = EPERM});
// GID mismatch allowed by CAP_SETGID
TestForgery(std::nullopt, 100, 203, sender, {.has_cap_setgid = true}, {.success = true});
// Success if at least one GID matches
TestForgery(std::nullopt, 100, 200, sender, no_caps, {.success = true});
TestForgery(std::nullopt, 100, 201, sender, no_caps, {.success = true});
TestForgery(std::nullopt, 100, 202, sender, no_caps, {.success = true});
}
TEST(SocketCrossFamilyTest, CrossFamilyBindConnectSendto) {
sockaddr_in addr_ipv4 = {};
addr_ipv4.sin_family = AF_INET;
addr_ipv4.sin_port = htons(0);
addr_ipv4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
sockaddr_in6 addr_ipv6 = {};
addr_ipv6.sin6_family = AF_INET6;
addr_ipv6.sin6_port = htons(0);
addr_ipv6.sin6_addr = in6addr_loopback;
sockaddr_un addr_unix = {};
addr_unix.sun_family = AF_UNIX;
const char abstract_name[] = "\0/abstract_name_unix_socket";
memcpy(addr_unix.sun_path, abstract_name, sizeof(abstract_name) - 1);
socklen_t addr_unix_short_len = offsetof(sockaddr_un, sun_path) + 5; // 7 bytes (< 16)
socklen_t addr_unix_med_len = offsetof(sockaddr_un, sun_path) + 20; // 22 bytes (16 <= len < 24)
socklen_t addr_unix_long_len =
offsetof(sockaddr_un, sun_path) + sizeof(abstract_name) - 1; // 29 bytes (>= 28)
sockaddr addr_unspec = {};
addr_unspec.sa_family = AF_UNSPEC;
char buf[4] = {'t', 'e', 's', 't'};
// 1. AF_INET SOCK_DGRAM
{
fbl::unique_fd fd(socket(AF_INET, SOCK_DGRAM, 0));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
// Earlier EBADF and EFAULT checks take precedence over sockaddr length and family validation.
EXPECT_THAT(bind(-1, reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EBADF));
EXPECT_THAT(connect(-1, reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EBADF));
EXPECT_THAT(
sendto(-1, buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EBADF));
sockaddr* bad_addr = reinterpret_cast<sockaddr*>(1);
EXPECT_THAT(bind(fd.get(), bad_addr, sizeof(addr_ipv6)), SyscallFailsWithErrno(EFAULT));
EXPECT_THAT(connect(fd.get(), bad_addr, sizeof(addr_ipv6)), SyscallFailsWithErrno(EFAULT));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, bad_addr, sizeof(addr_ipv6)),
SyscallFailsWithErrno(EFAULT));
// With AF_INET6 address (28 bytes >= 16)
EXPECT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_ipv6),
sizeof(addr_ipv6)),
SyscallFailsWithErrno(EAFNOSUPPORT));
// With AF_UNIX address of various lengths
// Long (>= 16):
EXPECT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_long_len),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_long_len),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_unix),
addr_unix_long_len),
SyscallFailsWithErrno(EAFNOSUPPORT));
// Short (< sizeof(sockaddr_in) == 16):
EXPECT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_short_len),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_short_len),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_unix),
addr_unix_short_len),
SyscallFailsWithErrno(EINVAL));
}
// 2. AF_INET6 SOCK_DGRAM
{
fbl::unique_fd fd(socket(AF_INET6, SOCK_DGRAM, 0));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
// With AF_INET address (16 bytes < SIN6_LEN_RFC2133 (24))
EXPECT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_ipv4), sizeof(addr_ipv4)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_ipv4),
sizeof(addr_ipv4)),
SyscallFailsWithErrno(EINVAL));
// With AF_UNIX long (29 bytes >= 24)
EXPECT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_long_len),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_long_len),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_unix),
addr_unix_long_len),
SyscallFailsWithErrno(EINVAL));
// With AF_UNIX med (22 bytes < 24)
EXPECT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_med_len),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_med_len),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_unix),
addr_unix_med_len),
SyscallFailsWithErrno(EINVAL));
}
// 2b. AF_INET and AF_INET6 SOCK_STREAM
{
fbl::unique_fd fd4(socket(AF_INET, SOCK_STREAM, 0));
ASSERT_TRUE(fd4.is_valid()) << strerror(errno);
EXPECT_THAT(connect(fd4.get(), reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(connect(fd4.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_long_len),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(connect(fd4.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_short_len),
SyscallFailsWithErrno(EINVAL));
fbl::unique_fd fd6(socket(AF_INET6, SOCK_STREAM, 0));
ASSERT_TRUE(fd6.is_valid()) << strerror(errno);
EXPECT_THAT(connect(fd6.get(), reinterpret_cast<sockaddr*>(&addr_ipv4), sizeof(addr_ipv4)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(connect(fd6.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_long_len),
SyscallFailsWithErrno(EAFNOSUPPORT));
EXPECT_THAT(connect(fd6.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_med_len),
SyscallFailsWithErrno(EINVAL));
}
// 3. AF_UNIX SOCK_DGRAM
{
fbl::unique_fd fd(socket(AF_UNIX, SOCK_DGRAM, 0));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
EXPECT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_ipv4), sizeof(addr_ipv4)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&addr_ipv4), sizeof(addr_ipv4)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_ipv4),
sizeof(addr_ipv4)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_ipv6),
sizeof(addr_ipv6)),
SyscallFailsWithErrno(EINVAL));
// Bind, connect, and sendto on AF_UNIX SOCK_DGRAM with explicit and null destination addresses.
ASSERT_THAT(bind(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_long_len),
SyscallSucceeds());
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_unix),
addr_unix_long_len),
SyscallSucceedsWithValue(sizeof(buf)));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, nullptr, 0), SyscallFailsWithErrno(ENOTCONN));
ASSERT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&addr_unix), addr_unix_long_len),
SyscallSucceeds());
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_unix),
addr_unix_long_len),
SyscallSucceedsWithValue(sizeof(buf)));
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, nullptr, 0),
SyscallSucceedsWithValue(sizeof(buf)));
// Empty AF_UNIX address (addrlen == sizeof(sa_family_t)) on sendto fails with EINVAL.
sockaddr_un addr_unix_empty = {};
addr_unix_empty.sun_family = AF_UNIX;
EXPECT_THAT(sendto(fd.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_unix_empty),
sizeof(sa_family_t)),
SyscallFailsWithErrno(EINVAL));
// Connected AF_UNIX SOCK_STREAM still rejects sendto with a destination address with EISCONN.
int stream_fds[2] = {-1, -1};
ASSERT_THAT(socketpair(AF_UNIX, SOCK_STREAM, 0, stream_fds), SyscallSucceeds());
fbl::unique_fd s0(stream_fds[0]);
fbl::unique_fd s1(stream_fds[1]);
EXPECT_THAT(sendto(s0.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_unix),
addr_unix_long_len),
SyscallFailsWithErrno(EISCONN));
// Unconnected AF_UNIX SOCK_STREAM rejects cross-family bind and connect with EINVAL,
// and sendto with a destination address with EOPNOTSUPP.
fbl::unique_fd ustream(socket(AF_UNIX, SOCK_STREAM, 0));
ASSERT_TRUE(ustream.is_valid()) << strerror(errno);
EXPECT_THAT(bind(ustream.get(), reinterpret_cast<sockaddr*>(&addr_ipv4), sizeof(addr_ipv4)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(connect(ustream.get(), reinterpret_cast<sockaddr*>(&addr_ipv4), sizeof(addr_ipv4)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(bind(ustream.get(), reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(connect(ustream.get(), reinterpret_cast<sockaddr*>(&addr_ipv6), sizeof(addr_ipv6)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(sendto(ustream.get(), buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&addr_ipv4),
sizeof(addr_ipv4)),
SyscallFailsWithErrno(EOPNOTSUPP));
}
}
TEST(UnixSocket, SendmsgCmsgLenExceedsControllenAtGuardPage) {
int fds[2] = {-1, -1};
ASSERT_THAT(socketpair(AF_UNIX, SOCK_DGRAM, 0, fds), SyscallSucceeds());
fbl::unique_fd sender(fds[0]);
fbl::unique_fd receiver(fds[1]);
const size_t page_size = static_cast<size_t>(sysconf(_SC_PAGESIZE));
void* mapping =
mmap(nullptr, 2 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(mapping, MAP_FAILED) << strerror(errno);
auto unmap = fit::defer([mapping, page_size] { munmap(mapping, 2 * page_size); });
auto* bytes = static_cast<uint8_t*>(mapping);
ASSERT_THAT(mprotect(bytes + page_size, page_size, PROT_NONE), SyscallSucceeds());
// Place cmsghdr flush against the PROT_NONE guard page with cmsg_len extending past
// msg_controllen into the unmapped page. The kernel must reject cmsg_len > msg_controllen with
// EINVAL rather than reading past msg_controllen and faulting with EFAULT.
auto* cmsg = reinterpret_cast<cmsghdr*>(bytes + page_size - sizeof(cmsghdr));
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = sizeof(cmsghdr) + page_size;
char payload = 'x';
iovec iov = {
.iov_base = &payload,
.iov_len = sizeof(payload),
};
msghdr msg = {};
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cmsg;
msg.msg_controllen = sizeof(cmsghdr);
EXPECT_THAT(sendmsg(sender.get(), &msg, 0), SyscallFailsWithErrno(EINVAL));
cmsg->cmsg_len = std::numeric_limits<decltype(cmsg->cmsg_len)>::max();
EXPECT_THAT(sendmsg(sender.get(), &msg, 0), SyscallFailsWithErrno(EINVAL));
}
TEST(SocketTest, ExtremeSndbufAndRcvbufValuesDoNotOverflow) {
auto check_socket = [](fbl::unique_fd fd) {
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
const int extreme_values[] = {
-1,
std::numeric_limits<int>::min(),
std::numeric_limits<int>::max(),
0x40000000,
};
for (int opt : {SO_SNDBUF, SO_RCVBUF}) {
for (int val : extreme_values) {
EXPECT_THAT(setsockopt(fd.get(), SOL_SOCKET, opt, &val, sizeof(val)), SyscallSucceeds())
<< "opt=" << opt << " val=" << val;
int actual = 0;
socklen_t actual_len = sizeof(actual);
ASSERT_THAT(getsockopt(fd.get(), SOL_SOCKET, opt, &actual, &actual_len), SyscallSucceeds());
EXPECT_GT(actual, 0);
}
}
};
int unix_pair[2] = {-1, -1};
ASSERT_THAT(socketpair(AF_UNIX, SOCK_STREAM, 0, unix_pair), SyscallSucceeds());
fbl::unique_fd unix_peer(unix_pair[1]);
check_socket(fbl::unique_fd(unix_pair[0]));
check_socket(fbl::unique_fd(socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)));
}
} // namespace