fortify_test.cpp revision 92d8b2320a4c3911452227f560ae4a39e83b0abf
1/* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <gtest/gtest.h> 18#include <signal.h> 19#include <string.h> 20#include <stdarg.h> 21#include <sys/types.h> 22#include <sys/stat.h> 23#include <sys/socket.h> 24#include <malloc.h> 25#include <fcntl.h> 26#include <sys/prctl.h> 27 28// We have to say "DeathTest" here so gtest knows to run this test (which exits) 29// in its own process. Unfortunately, the C preprocessor doesn't give us an 30// easy way to concatenate strings, so we need to use the complicated method 31// below. *sigh* 32#define DEATHTEST_PASTER(name) name##_DeathTest 33#define DEATHTEST_EVALUATOR(name) DEATHTEST_PASTER(name) 34#define DEATHTEST DEATHTEST_EVALUATOR(TEST_NAME) 35 36class DEATHTEST : public testing::Test { 37 protected: 38 virtual void SetUp() { 39 old_dumpable_ = prctl(PR_GET_DUMPABLE, 0, 0, 0, 0); 40 // Suppress debuggerd stack traces. Too slow. 41 prctl(PR_SET_DUMPABLE, 0, 0, 0, 0); 42 } 43 44 virtual void TearDown() { 45 prctl(PR_SET_DUMPABLE, old_dumpable_, 0, 0, 0, 0); 46 } 47 private: 48 int old_dumpable_; 49}; 50 51#if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE == 2 52struct foo { 53 char empty[0]; 54 char one[1]; 55 char a[10]; 56 char b[10]; 57}; 58 59#ifndef __clang__ 60// This test is disabled in clang because clang doesn't properly detect 61// this buffer overflow. TODO: Fix clang. 62TEST_F(DEATHTEST, stpncpy_fortified2) { 63 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 64 foo myfoo; 65 int copy_amt = atoi("11"); 66 ASSERT_EXIT(stpncpy(myfoo.a, "01234567890", copy_amt), 67 testing::KilledBySignal(SIGABRT), ""); 68} 69#endif 70 71#ifndef __clang__ 72// This test is disabled in clang because clang doesn't properly detect 73// this buffer overflow. TODO: Fix clang. 74TEST_F(DEATHTEST, stpncpy2_fortified2) { 75 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 76 foo myfoo; 77 memset(&myfoo, 0, sizeof(myfoo)); 78 myfoo.one[0] = 'A'; // not null terminated string 79 ASSERT_EXIT(stpncpy(myfoo.b, myfoo.one, sizeof(myfoo.b)), 80 testing::KilledBySignal(SIGABRT), ""); 81} 82#endif 83 84#ifndef __clang__ 85// This test is disabled in clang because clang doesn't properly detect 86// this buffer overflow. TODO: Fix clang. 87TEST_F(DEATHTEST, strncpy_fortified2) { 88 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 89 foo myfoo; 90 int copy_amt = atoi("11"); 91 ASSERT_EXIT(strncpy(myfoo.a, "01234567890", copy_amt), 92 testing::KilledBySignal(SIGABRT), ""); 93} 94#endif 95 96#ifndef __clang__ 97// This test is disabled in clang because clang doesn't properly detect 98// this buffer overflow. TODO: Fix clang. 99TEST_F(DEATHTEST, strncpy2_fortified2) { 100 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 101 foo myfoo; 102 memset(&myfoo, 0, sizeof(myfoo)); 103 myfoo.one[0] = 'A'; // not null terminated string 104 ASSERT_EXIT(strncpy(myfoo.b, myfoo.one, sizeof(myfoo.b)), 105 testing::KilledBySignal(SIGABRT), ""); 106} 107#endif 108 109#ifndef __clang__ 110// This test is disabled in clang because clang doesn't properly detect 111// this buffer overflow. TODO: Fix clang. 112TEST_F(DEATHTEST, sprintf_fortified2) { 113 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 114 foo myfoo; 115 char source_buf[15]; 116 memcpy(source_buf, "12345678901234", 15); 117 ASSERT_EXIT(sprintf(myfoo.a, "%s", source_buf), 118 testing::KilledBySignal(SIGABRT), ""); 119} 120#endif 121 122#ifndef __clang__ 123// This test is disabled in clang because clang doesn't properly detect 124// this buffer overflow. TODO: Fix clang. 125TEST_F(DEATHTEST, sprintf2_fortified2) { 126 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 127 foo myfoo; 128 ASSERT_EXIT(sprintf(myfoo.a, "0123456789"), 129 testing::KilledBySignal(SIGABRT), ""); 130} 131#endif 132 133#ifndef __clang__ 134// These tests are disabled in clang because clang doesn't properly detect 135// this buffer overflow. TODO: Fix clang. 136static int vsprintf_helper2(const char *fmt, ...) { 137 foo myfoo; 138 va_list va; 139 int result; 140 141 va_start(va, fmt); 142 result = vsprintf(myfoo.a, fmt, va); // should crash here 143 va_end(va); 144 return result; 145} 146 147TEST_F(DEATHTEST, vsprintf_fortified2) { 148 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 149 ASSERT_EXIT(vsprintf_helper2("%s", "0123456789"), testing::KilledBySignal(SIGABRT), ""); 150} 151 152TEST_F(DEATHTEST, vsprintf2_fortified2) { 153 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 154 ASSERT_EXIT(vsprintf_helper2("0123456789"), testing::KilledBySignal(SIGABRT), ""); 155} 156#endif 157 158#ifndef __clang__ 159// These tests are disabled in clang because clang doesn't properly detect 160// this buffer overflow. TODO: Fix clang. 161static int vsnprintf_helper2(const char *fmt, ...) { 162 foo myfoo; 163 va_list va; 164 int result; 165 size_t size = atoi("11"); 166 167 va_start(va, fmt); 168 result = vsnprintf(myfoo.a, size, fmt, va); // should crash here 169 va_end(va); 170 return result; 171} 172 173TEST_F(DEATHTEST, vsnprintf_fortified2) { 174 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 175 ASSERT_EXIT(vsnprintf_helper2("%s", "0123456789"), testing::KilledBySignal(SIGABRT), ""); 176} 177 178TEST_F(DEATHTEST, vsnprintf2_fortified2) { 179 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 180 ASSERT_EXIT(vsnprintf_helper2("0123456789"), testing::KilledBySignal(SIGABRT), ""); 181} 182#endif 183 184#ifndef __clang__ 185// zero sized target with "\0" source (should fail) 186// This test is disabled in clang because clang doesn't properly detect 187// this buffer overflow. TODO: Fix clang. 188TEST_F(DEATHTEST, stpcpy_fortified2) { 189#if defined(__BIONIC__) 190 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 191 foo myfoo; 192 char* src = strdup(""); 193 ASSERT_EXIT(stpcpy(myfoo.empty, src), 194 testing::KilledBySignal(SIGABRT), ""); 195 free(src); 196#else // __BIONIC__ 197 GTEST_LOG_(INFO) << "This test does nothing.\n"; 198#endif // __BIONIC__ 199} 200#endif 201 202#ifndef __clang__ 203// zero sized target with "\0" source (should fail) 204// This test is disabled in clang because clang doesn't properly detect 205// this buffer overflow. TODO: Fix clang. 206TEST_F(DEATHTEST, strcpy_fortified2) { 207#if defined(__BIONIC__) 208 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 209 foo myfoo; 210 char* src = strdup(""); 211 ASSERT_EXIT(strcpy(myfoo.empty, src), 212 testing::KilledBySignal(SIGABRT), ""); 213 free(src); 214#else // __BIONIC__ 215 GTEST_LOG_(INFO) << "This test does nothing.\n"; 216#endif // __BIONIC__ 217} 218#endif 219 220#ifndef __clang__ 221// zero sized target with longer source (should fail) 222// This test is disabled in clang because clang doesn't properly detect 223// this buffer overflow. TODO: Fix clang. 224TEST_F(DEATHTEST, strcpy2_fortified2) { 225#if defined(__BIONIC__) 226 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 227 foo myfoo; 228 char* src = strdup("1"); 229 ASSERT_EXIT(strcpy(myfoo.empty, src), 230 testing::KilledBySignal(SIGABRT), ""); 231 free(src); 232#else // __BIONIC__ 233 GTEST_LOG_(INFO) << "This test does nothing.\n"; 234#endif // __BIONIC__ 235} 236#endif 237 238#ifndef __clang__ 239// one byte target with longer source (should fail) 240// This test is disabled in clang because clang doesn't properly detect 241// this buffer overflow. TODO: Fix clang. 242TEST_F(DEATHTEST, strcpy3_fortified2) { 243#if defined(__BIONIC__) 244 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 245 foo myfoo; 246 char* src = strdup("12"); 247 ASSERT_EXIT(strcpy(myfoo.one, src), 248 testing::KilledBySignal(SIGABRT), ""); 249 free(src); 250#else // __BIONIC__ 251 GTEST_LOG_(INFO) << "This test does nothing.\n"; 252#endif // __BIONIC__ 253} 254#endif 255 256#ifndef __clang__ 257// This test is disabled in clang because clang doesn't properly detect 258// this buffer overflow. TODO: Fix clang. 259TEST_F(DEATHTEST, strchr_fortified2) { 260#if defined(__BIONIC__) 261 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 262 foo myfoo; 263 memcpy(myfoo.a, "0123456789", sizeof(myfoo.a)); 264 myfoo.b[0] = '\0'; 265 ASSERT_EXIT(printf("%s", strchr(myfoo.a, 'a')), 266 testing::KilledBySignal(SIGABRT), ""); 267#else // __BIONIC__ 268 GTEST_LOG_(INFO) << "This test does nothing.\n"; 269#endif // __BIONIC__ 270} 271#endif 272 273#ifndef __clang__ 274// This test is disabled in clang because clang doesn't properly detect 275// this buffer overflow. TODO: Fix clang. 276TEST_F(DEATHTEST, strrchr_fortified2) { 277#if defined(__BIONIC__) 278 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 279 foo myfoo; 280 memcpy(myfoo.a, "0123456789", 10); 281 memcpy(myfoo.b, "01234", 6); 282 ASSERT_EXIT(printf("%s", strrchr(myfoo.a, 'a')), 283 testing::KilledBySignal(SIGABRT), ""); 284#else // __BIONIC__ 285 GTEST_LOG_(INFO) << "This test does nothing.\n"; 286#endif // __BIONIC__ 287} 288#endif 289 290#ifndef __clang__ 291// This test is disabled in clang because clang doesn't properly detect 292// this buffer overflow. TODO: Fix clang. 293TEST_F(DEATHTEST, strlcpy_fortified2) { 294#if defined(__BIONIC__) 295 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 296 foo myfoo; 297 strcpy(myfoo.a, "01"); 298 size_t n = strlen(myfoo.a); 299 ASSERT_EXIT(strlcpy(myfoo.one, myfoo.a, n), 300 testing::KilledBySignal(SIGABRT), ""); 301#else // __BIONIC__ 302 GTEST_LOG_(INFO) << "This test does nothing.\n"; 303#endif // __BIONIC__ 304} 305#endif 306 307#ifndef __clang__ 308// This test is disabled in clang because clang doesn't properly detect 309// this buffer overflow. TODO: Fix clang. 310TEST_F(DEATHTEST, strlcat_fortified2) { 311#if defined(__BIONIC__) 312 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 313 foo myfoo; 314 strcpy(myfoo.a, "01"); 315 myfoo.one[0] = '\0'; 316 size_t n = strlen(myfoo.a); 317 ASSERT_EXIT(strlcat(myfoo.one, myfoo.a, n), 318 testing::KilledBySignal(SIGABRT), ""); 319#else // __BIONIC__ 320 GTEST_LOG_(INFO) << "This test does nothing.\n"; 321#endif // __BIONIC__ 322} 323#endif 324 325#ifndef __clang__ 326// This test is disabled in clang because clang doesn't properly detect 327// this buffer overflow. TODO: Fix clang. 328TEST_F(DEATHTEST, strncat_fortified2) { 329 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 330 foo myfoo; 331 size_t n = atoi("10"); // avoid compiler optimizations 332 strncpy(myfoo.a, "012345678", n); 333 ASSERT_EXIT(strncat(myfoo.a, "9", n), testing::KilledBySignal(SIGABRT), ""); 334} 335#endif 336 337#ifndef __clang__ 338// This test is disabled in clang because clang doesn't properly detect 339// this buffer overflow. TODO: Fix clang. 340TEST_F(DEATHTEST, strncat2_fortified2) { 341 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 342 foo myfoo; 343 myfoo.a[0] = '\0'; 344 size_t n = atoi("10"); // avoid compiler optimizations 345 ASSERT_EXIT(strncat(myfoo.a, "0123456789", n), testing::KilledBySignal(SIGABRT), ""); 346} 347#endif 348 349TEST_F(DEATHTEST, strncat3_fortified2) { 350 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 351 foo myfoo; 352 memcpy(myfoo.a, "0123456789", sizeof(myfoo.a)); // unterminated string 353 myfoo.b[0] = '\0'; 354 size_t n = atoi("10"); // avoid compiler optimizations 355 ASSERT_EXIT(strncat(myfoo.b, myfoo.a, n), testing::KilledBySignal(SIGABRT), ""); 356} 357 358#ifndef __clang__ 359// This test is disabled in clang because clang doesn't properly detect 360// this buffer overflow. TODO: Fix clang. 361TEST_F(DEATHTEST, strcat_fortified2) { 362 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 363 char src[11]; 364 strcpy(src, "0123456789"); 365 foo myfoo; 366 myfoo.a[0] = '\0'; 367 ASSERT_EXIT(strcat(myfoo.a, src), testing::KilledBySignal(SIGABRT), ""); 368} 369#endif 370 371TEST_F(DEATHTEST, strcat2_fortified2) { 372 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 373 foo myfoo; 374 memcpy(myfoo.a, "0123456789", sizeof(myfoo.a)); // unterminated string 375 myfoo.b[0] = '\0'; 376 ASSERT_EXIT(strcat(myfoo.b, myfoo.a), testing::KilledBySignal(SIGABRT), ""); 377} 378 379TEST_F(DEATHTEST, snprintf_fortified2) { 380 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 381 foo myfoo; 382 strcpy(myfoo.a, "012345678"); 383 size_t n = strlen(myfoo.a) + 2; 384 ASSERT_EXIT(snprintf(myfoo.b, n, "a%s", myfoo.a), testing::KilledBySignal(SIGABRT), ""); 385} 386 387TEST_F(DEATHTEST, bzero_fortified2) { 388 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 389 foo myfoo; 390 memcpy(myfoo.b, "0123456789", sizeof(myfoo.b)); 391 size_t n = atoi("11"); 392 ASSERT_EXIT(bzero(myfoo.b, n), testing::KilledBySignal(SIGABRT), ""); 393} 394 395#endif /* defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE=2 */ 396 397// multibyte target where we over fill (should fail) 398TEST_F(DEATHTEST, strcpy_fortified) { 399#if defined(__BIONIC__) 400 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 401 char buf[10]; 402 char *orig = strdup("0123456789"); 403 ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), ""); 404 free(orig); 405#else // __BIONIC__ 406 GTEST_LOG_(INFO) << "This test does nothing.\n"; 407#endif // __BIONIC__ 408} 409 410// zero sized target with "\0" source (should fail) 411TEST_F(DEATHTEST, strcpy2_fortified) { 412#if defined(__BIONIC__) 413 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 414 char buf[0]; 415 char *orig = strdup(""); 416 ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), ""); 417 free(orig); 418#else // __BIONIC__ 419 GTEST_LOG_(INFO) << "This test does nothing.\n"; 420#endif // __BIONIC__ 421} 422 423// zero sized target with longer source (should fail) 424TEST_F(DEATHTEST, strcpy3_fortified) { 425#if defined(__BIONIC__) 426 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 427 char buf[0]; 428 char *orig = strdup("1"); 429 ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), ""); 430 free(orig); 431#else // __BIONIC__ 432 GTEST_LOG_(INFO) << "This test does nothing.\n"; 433#endif // __BIONIC__ 434} 435 436// one byte target with longer source (should fail) 437TEST_F(DEATHTEST, strcpy4_fortified) { 438#if defined(__BIONIC__) 439 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 440 char buf[1]; 441 char *orig = strdup("12"); 442 ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), ""); 443 free(orig); 444#else // __BIONIC__ 445 GTEST_LOG_(INFO) << "This test does nothing.\n"; 446#endif // __BIONIC__ 447} 448 449TEST_F(DEATHTEST, strlen_fortified) { 450#if defined(__BIONIC__) 451 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 452 char buf[10]; 453 memcpy(buf, "0123456789", sizeof(buf)); 454 ASSERT_EXIT(printf("%zd", strlen(buf)), testing::KilledBySignal(SIGABRT), ""); 455#else // __BIONIC__ 456 GTEST_LOG_(INFO) << "This test does nothing.\n"; 457#endif // __BIONIC__ 458} 459 460TEST_F(DEATHTEST, strchr_fortified) { 461#if defined(__BIONIC__) 462 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 463 char buf[10]; 464 memcpy(buf, "0123456789", sizeof(buf)); 465 ASSERT_EXIT(printf("%s", strchr(buf, 'a')), testing::KilledBySignal(SIGABRT), ""); 466#else // __BIONIC__ 467 GTEST_LOG_(INFO) << "This test does nothing.\n"; 468#endif // __BIONIC__ 469} 470 471TEST_F(DEATHTEST, strrchr_fortified) { 472#if defined(__BIONIC__) 473 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 474 char buf[10]; 475 memcpy(buf, "0123456789", sizeof(buf)); 476 ASSERT_EXIT(printf("%s", strrchr(buf, 'a')), testing::KilledBySignal(SIGABRT), ""); 477#else // __BIONIC__ 478 GTEST_LOG_(INFO) << "This test does nothing.\n"; 479#endif // __BIONIC__ 480} 481 482TEST_F(DEATHTEST, strlcpy_fortified) { 483#if defined(__BIONIC__) 484 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 485 char bufa[15]; 486 char bufb[10]; 487 strcpy(bufa, "01234567890123"); 488 size_t n = strlen(bufa); 489 ASSERT_EXIT(strlcpy(bufb, bufa, n), testing::KilledBySignal(SIGABRT), ""); 490#else // __BIONIC__ 491 GTEST_LOG_(INFO) << "This test does nothing.\n"; 492#endif // __BIONIC__ 493} 494 495TEST_F(DEATHTEST, strlcat_fortified) { 496#if defined(__BIONIC__) 497 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 498 char bufa[15]; 499 char bufb[10]; 500 bufb[0] = '\0'; 501 strcpy(bufa, "01234567890123"); 502 size_t n = strlen(bufa); 503 ASSERT_EXIT(strlcat(bufb, bufa, n), testing::KilledBySignal(SIGABRT), ""); 504#else // __BIONIC__ 505 GTEST_LOG_(INFO) << "This test does nothing.\n"; 506#endif // __BIONIC__ 507} 508 509TEST_F(DEATHTEST, sprintf_fortified) { 510 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 511 char buf[10]; 512 char source_buf[15]; 513 memcpy(source_buf, "12345678901234", 15); 514 ASSERT_EXIT(sprintf(buf, "%s", source_buf), testing::KilledBySignal(SIGABRT), ""); 515} 516 517#ifndef __clang__ 518// This test is disabled in clang because clang doesn't properly detect 519// this buffer overflow. TODO: Fix clang. 520TEST_F(DEATHTEST, sprintf_malloc_fortified) { 521 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 522 char* buf = (char *) malloc(10); 523 char source_buf[11]; 524 memcpy(source_buf, "1234567890", 11); 525 ASSERT_EXIT(sprintf(buf, "%s", source_buf), testing::KilledBySignal(SIGABRT), ""); 526 free(buf); 527} 528#endif 529 530TEST_F(DEATHTEST, sprintf2_fortified) { 531 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 532 char buf[5]; 533 ASSERT_EXIT(sprintf(buf, "aaaaa"), testing::KilledBySignal(SIGABRT), ""); 534} 535 536static int vsprintf_helper(const char *fmt, ...) { 537 char buf[10]; 538 va_list va; 539 int result; 540 541 va_start(va, fmt); 542 result = vsprintf(buf, fmt, va); // should crash here 543 va_end(va); 544 return result; 545} 546 547TEST_F(DEATHTEST, vsprintf_fortified) { 548 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 549 ASSERT_EXIT(vsprintf_helper("%s", "0123456789"), testing::KilledBySignal(SIGABRT), ""); 550} 551 552TEST_F(DEATHTEST, vsprintf2_fortified) { 553 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 554 ASSERT_EXIT(vsprintf_helper("0123456789"), testing::KilledBySignal(SIGABRT), ""); 555} 556 557static int vsnprintf_helper(const char *fmt, ...) { 558 char buf[10]; 559 va_list va; 560 int result; 561 size_t size = atoi("11"); 562 563 va_start(va, fmt); 564 result = vsnprintf(buf, size, fmt, va); // should crash here 565 va_end(va); 566 return result; 567} 568 569TEST_F(DEATHTEST, vsnprintf_fortified) { 570 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 571 ASSERT_EXIT(vsnprintf_helper("%s", "0123456789"), testing::KilledBySignal(SIGABRT), ""); 572} 573 574TEST_F(DEATHTEST, vsnprintf2_fortified) { 575 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 576 ASSERT_EXIT(vsnprintf_helper("0123456789"), testing::KilledBySignal(SIGABRT), ""); 577} 578 579TEST_F(DEATHTEST, strncat_fortified) { 580 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 581 char buf[10]; 582 size_t n = atoi("10"); // avoid compiler optimizations 583 strncpy(buf, "012345678", n); 584 ASSERT_EXIT(strncat(buf, "9", n), testing::KilledBySignal(SIGABRT), ""); 585} 586 587TEST_F(DEATHTEST, strncat2_fortified) { 588 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 589 char buf[10]; 590 buf[0] = '\0'; 591 size_t n = atoi("10"); // avoid compiler optimizations 592 ASSERT_EXIT(strncat(buf, "0123456789", n), testing::KilledBySignal(SIGABRT), ""); 593} 594 595TEST_F(DEATHTEST, strcat_fortified) { 596 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 597 char src[11]; 598 strcpy(src, "0123456789"); 599 char buf[10]; 600 buf[0] = '\0'; 601 ASSERT_EXIT(strcat(buf, src), testing::KilledBySignal(SIGABRT), ""); 602} 603 604TEST_F(DEATHTEST, memmove_fortified) { 605 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 606 char buf[20]; 607 strcpy(buf, "0123456789"); 608 size_t n = atoi("10"); 609 ASSERT_EXIT(memmove(buf + 11, buf, n), testing::KilledBySignal(SIGABRT), ""); 610} 611 612TEST_F(DEATHTEST, memcpy_fortified) { 613 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 614 char bufa[10]; 615 char bufb[10]; 616 strcpy(bufa, "012345678"); 617 size_t n = atoi("11"); 618 ASSERT_EXIT(memcpy(bufb, bufa, n), testing::KilledBySignal(SIGABRT), ""); 619} 620 621TEST_F(DEATHTEST, stpncpy_fortified) { 622 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 623 char bufa[15]; 624 char bufb[10]; 625 strcpy(bufa, "01234567890123"); 626 size_t n = strlen(bufa); 627 ASSERT_EXIT(stpncpy(bufb, bufa, n), testing::KilledBySignal(SIGABRT), ""); 628} 629 630TEST_F(DEATHTEST, stpncpy2_fortified) { 631 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 632 char dest[11]; 633 char src[10]; 634 memcpy(src, "0123456789", sizeof(src)); // src is not null terminated 635 ASSERT_EXIT(stpncpy(dest, src, sizeof(dest)), testing::KilledBySignal(SIGABRT), ""); 636} 637 638TEST_F(DEATHTEST, strncpy_fortified) { 639 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 640 char bufa[15]; 641 char bufb[10]; 642 strcpy(bufa, "01234567890123"); 643 size_t n = strlen(bufa); 644 ASSERT_EXIT(strncpy(bufb, bufa, n), testing::KilledBySignal(SIGABRT), ""); 645} 646 647 648TEST_F(DEATHTEST, strncpy2_fortified) { 649 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 650 char dest[11]; 651 char src[10]; 652 memcpy(src, "0123456789", sizeof(src)); // src is not null terminated 653 ASSERT_EXIT(strncpy(dest, src, sizeof(dest)), testing::KilledBySignal(SIGABRT), ""); 654} 655 656TEST_F(DEATHTEST, snprintf_fortified) { 657 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 658 char bufa[15]; 659 char bufb[10]; 660 strcpy(bufa, "0123456789"); 661 size_t n = strlen(bufa) + 1; 662 ASSERT_EXIT(snprintf(bufb, n, "%s", bufa), testing::KilledBySignal(SIGABRT), ""); 663} 664 665TEST_F(DEATHTEST, bzero_fortified) { 666 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 667 char buf[10]; 668 memcpy(buf, "0123456789", sizeof(buf)); 669 size_t n = atoi("11"); 670 ASSERT_EXIT(bzero(buf, n), testing::KilledBySignal(SIGABRT), ""); 671} 672 673TEST_F(DEATHTEST, umask_fortified) { 674 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 675 mode_t mask = atoi("1023"); // 01777 in octal 676 ASSERT_EXIT(umask(mask), testing::KilledBySignal(SIGABRT), ""); 677} 678 679TEST_F(DEATHTEST, recv_fortified) { 680 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 681 size_t data_len = atoi("11"); // suppress compiler optimizations 682 char buf[10]; 683 ASSERT_EXIT(recv(0, buf, data_len, 0), testing::KilledBySignal(SIGABRT), ""); 684} 685 686TEST_F(DEATHTEST, FD_ISSET_fortified) { 687#if defined(__BIONIC__) // glibc catches this at compile-time. 688 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 689 fd_set set; 690 memset(&set, 0, sizeof(set)); 691 ASSERT_EXIT(FD_ISSET(-1, &set), testing::KilledBySignal(SIGABRT), ""); 692#endif 693} 694 695TEST_F(DEATHTEST, FD_ISSET_2_fortified) { 696 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 697 char buf[1]; 698 fd_set* set = (fd_set*) buf; 699 ASSERT_EXIT(FD_ISSET(0, set), testing::KilledBySignal(SIGABRT), ""); 700} 701 702// gtest's ASSERT_EXIT needs a valid expression, but glibc has a do-while macro. 703static void FD_ZERO_function(fd_set* s) { FD_ZERO(s); } 704 705TEST_F(DEATHTEST, FD_ZERO_fortified) { 706 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 707 char buf[1]; 708 fd_set* set = (fd_set*) buf; 709 ASSERT_EXIT(FD_ZERO_function(set), testing::KilledBySignal(SIGABRT), ""); 710} 711 712TEST_F(DEATHTEST, read_fortified) { 713 ::testing::FLAGS_gtest_death_test_style = "threadsafe"; 714 char buf[1]; 715 size_t ct = atoi("2"); // prevent optimizations 716 int fd = open("/dev/null", O_RDONLY); 717 ASSERT_EXIT(read(fd, buf, ct), testing::KilledBySignal(SIGABRT), ""); 718 close(fd); 719} 720 721extern "C" char* __strncat_chk(char*, const char*, size_t, size_t); 722extern "C" char* __strcat_chk(char*, const char*, size_t); 723 724TEST(TEST_NAME, strncat) { 725 char buf[10]; 726 memset(buf, 'A', sizeof(buf)); 727 buf[0] = 'a'; 728 buf[1] = '\0'; 729 char* res = __strncat_chk(buf, "01234", sizeof(buf) - strlen(buf) - 1, sizeof(buf)); 730 ASSERT_EQ(buf, res); 731 ASSERT_EQ('a', buf[0]); 732 ASSERT_EQ('0', buf[1]); 733 ASSERT_EQ('1', buf[2]); 734 ASSERT_EQ('2', buf[3]); 735 ASSERT_EQ('3', buf[4]); 736 ASSERT_EQ('4', buf[5]); 737 ASSERT_EQ('\0', buf[6]); 738 ASSERT_EQ('A', buf[7]); 739 ASSERT_EQ('A', buf[8]); 740 ASSERT_EQ('A', buf[9]); 741} 742 743TEST(TEST_NAME, strncat2) { 744 char buf[10]; 745 memset(buf, 'A', sizeof(buf)); 746 buf[0] = 'a'; 747 buf[1] = '\0'; 748 char* res = __strncat_chk(buf, "0123456789", 5, sizeof(buf)); 749 ASSERT_EQ(buf, res); 750 ASSERT_EQ('a', buf[0]); 751 ASSERT_EQ('0', buf[1]); 752 ASSERT_EQ('1', buf[2]); 753 ASSERT_EQ('2', buf[3]); 754 ASSERT_EQ('3', buf[4]); 755 ASSERT_EQ('4', buf[5]); 756 ASSERT_EQ('\0', buf[6]); 757 ASSERT_EQ('A', buf[7]); 758 ASSERT_EQ('A', buf[8]); 759 ASSERT_EQ('A', buf[9]); 760} 761 762TEST(TEST_NAME, strncat3) { 763 char buf[10]; 764 memset(buf, 'A', sizeof(buf)); 765 buf[0] = '\0'; 766 char* res = __strncat_chk(buf, "0123456789", 5, sizeof(buf)); 767 ASSERT_EQ(buf, res); 768 ASSERT_EQ('0', buf[0]); 769 ASSERT_EQ('1', buf[1]); 770 ASSERT_EQ('2', buf[2]); 771 ASSERT_EQ('3', buf[3]); 772 ASSERT_EQ('4', buf[4]); 773 ASSERT_EQ('\0', buf[5]); 774 ASSERT_EQ('A', buf[6]); 775 ASSERT_EQ('A', buf[7]); 776 ASSERT_EQ('A', buf[8]); 777 ASSERT_EQ('A', buf[9]); 778} 779 780TEST(TEST_NAME, strncat4) { 781 char buf[10]; 782 memset(buf, 'A', sizeof(buf)); 783 buf[9] = '\0'; 784 char* res = __strncat_chk(buf, "", 5, sizeof(buf)); 785 ASSERT_EQ(buf, res); 786 ASSERT_EQ('A', buf[0]); 787 ASSERT_EQ('A', buf[1]); 788 ASSERT_EQ('A', buf[2]); 789 ASSERT_EQ('A', buf[3]); 790 ASSERT_EQ('A', buf[4]); 791 ASSERT_EQ('A', buf[5]); 792 ASSERT_EQ('A', buf[6]); 793 ASSERT_EQ('A', buf[7]); 794 ASSERT_EQ('A', buf[8]); 795 ASSERT_EQ('\0', buf[9]); 796} 797 798TEST(TEST_NAME, strncat5) { 799 char buf[10]; 800 memset(buf, 'A', sizeof(buf)); 801 buf[0] = 'a'; 802 buf[1] = '\0'; 803 char* res = __strncat_chk(buf, "01234567", 8, sizeof(buf)); 804 ASSERT_EQ(buf, res); 805 ASSERT_EQ('a', buf[0]); 806 ASSERT_EQ('0', buf[1]); 807 ASSERT_EQ('1', buf[2]); 808 ASSERT_EQ('2', buf[3]); 809 ASSERT_EQ('3', buf[4]); 810 ASSERT_EQ('4', buf[5]); 811 ASSERT_EQ('5', buf[6]); 812 ASSERT_EQ('6', buf[7]); 813 ASSERT_EQ('7', buf[8]); 814 ASSERT_EQ('\0', buf[9]); 815} 816 817TEST(TEST_NAME, strncat6) { 818 char buf[10]; 819 memset(buf, 'A', sizeof(buf)); 820 buf[0] = 'a'; 821 buf[1] = '\0'; 822 char* res = __strncat_chk(buf, "01234567", 9, sizeof(buf)); 823 ASSERT_EQ(buf, res); 824 ASSERT_EQ('a', buf[0]); 825 ASSERT_EQ('0', buf[1]); 826 ASSERT_EQ('1', buf[2]); 827 ASSERT_EQ('2', buf[3]); 828 ASSERT_EQ('3', buf[4]); 829 ASSERT_EQ('4', buf[5]); 830 ASSERT_EQ('5', buf[6]); 831 ASSERT_EQ('6', buf[7]); 832 ASSERT_EQ('7', buf[8]); 833 ASSERT_EQ('\0', buf[9]); 834} 835 836 837TEST(TEST_NAME, strcat) { 838 char buf[10]; 839 memset(buf, 'A', sizeof(buf)); 840 buf[0] = 'a'; 841 buf[1] = '\0'; 842 char* res = __strcat_chk(buf, "01234", sizeof(buf)); 843 ASSERT_EQ(buf, res); 844 ASSERT_EQ('a', buf[0]); 845 ASSERT_EQ('0', buf[1]); 846 ASSERT_EQ('1', buf[2]); 847 ASSERT_EQ('2', buf[3]); 848 ASSERT_EQ('3', buf[4]); 849 ASSERT_EQ('4', buf[5]); 850 ASSERT_EQ('\0', buf[6]); 851 ASSERT_EQ('A', buf[7]); 852 ASSERT_EQ('A', buf[8]); 853 ASSERT_EQ('A', buf[9]); 854} 855 856TEST(TEST_NAME, strcat2) { 857 char buf[10]; 858 memset(buf, 'A', sizeof(buf)); 859 buf[0] = 'a'; 860 buf[1] = '\0'; 861 char* res = __strcat_chk(buf, "01234567", sizeof(buf)); 862 ASSERT_EQ(buf, res); 863 ASSERT_EQ('a', buf[0]); 864 ASSERT_EQ('0', buf[1]); 865 ASSERT_EQ('1', buf[2]); 866 ASSERT_EQ('2', buf[3]); 867 ASSERT_EQ('3', buf[4]); 868 ASSERT_EQ('4', buf[5]); 869 ASSERT_EQ('5', buf[6]); 870 ASSERT_EQ('6', buf[7]); 871 ASSERT_EQ('7', buf[8]); 872 ASSERT_EQ('\0', buf[9]); 873} 874 875TEST(TEST_NAME, stpncpy) { 876 char src[10]; 877 char dst[10]; 878 memcpy(src, "0123456789", sizeof(src)); // non null terminated string 879 stpncpy(dst, src, sizeof(dst)); 880 ASSERT_EQ('0', dst[0]); 881 ASSERT_EQ('1', dst[1]); 882 ASSERT_EQ('2', dst[2]); 883 ASSERT_EQ('3', dst[3]); 884 ASSERT_EQ('4', dst[4]); 885 ASSERT_EQ('5', dst[5]); 886 ASSERT_EQ('6', dst[6]); 887 ASSERT_EQ('7', dst[7]); 888 ASSERT_EQ('8', dst[8]); 889 ASSERT_EQ('9', dst[9]); 890} 891 892TEST(TEST_NAME, stpncpy2) { 893 char src[10]; 894 char dst[15]; 895 memcpy(src, "012345678\0", sizeof(src)); 896 stpncpy(dst, src, sizeof(dst)); 897 ASSERT_EQ('0', dst[0]); 898 ASSERT_EQ('1', dst[1]); 899 ASSERT_EQ('2', dst[2]); 900 ASSERT_EQ('3', dst[3]); 901 ASSERT_EQ('4', dst[4]); 902 ASSERT_EQ('5', dst[5]); 903 ASSERT_EQ('6', dst[6]); 904 ASSERT_EQ('7', dst[7]); 905 ASSERT_EQ('8', dst[8]); 906 ASSERT_EQ('\0', dst[9]); 907 ASSERT_EQ('\0', dst[10]); 908 ASSERT_EQ('\0', dst[11]); 909 ASSERT_EQ('\0', dst[12]); 910 ASSERT_EQ('\0', dst[13]); 911 ASSERT_EQ('\0', dst[14]); 912} 913 914TEST(TEST_NAME, strncpy) { 915 char src[10]; 916 char dst[10]; 917 memcpy(src, "0123456789", sizeof(src)); // non null terminated string 918 strncpy(dst, src, sizeof(dst)); 919 ASSERT_EQ('0', dst[0]); 920 ASSERT_EQ('1', dst[1]); 921 ASSERT_EQ('2', dst[2]); 922 ASSERT_EQ('3', dst[3]); 923 ASSERT_EQ('4', dst[4]); 924 ASSERT_EQ('5', dst[5]); 925 ASSERT_EQ('6', dst[6]); 926 ASSERT_EQ('7', dst[7]); 927 ASSERT_EQ('8', dst[8]); 928 ASSERT_EQ('9', dst[9]); 929} 930 931TEST(TEST_NAME, strncpy2) { 932 char src[10]; 933 char dst[15]; 934 memcpy(src, "012345678\0", sizeof(src)); 935 strncpy(dst, src, sizeof(dst)); 936 ASSERT_EQ('0', dst[0]); 937 ASSERT_EQ('1', dst[1]); 938 ASSERT_EQ('2', dst[2]); 939 ASSERT_EQ('3', dst[3]); 940 ASSERT_EQ('4', dst[4]); 941 ASSERT_EQ('5', dst[5]); 942 ASSERT_EQ('6', dst[6]); 943 ASSERT_EQ('7', dst[7]); 944 ASSERT_EQ('8', dst[8]); 945 ASSERT_EQ('\0', dst[9]); 946 ASSERT_EQ('\0', dst[10]); 947 ASSERT_EQ('\0', dst[11]); 948 ASSERT_EQ('\0', dst[12]); 949 ASSERT_EQ('\0', dst[13]); 950 ASSERT_EQ('\0', dst[14]); 951} 952 953TEST(TEST_NAME, strcat_chk_max_int_size) { 954 char buf[10]; 955 memset(buf, 'A', sizeof(buf)); 956 buf[0] = 'a'; 957 buf[1] = '\0'; 958 char* res = __strcat_chk(buf, "01234567", (size_t)-1); 959 ASSERT_EQ(buf, res); 960 ASSERT_EQ('a', buf[0]); 961 ASSERT_EQ('0', buf[1]); 962 ASSERT_EQ('1', buf[2]); 963 ASSERT_EQ('2', buf[3]); 964 ASSERT_EQ('3', buf[4]); 965 ASSERT_EQ('4', buf[5]); 966 ASSERT_EQ('5', buf[6]); 967 ASSERT_EQ('6', buf[7]); 968 ASSERT_EQ('7', buf[8]); 969 ASSERT_EQ('\0', buf[9]); 970} 971 972extern "C" char* __stpcpy_chk(char*, const char*, size_t); 973 974TEST(TEST_NAME, stpcpy_chk_max_int_size) { 975 char buf[10]; 976 char* res = __stpcpy_chk(buf, "012345678", (size_t)-1); 977 ASSERT_EQ(buf + strlen("012345678"), res); 978 ASSERT_STREQ("012345678", buf); 979} 980 981extern "C" char* __strcpy_chk(char*, const char*, size_t); 982 983TEST(TEST_NAME, strcpy_chk_max_int_size) { 984 char buf[10]; 985 char* res = __strcpy_chk(buf, "012345678", (size_t)-1); 986 ASSERT_EQ(buf, res); 987 ASSERT_STREQ("012345678", buf); 988} 989 990extern "C" void* __memcpy_chk(void*, const void*, size_t, size_t); 991 992TEST(TEST_NAME, memcpy_chk_max_int_size) { 993 char buf[10]; 994 void* res = __memcpy_chk(buf, "012345678", sizeof(buf), (size_t)-1); 995 ASSERT_EQ((void*)buf, res); 996 ASSERT_EQ('0', buf[0]); 997 ASSERT_EQ('1', buf[1]); 998 ASSERT_EQ('2', buf[2]); 999 ASSERT_EQ('3', buf[3]); 1000 ASSERT_EQ('4', buf[4]); 1001 ASSERT_EQ('5', buf[5]); 1002 ASSERT_EQ('6', buf[6]); 1003 ASSERT_EQ('7', buf[7]); 1004 ASSERT_EQ('8', buf[8]); 1005 ASSERT_EQ('\0', buf[9]); 1006} 1007 1008// Verify that macro expansion is done properly for sprintf/snprintf (which 1009// are defined as macros in stdio.h under clang). 1010#define CONTENTS "macro expansion" 1011#define BUF_AND_SIZE(A) A, sizeof(A) 1012#define BUF_AND_CONTENTS(A) A, CONTENTS 1013#define BUF_AND_SIZE_AND_CONTENTS(A) A, sizeof(A), CONTENTS 1014TEST(TEST_NAME, s_n_printf_macro_expansion) { 1015 char buf[BUFSIZ]; 1016 snprintf(BUF_AND_SIZE(buf), CONTENTS); 1017 EXPECT_STREQ(CONTENTS, buf); 1018 1019 snprintf(BUF_AND_SIZE_AND_CONTENTS(buf)); 1020 EXPECT_STREQ(CONTENTS, buf); 1021 1022 sprintf(BUF_AND_CONTENTS(buf)); 1023 EXPECT_STREQ(CONTENTS, buf); 1024} 1025