TEST(DEATHTEST, snprintf_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
strcpy(myfoo.a, "012345678");
size_t n = strlen(myfoo.a) + 2;
ASSERT_EXIT(snprintf(myfoo.b, n, "a%s", myfoo.a), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, strncpy2_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char dest[11];
char src[10];
memcpy(src, "0123456789", sizeof(src)); // src is not null terminated
ASSERT_EXIT(strncpy(dest, src, sizeof(dest)), testing::KilledBySignal(SIGABRT), "");
}
// This test is disabled in clang because clang doesn't properly detect
// this buffer overflow. TODO: Fix clang.
TEST(DEATHTEST, strncpy_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
int copy_amt = atoi("11");
ASSERT_EXIT(strncpy(myfoo.a, "01234567890", copy_amt),
testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, strncat_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char buf[10];
size_t n = atoi("10"); // avoid compiler optimizations
strncpy(buf, "012345678", n);
ASSERT_EXIT(strncat(buf, "9", n), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, bzero_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
memcpy(myfoo.b, "0123456789", sizeof(myfoo.b));
size_t n = atoi("11");
ASSERT_EXIT(bzero(myfoo.b, n), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, sprintf_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char buf[10];
char source_buf[15];
memcpy(source_buf, "12345678901234", 15);
ASSERT_EXIT(sprintf(buf, "%s", source_buf), testing::KilledBySignal(SIGABRT), "");
}
// multibyte target where we over fill (should fail)
TEST(DEATHTEST, strcpy_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char buf[10];
char *orig = strdup("0123456789");
ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), "");
free(orig);
}
// one byte target with longer source (should fail)
TEST(Fortify1_DeathTest, strcpy4_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char buf[1];
char *orig = strdup("12");
ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), "");
free(orig);
}
TEST(Fortify1_DeathTest, strncat2_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char buf[10];
buf[0] = '\0';
size_t n = atoi("10"); // avoid compiler optimizations
ASSERT_EXIT(strncat(buf, "0123456789", n), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, bzero_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char buf[10];
memcpy(buf, "0123456789", sizeof(buf));
size_t n = atoi("11");
ASSERT_EXIT(bzero(buf, n), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, memmove_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char buf[20];
strcpy(buf, "0123456789");
size_t n = atoi("10");
ASSERT_EXIT(memmove(buf + 11, buf, n), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, strcat2_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
memcpy(myfoo.a, "0123456789", sizeof(myfoo.a)); // unterminated string
myfoo.b[0] = '\0';
ASSERT_EXIT(strcat(myfoo.b, myfoo.a), testing::KilledBySignal(SIGABRT), "");
}
// This test is disabled in clang because clang doesn't properly detect
// this buffer overflow. TODO: Fix clang.
TEST(DEATHTEST, strncat2_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
myfoo.a[0] = '\0';
size_t n = atoi("10"); // avoid compiler optimizations
ASSERT_EXIT(strncat(myfoo.a, "0123456789", n), testing::KilledBySignal(SIGABRT), "");
}
// This test is disabled in clang because clang doesn't properly detect
// this buffer overflow. TODO: Fix clang.
TEST(DEATHTEST, strlcpy_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
strcpy(myfoo.a, "01");
size_t n = strlen(myfoo.a);
ASSERT_EXIT(strlcpy(myfoo.one, myfoo.a, n),
testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, read_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char buf[1];
size_t ct = atoi("2"); // prevent optimizations
int fd = open("/dev/null", O_RDONLY);
ASSERT_EXIT(read(fd, buf, ct), testing::KilledBySignal(SIGABRT), "");
close(fd);
}
// This test is disabled in clang because clang doesn't properly detect
// this buffer overflow. TODO: Fix clang.
TEST(DEATHTEST, strrchr_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
memcpy(myfoo.a, "0123456789", 10);
memcpy(myfoo.b, "01234", 6);
ASSERT_EXIT(printf("%s", strrchr(myfoo.a, 'a')),
testing::KilledBySignal(SIGABRT), "");
}
// one byte target with longer source (should fail)
// This test is disabled in clang because clang doesn't properly detect
// this buffer overflow. TODO: Fix clang.
TEST(DEATHTEST, strcpy3_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
char* src = strdup("12");
ASSERT_EXIT(strcpy(myfoo.one, src),
testing::KilledBySignal(SIGABRT), "");
free(src);
}
// This test is disabled in clang because clang doesn't properly detect
// this buffer overflow. TODO: Fix clang.
TEST(DEATHTEST, strncpy2_fortified2) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
foo myfoo;
memset(&myfoo, 0, sizeof(myfoo));
myfoo.one[0] = 'A'; // not null terminated string
ASSERT_EXIT(strncpy(myfoo.b, myfoo.one, sizeof(myfoo.b)),
testing::KilledBySignal(SIGABRT), "");
}
// This test is disabled in clang because clang doesn't properly detect
// this buffer overflow. TODO: Fix clang.
TEST(DEATHTEST, sprintf_malloc_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char* buf = (char *) malloc(10);
char source_buf[11];
memcpy(source_buf, "1234567890", 11);
ASSERT_EXIT(sprintf(buf, "%s", source_buf), testing::KilledBySignal(SIGABRT), "");
free(buf);
}
TEST(DEATHTEST, snprintf_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char bufa[15];
char bufb[10];
strcpy(bufa, "0123456789");
size_t n = strlen(bufa) + 1;
ASSERT_EXIT(snprintf(bufb, n, "%s", bufa), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, strncpy_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char bufa[15];
char bufb[10];
strcpy(bufa, "01234567890123");
size_t n = strlen(bufa);
ASSERT_EXIT(strncpy(bufb, bufa, n), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, memcpy_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char bufa[10];
char bufb[10];
strcpy(bufa, "012345678");
size_t n = atoi("11");
ASSERT_EXIT(memcpy(bufb, bufa, n), testing::KilledBySignal(SIGABRT), "");
}
TEST(DEATHTEST, strcat_fortified) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
char src[11];
strcpy(src, "0123456789");
char buf[10];
buf[0] = '\0';
ASSERT_EXIT(strcat(buf, src), testing::KilledBySignal(SIGABRT), "");
}
void GetExecutablePathQuoted(wchar_t* outpath, int outpath_length)
{
wchar_t* temppath = new wchar_t[outpath_length];
GetExecutablePath(temppath, outpath_length);
int result = swprintf_s(outpath, outpath_length, L"\"%s\"", temppath);
ASSERT_EXIT((-1 != result), "swprintf_s(outpath)");
delete[] temppath;
temppath = 0;
}
void GetExecutablePath(wchar_t* outpath, int outpath_length)
{
// This path is longer than MAX_PATH, do not use it with
// windows api functions as you might get buffer overflows.
wchar_t shortpath[1024];
wchar_t longpath[1024];
DWORD dw;
dw = GetModuleFileName(NULL, shortpath, 1024);
ASSERT_EXIT(dw, "GetModuleFileName()");
dw = GetLongPathName(shortpath, longpath, 1024);
ASSERT_EXIT(dw, "GetLongPathName()");
swprintf_s(outpath, outpath_length, L"%s", longpath);
}
TEST(ExampleTests, test_no_death){
auto a = [] () {
int a = 0;
a = 7;
int b = a;
a = b;
exit(0);
};
ASSERT_EXIT(a(), ::testing::ExitedWithCode(0), "");
}
TEST_F(properties_DeathTest, read_only) {
#if defined(__BIONIC__)
// This test only makes sense if we're talking to the real system property service.
struct stat sb;
if (stat(PROP_FILENAME, &sb) == -1 && errno == ENOENT) {
return;
}
ASSERT_EXIT(__system_property_add("property", 8, "value", 5), KilledByFault(), "");
#else // __BIONIC__
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif // __BIONIC__
}
void GetExecutableName(wchar_t* outdir, int outdir_length)
{
// Filename without extension.
wchar_t longpath[1024];
GetExecutablePath(longpath, _countof(longpath));
wchar_t drive[3];
wchar_t dir[768];
wchar_t fname[256];
wchar_t ext[32];
errno_t result = _wsplitpath_s(longpath, drive, _countof(drive), dir, _countof(dir), fname, _countof(fname), ext, _countof(ext));
ASSERT_EXIT((result == 0), "_wsplitpath_s(longpath)");
swprintf_s(outdir, outdir_length, L"%s", fname);
}
static int test_policy_priv_by_id(const char *bus,
struct kdbus_conn *conn_dst,
bool drop_second_user,
int parent_status,
int child_status)
{
int ret = 0;
uint64_t expected_cookie = time(NULL) ^ 0xdeadbeef;
ASSERT_RETURN(conn_dst);
ret = RUN_UNPRIVILEGED_CONN(unpriv, bus, ({
ret = kdbus_msg_send(unpriv, NULL,
expected_cookie, 0, 0, 0,
conn_dst->id);
ASSERT_EXIT(ret == child_status);
}));
static int no_cancel_sync(struct kdbus_conn *conn_src,
struct kdbus_conn *conn_dst)
{
pid_t pid;
int cancel_fd;
int ret, status;
struct kdbus_msg *msg = NULL;
/* pass eventfd, but never signal it so it shouldn't have any effect */
cancel_fd = eventfd(0, 0);
ASSERT_RETURN_VAL(cancel_fd >= 0, cancel_fd);
cookie++;
pid = fork();
ASSERT_RETURN_VAL(pid >= 0, pid);
if (pid == 0) {
ret = kdbus_msg_send_sync(conn_dst, NULL, cookie,
KDBUS_MSG_EXPECT_REPLY,
100000000ULL, 0, conn_src->id,
cancel_fd);
ASSERT_EXIT(ret == 0);
_exit(EXIT_SUCCESS);
}
ret = kdbus_msg_recv_poll(conn_src, 100, &msg, NULL);
ASSERT_RETURN_VAL(ret == 0 && msg->cookie == cookie, -1);
kdbus_msg_free(msg);
ret = kdbus_msg_send_reply(conn_src, cookie, conn_dst->id);
ASSERT_RETURN_VAL(ret >= 0, ret);
ret = waitpid(pid, &status, 0);
ASSERT_RETURN_VAL(ret >= 0, ret);
if (WIFSIGNALED(status))
return -1;
return (status == EXIT_SUCCESS) ? 0 : -1;
}
