[libFuzzer] Diff 20 - Update tests to use more general functions instead of posix specific.

[mpividori]

Summary

I update the tests to use SearchMemory(), StrStr(), StrCaseStr(), and SleepSeconds(), instead of posix specific functions.

[zturner]

lib/Fuzzer/FuzzerUtilWindows.cpp

181–182

Windows has strstr, it just doesn't have strcasestr. I would implement this one using just strstr.

[mpividori]

lib/Fuzzer/FuzzerUtilWindows.cpp

181–182

@zturner , You are right. I confused because I found the function StrStr() from Shlwapi.lib . I didn't realized that strstr() is part of the std library.
I think it is better to continue with actual implementation of StrCaseStr(). By using std::search(), we don't have no copy the arrays.
If we want to use strstr(), we should copy both arrays, then apply tolower(), and then use strstr(). This can be slower with large arrays.

[mpividori]

Update diff to remove StrStr().

[zturner]

Agree, we do need StrCaseStr. Looks good to me.

[mpividori]

@kcc would you agree with these changes?

[kcc]

lib/Fuzzer/test/OutOfMemoryTest.cpp

5

Please don't.
I want the tests to remain free of any such deps.

lib/Fuzzer/test/StrstrTest.cpp

5

ditto

[mpividori]

lib/Fuzzer/test/OutOfMemoryTest.cpp

5

Free from dependencies from libFuzzer?? Even if this tests are linked with the LLVMFuzzer.lib library? You want me to remove the include and declare the function signature? I don't understand...

[mpividori]

lib/Fuzzer/test/OutOfMemoryTest.cpp

5

In CustomCrossOverTest.cpp, CustomMutatorTest.cpp, and other tests, you also include:
#include "FuzzerInterface.h" ...

[kcc]

lib/Fuzzer/test/OutOfMemoryTest.cpp

5

I don't want these tests to depend on libFuzzer in any way.
obviously, declaring the function signature here is even worse.
These tests should be usable with other fuzzing engines.

CustomCrossOverTest.cpp, CustomMutatorTest.cpp,

These are the exceptions because they use cutom mutator/crossover -- something that other fuzzing engines don't support.

[zturner]

What about copying these functions into a common header file that has no dependencies and can be symlinked from the test dir into the source tree? That way the test (which now consists of a cpp file and a h file) is self contained, but there is still only one master copy of the h file so we don't have to worry about code duplication. Then FuzzerUtilWindows.h could just incldue that header file.

[zturner]

(Of course the alternative is just rewrite the function here, which is not the end of the world, although kind of unfortunate)

[kcc]

(summary of offline discussion).

For OutOfMemoryTest.cpp just use c++11 sleep

For StrstrTest.cpp: this test tests the ability of *a* fuzzing engine to look through strstr and friends.
If some platform does not have e.g. strcasestr, there is no point in implementing it for this test.
a simple

 #ifdef SOMETHING
#  define strcasestr strstr
#endif

will be good enough

[mpividori]

@kcc Ok. Let me know if you agree with this final diff.

[kcc]

LGTM with a nit

lib/Fuzzer/test/StrstrTest.cpp

12

add a comment:
win32 does not have strcasestr and memmem, so we are not testing them

[mpividori]

Done.

[kcc]

LGTM

lib/Fuzzer/FuzzerUtil.h

 
 int ExecuteCommand(const std::string &Command);
 
 FILE *OpenProcessPipe(const char *Command, const char *Mode);
 
 const void *SearchMemory(const void *haystack, size_t haystacklen,
                          const void *needle, size_t needlelen);
 
+const char *StrStr(const char* Ref, const char* Patt);
+
+const char *StrCaseStr(const char* Ref, const char* Patt);
+
 std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
                               const char *X1, const char *X2);
 
 inline std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
                                      const char *X) {
   return CloneArgsWithoutX(Args, X, X);
 }
 
 }  // namespace fuzzer
 
 #endif  // LLVM_FUZZER_UTIL_H

lib/Fuzzer/FuzzerUtilPosix.cpp

FILE *OpenProcessPipe(const char *Command, const char *Mode) {
   return popen(Command, Mode);
 }
 
 const void *SearchMemory(const void *Data, size_t DataLen, const void *Patt,
                          size_t PattLen) {
   return memmem(Data, DataLen, Patt, PattLen);
 }
 
+const char *StrStr(const char* Ref, const char* Patt) {
+  return strstr(Ref, Patt);
+}
+
+const char *StrCaseStr(const char* Ref, const char* Patt) {
+  return strcasestr(Ref, Patt);
+}
+
 }  // namespace fuzzer
 
 #endif // LIBFUZZER_POSIX

lib/Fuzzer/FuzzerUtilWindows.cpp

const void *SearchMemory(const void *Data, size_t DataLen, const void *Patt,
 
   for (const char *It = Cdata; It < End; ++It)
     if (It[0] == Cpatt[0] && memcmp(It, Cpatt, PattLen) == 0)
       return It;
 
   return NULL;
 }
 
+const char *StrStr(const char* Ref, const char* Patt) {
+  return (const char*) fuzzer::SearchMemory(Ref, ::strlen(Ref), Patt,
+    ::strlen(Patt));
+}
+
+static bool IgnoreCaseCmp(char a, char b) {
+  return ::tolower(a) == ::tolower(b);
+}
+
+const char *StrCaseStr(const char* Ref, const char* Patt) {
+  const char* RefEnd = Ref + ::strlen(Ref);
+  const char* PattEnd = Patt + ::strlen(Patt);
+  const char* It = std::search(Ref, RefEnd, Patt, PattEnd, IgnoreCaseCmp);
+  if (It == RefEnd)
+    return NULL;
+  return It;
+}
+
 } // namespace fuzzer
 
 #endif // LIBFUZZER_WINDOWS

lib/Fuzzer/test/OutOfMemoryTest.cpp

 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 
 // Tests OOM handling.
+#include "../FuzzerUtil.h"
 #include <assert.h>
 #include <cstdint>
 #include <cstdlib>
 #include <cstddef>
 #include <cstring>
 #include <iostream>
 #include <unistd.h>
 
 static volatile char *SinkPtr;
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   if (Size > 0 && Data[0] == 'H') {
     if (Size > 1 && Data[1] == 'i') {
       if (Size > 2 && Data[2] == '!') {
         while (true) {
           size_t kSize = 1 << 28;
           char *p = new char[kSize];
           memset(p, 0, kSize);
           SinkPtr = p;
-          sleep(1);
+          fuzzer::SleepSeconds(1);
         }
       }
     }
   }
   return 0;
 }
 

lib/Fuzzer/test/StrstrTest.cpp

 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 
 // Test strstr and strcasestr hooks.
+#include "../FuzzerUtil.h"
 #include <string>
 #include <string.h>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   if (Size < 4) return 0;
   std::string s(reinterpret_cast<const char*>(Data), Size);
-  if (strstr(s.c_str(), "FUZZ") &&
-      strcasestr(s.c_str(), "aBcD") &&
-      memmem(s.data(), s.size(), "kuku", 4)
+  if (fuzzer::StrStr(s.c_str(), "FUZZ") &&
+      fuzzer::StrCaseStr(s.c_str(), "aBcD") &&
+      fuzzer::SearchMemory(s.data(), s.size(), "kuku", 4)
       ) {
     fprintf(stderr, "BINGO\n");
     exit(1);
   }
   return 0;
 }