1 //===- KillTheDoctor - Prevent Dr. Watson from stopping tests ---*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This program provides an extremely hacky way to stop Dr. Watson from starting
10 // due to unhandled exceptions in child processes.
11 //
12 // This simply starts the program named in the first positional argument with
13 // the arguments following it under a debugger. All this debugger does is catch
14 // any unhandled exceptions thrown in the child process and close the program
15 // (and hopefully tells someone about it).
16 //
17 // This also provides another really hacky method to prevent assert dialog boxes
18 // from popping up. When --no-user32 is passed, if any process loads user32.dll,
19 // we assume it is trying to call MessageBoxEx and terminate it. The proper way
20 // to do this would be to actually set a break point, but there's quite a bit
21 // of code involved to get the address of MessageBoxEx in the remote process's
22 // address space due to Address space layout randomization (ASLR). This can be
23 // added if it's ever actually needed.
24 //
25 // If the subprocess exits for any reason other than successful termination, -1
26 // is returned. If the process exits normally the value it returned is returned.
27 //
28 // I hate Windows.
29 //
30 //===----------------------------------------------------------------------===//
31 
32 #include "llvm/ADT/STLExtras.h"
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/ADT/SmallVector.h"
35 #include "llvm/ADT/StringExtras.h"
36 #include "llvm/ADT/StringRef.h"
37 #include "llvm/ADT/Twine.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/InitLLVM.h"
40 #include "llvm/Support/ManagedStatic.h"
41 #include "llvm/Support/Path.h"
42 #include "llvm/Support/PrettyStackTrace.h"
43 #include "llvm/Support/Signals.h"
44 #include "llvm/Support/WindowsError.h"
45 #include "llvm/Support/raw_ostream.h"
46 #include "llvm/Support/type_traits.h"
47 #include <algorithm>
48 #include <cerrno>
49 #include <cstdlib>
50 #include <map>
51 #include <string>
52 #include <system_error>
53 
54 // These includes must be last.
55 #include <windows.h>
56 #include <winerror.h>
57 #include <dbghelp.h>
58 #include <psapi.h>
59 
60 using namespace llvm;
61 
62 #undef max
63 
64 namespace {
65   cl::opt<std::string> ProgramToRun(cl::Positional,
66     cl::desc("<program to run>"));
67   cl::list<std::string>  Argv(cl::ConsumeAfter,
68     cl::desc("<program arguments>..."));
69   cl::opt<bool> TraceExecution("x",
70     cl::desc("Print detailed output about what is being run to stderr."));
71   cl::opt<unsigned> Timeout("t", cl::init(0),
72     cl::desc("Set maximum runtime in seconds. Defaults to infinite."));
73   cl::opt<bool> NoUser32("no-user32",
74     cl::desc("Terminate process if it loads user32.dll."));
75 
76   StringRef ToolName;
77 
78   template <typename HandleType>
79   class ScopedHandle {
80     typedef typename HandleType::handle_type handle_type;
81 
82     handle_type Handle;
83 
84   public:
85     ScopedHandle()
86       : Handle(HandleType::GetInvalidHandle()) {}
87 
88     explicit ScopedHandle(handle_type handle)
89       : Handle(handle) {}
90 
91     ~ScopedHandle() {
92       HandleType::Destruct(Handle);
93     }
94 
95     ScopedHandle& operator=(handle_type handle) {
96       // Cleanup current handle.
97       if (!HandleType::isValid(Handle))
98         HandleType::Destruct(Handle);
99       Handle = handle;
100       return *this;
101     }
102 
103     operator bool() const {
104       return HandleType::isValid(Handle);
105     }
106 
107     operator handle_type() {
108       return Handle;
109     }
110   };
111 
112   // This implements the most common handle in the Windows API.
113   struct CommonHandle {
114     typedef HANDLE handle_type;
115 
116     static handle_type GetInvalidHandle() {
117       return INVALID_HANDLE_VALUE;
118     }
119 
120     static void Destruct(handle_type Handle) {
121       ::CloseHandle(Handle);
122     }
123 
124     static bool isValid(handle_type Handle) {
125       return Handle != GetInvalidHandle();
126     }
127   };
128 
129   struct FileMappingHandle {
130     typedef HANDLE handle_type;
131 
132     static handle_type GetInvalidHandle() {
133       return NULL;
134     }
135 
136     static void Destruct(handle_type Handle) {
137       ::CloseHandle(Handle);
138     }
139 
140     static bool isValid(handle_type Handle) {
141       return Handle != GetInvalidHandle();
142     }
143   };
144 
145   struct MappedViewOfFileHandle {
146     typedef LPVOID handle_type;
147 
148     static handle_type GetInvalidHandle() {
149       return NULL;
150     }
151 
152     static void Destruct(handle_type Handle) {
153       ::UnmapViewOfFile(Handle);
154     }
155 
156     static bool isValid(handle_type Handle) {
157       return Handle != GetInvalidHandle();
158     }
159   };
160 
161   struct ProcessHandle : CommonHandle {};
162   struct ThreadHandle  : CommonHandle {};
163   struct TokenHandle   : CommonHandle {};
164   struct FileHandle    : CommonHandle {};
165 
166   typedef ScopedHandle<FileMappingHandle>       FileMappingScopedHandle;
167   typedef ScopedHandle<MappedViewOfFileHandle>  MappedViewOfFileScopedHandle;
168   typedef ScopedHandle<ProcessHandle>           ProcessScopedHandle;
169   typedef ScopedHandle<ThreadHandle>            ThreadScopedHandle;
170   typedef ScopedHandle<TokenHandle>             TokenScopedHandle;
171   typedef ScopedHandle<FileHandle>              FileScopedHandle;
172 }
173 
174 static std::error_code windows_error(DWORD E) { return mapWindowsError(E); }
175 
176 static std::error_code GetFileNameFromHandle(HANDLE FileHandle,
177                                              std::string &Name) {
178   char Filename[MAX_PATH+1];
179   bool Success = false;
180   Name.clear();
181 
182   // Get the file size.
183   LARGE_INTEGER FileSize;
184   Success = ::GetFileSizeEx(FileHandle, &FileSize);
185 
186   if (!Success)
187     return windows_error(::GetLastError());
188 
189   // Create a file mapping object.
190   FileMappingScopedHandle FileMapping(
191     ::CreateFileMappingA(FileHandle,
192                          NULL,
193                          PAGE_READONLY,
194                          0,
195                          1,
196                          NULL));
197 
198   if (!FileMapping)
199     return windows_error(::GetLastError());
200 
201   // Create a file mapping to get the file name.
202   MappedViewOfFileScopedHandle MappedFile(
203     ::MapViewOfFile(FileMapping, FILE_MAP_READ, 0, 0, 1));
204 
205   if (!MappedFile)
206     return windows_error(::GetLastError());
207 
208   Success = ::GetMappedFileNameA(::GetCurrentProcess(),
209                                 MappedFile,
210                                 Filename,
211                                 array_lengthof(Filename) - 1);
212 
213   if (!Success)
214     return windows_error(::GetLastError());
215   else {
216     Name = Filename;
217     return std::error_code();
218   }
219 }
220 
221 /// Find program using shell lookup rules.
222 /// @param Program This is either an absolute path, relative path, or simple a
223 ///        program name. Look in PATH for any programs that match. If no
224 ///        extension is present, try all extensions in PATHEXT.
225 /// @return If ec == errc::success, The absolute path to the program. Otherwise
226 ///         the return value is undefined.
227 static std::string FindProgram(const std::string &Program,
228                                std::error_code &ec) {
229   char PathName[MAX_PATH + 1];
230   typedef SmallVector<StringRef, 12> pathext_t;
231   pathext_t pathext;
232   // Check for the program without an extension (in case it already has one).
233   pathext.push_back("");
234   SplitString(std::getenv("PATHEXT"), pathext, ";");
235 
236   for (pathext_t::iterator i = pathext.begin(), e = pathext.end(); i != e; ++i){
237     SmallString<5> ext;
238     for (std::size_t ii = 0, e = i->size(); ii != e; ++ii)
239       ext.push_back(::tolower((*i)[ii]));
240     LPCSTR Extension = NULL;
241     if (ext.size() && ext[0] == '.')
242       Extension = ext.c_str();
243     DWORD length = ::SearchPathA(NULL,
244                                  Program.c_str(),
245                                  Extension,
246                                  array_lengthof(PathName),
247                                  PathName,
248                                  NULL);
249     if (length == 0)
250       ec = windows_error(::GetLastError());
251     else if (length > array_lengthof(PathName)) {
252       // This may have been the file, return with error.
253       ec = windows_error(ERROR_BUFFER_OVERFLOW);
254       break;
255     } else {
256       // We found the path! Return it.
257       ec = std::error_code();
258       break;
259     }
260   }
261 
262   // Make sure PathName is valid.
263   PathName[MAX_PATH] = 0;
264   return PathName;
265 }
266 
267 static StringRef ExceptionCodeToString(DWORD ExceptionCode) {
268   switch(ExceptionCode) {
269   case EXCEPTION_ACCESS_VIOLATION: return "EXCEPTION_ACCESS_VIOLATION";
270   case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
271     return "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
272   case EXCEPTION_BREAKPOINT: return "EXCEPTION_BREAKPOINT";
273   case EXCEPTION_DATATYPE_MISALIGNMENT:
274     return "EXCEPTION_DATATYPE_MISALIGNMENT";
275   case EXCEPTION_FLT_DENORMAL_OPERAND: return "EXCEPTION_FLT_DENORMAL_OPERAND";
276   case EXCEPTION_FLT_DIVIDE_BY_ZERO: return "EXCEPTION_FLT_DIVIDE_BY_ZERO";
277   case EXCEPTION_FLT_INEXACT_RESULT: return "EXCEPTION_FLT_INEXACT_RESULT";
278   case EXCEPTION_FLT_INVALID_OPERATION:
279     return "EXCEPTION_FLT_INVALID_OPERATION";
280   case EXCEPTION_FLT_OVERFLOW: return "EXCEPTION_FLT_OVERFLOW";
281   case EXCEPTION_FLT_STACK_CHECK: return "EXCEPTION_FLT_STACK_CHECK";
282   case EXCEPTION_FLT_UNDERFLOW: return "EXCEPTION_FLT_UNDERFLOW";
283   case EXCEPTION_ILLEGAL_INSTRUCTION: return "EXCEPTION_ILLEGAL_INSTRUCTION";
284   case EXCEPTION_IN_PAGE_ERROR: return "EXCEPTION_IN_PAGE_ERROR";
285   case EXCEPTION_INT_DIVIDE_BY_ZERO: return "EXCEPTION_INT_DIVIDE_BY_ZERO";
286   case EXCEPTION_INT_OVERFLOW: return "EXCEPTION_INT_OVERFLOW";
287   case EXCEPTION_INVALID_DISPOSITION: return "EXCEPTION_INVALID_DISPOSITION";
288   case EXCEPTION_NONCONTINUABLE_EXCEPTION:
289     return "EXCEPTION_NONCONTINUABLE_EXCEPTION";
290   case EXCEPTION_PRIV_INSTRUCTION: return "EXCEPTION_PRIV_INSTRUCTION";
291   case EXCEPTION_SINGLE_STEP: return "EXCEPTION_SINGLE_STEP";
292   case EXCEPTION_STACK_OVERFLOW: return "EXCEPTION_STACK_OVERFLOW";
293   default: return "<unknown>";
294   }
295 }
296 
297 int main(int argc, char **argv) {
298   // Print a stack trace if we signal out.
299   llvm::InitLLVM X(argc, argv);
300   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
301 
302   ToolName = argv[0];
303 
304   cl::ParseCommandLineOptions(argc, argv, "Dr. Watson Assassin.\n");
305   if (ProgramToRun.size() == 0) {
306     cl::PrintHelpMessage();
307     return -1;
308   }
309 
310   if (Timeout > std::numeric_limits<uint32_t>::max() / 1000) {
311     errs() << ToolName << ": Timeout value too large, must be less than: "
312                        << std::numeric_limits<uint32_t>::max() / 1000
313                        << '\n';
314     return -1;
315   }
316 
317   std::string CommandLine(ProgramToRun);
318 
319   std::error_code ec;
320   ProgramToRun = FindProgram(ProgramToRun, ec);
321   if (ec) {
322     errs() << ToolName << ": Failed to find program: '" << CommandLine
323            << "': " << ec.message() << '\n';
324     return -1;
325   }
326 
327   if (TraceExecution)
328     errs() << ToolName << ": Found Program: " << ProgramToRun << '\n';
329 
330   for (const std::string &Arg : Argv) {
331     CommandLine.push_back(' ');
332     CommandLine.append(Arg);
333   }
334 
335   if (TraceExecution)
336     errs() << ToolName << ": Program Image Path: " << ProgramToRun << '\n'
337            << ToolName << ": Command Line: " << CommandLine << '\n';
338 
339   STARTUPINFOA StartupInfo;
340   PROCESS_INFORMATION ProcessInfo;
341   std::memset(&StartupInfo, 0, sizeof(StartupInfo));
342   StartupInfo.cb = sizeof(StartupInfo);
343   std::memset(&ProcessInfo, 0, sizeof(ProcessInfo));
344 
345   // Set error mode to not display any message boxes. The child process inherits
346   // this.
347   ::SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
348   ::_set_error_mode(_OUT_TO_STDERR);
349 
350   BOOL success = ::CreateProcessA(ProgramToRun.c_str(),
351                                   const_cast<LPSTR>(CommandLine.c_str()),
352                                   NULL,
353                                   NULL,
354                                   FALSE,
355                                   DEBUG_PROCESS,
356                                   NULL,
357                                   NULL,
358                                   &StartupInfo,
359                                   &ProcessInfo);
360   if (!success) {
361     errs() << ToolName << ": Failed to run program: '" << ProgramToRun << "': "
362            << std::error_code(windows_error(::GetLastError())).message()
363            << '\n';
364     return -1;
365   }
366 
367   // Make sure ::CloseHandle is called on exit.
368   std::map<DWORD, HANDLE> ProcessIDToHandle;
369 
370   DEBUG_EVENT DebugEvent;
371   std::memset(&DebugEvent, 0, sizeof(DebugEvent));
372   DWORD dwContinueStatus = DBG_CONTINUE;
373 
374   // Run the program under the debugger until either it exits, or throws an
375   // exception.
376   if (TraceExecution)
377     errs() << ToolName << ": Debugging...\n";
378 
379   while(true) {
380     DWORD TimeLeft = INFINITE;
381     if (Timeout > 0) {
382       FILETIME CreationTime, ExitTime, KernelTime, UserTime;
383       ULARGE_INTEGER a, b;
384       success = ::GetProcessTimes(ProcessInfo.hProcess,
385                                   &CreationTime,
386                                   &ExitTime,
387                                   &KernelTime,
388                                   &UserTime);
389       if (!success) {
390         ec = windows_error(::GetLastError());
391 
392         errs() << ToolName << ": Failed to get process times: "
393                << ec.message() << '\n';
394         return -1;
395       }
396       a.LowPart = KernelTime.dwLowDateTime;
397       a.HighPart = KernelTime.dwHighDateTime;
398       b.LowPart = UserTime.dwLowDateTime;
399       b.HighPart = UserTime.dwHighDateTime;
400       // Convert 100-nanosecond units to milliseconds.
401       uint64_t TotalTimeMiliseconds = (a.QuadPart + b.QuadPart) / 10000;
402       // Handle the case where the process has been running for more than 49
403       // days.
404       if (TotalTimeMiliseconds > std::numeric_limits<uint32_t>::max()) {
405         errs() << ToolName << ": Timeout Failed: Process has been running for"
406                               "more than 49 days.\n";
407         return -1;
408       }
409 
410       // We check with > instead of using Timeleft because if
411       // TotalTimeMiliseconds is greater than Timeout * 1000, TimeLeft would
412       // underflow.
413       if (TotalTimeMiliseconds > (Timeout * 1000)) {
414         errs() << ToolName << ": Process timed out.\n";
415         ::TerminateProcess(ProcessInfo.hProcess, -1);
416         // Otherwise other stuff starts failing...
417         return -1;
418       }
419 
420       TimeLeft = (Timeout * 1000) - static_cast<uint32_t>(TotalTimeMiliseconds);
421     }
422     success = WaitForDebugEvent(&DebugEvent, TimeLeft);
423 
424     if (!success) {
425       DWORD LastError = ::GetLastError();
426       ec = windows_error(LastError);
427 
428       if (LastError == ERROR_SEM_TIMEOUT || LastError == WSAETIMEDOUT) {
429         errs() << ToolName << ": Process timed out.\n";
430         ::TerminateProcess(ProcessInfo.hProcess, -1);
431         // Otherwise other stuff starts failing...
432         return -1;
433       }
434 
435       errs() << ToolName << ": Failed to wait for debug event in program: '"
436              << ProgramToRun << "': " << ec.message() << '\n';
437       return -1;
438     }
439 
440     switch(DebugEvent.dwDebugEventCode) {
441     case CREATE_PROCESS_DEBUG_EVENT:
442       // Make sure we remove the handle on exit.
443       if (TraceExecution)
444         errs() << ToolName << ": Debug Event: CREATE_PROCESS_DEBUG_EVENT\n";
445       ProcessIDToHandle[DebugEvent.dwProcessId] =
446         DebugEvent.u.CreateProcessInfo.hProcess;
447       ::CloseHandle(DebugEvent.u.CreateProcessInfo.hFile);
448       break;
449     case EXIT_PROCESS_DEBUG_EVENT: {
450         if (TraceExecution)
451           errs() << ToolName << ": Debug Event: EXIT_PROCESS_DEBUG_EVENT\n";
452 
453         // If this is the process we originally created, exit with its exit
454         // code.
455         if (DebugEvent.dwProcessId == ProcessInfo.dwProcessId)
456           return DebugEvent.u.ExitProcess.dwExitCode;
457 
458         // Otherwise cleanup any resources we have for it.
459         std::map<DWORD, HANDLE>::iterator ExitingProcess =
460           ProcessIDToHandle.find(DebugEvent.dwProcessId);
461         if (ExitingProcess == ProcessIDToHandle.end()) {
462           errs() << ToolName << ": Got unknown process id!\n";
463           return -1;
464         }
465         ::CloseHandle(ExitingProcess->second);
466         ProcessIDToHandle.erase(ExitingProcess);
467       }
468       break;
469     case CREATE_THREAD_DEBUG_EVENT:
470       ::CloseHandle(DebugEvent.u.CreateThread.hThread);
471       break;
472     case LOAD_DLL_DEBUG_EVENT: {
473         // Cleanup the file handle.
474         FileScopedHandle DLLFile(DebugEvent.u.LoadDll.hFile);
475         std::string DLLName;
476         ec = GetFileNameFromHandle(DLLFile, DLLName);
477         if (ec) {
478           DLLName = "<failed to get file name from file handle> : ";
479           DLLName += ec.message();
480         }
481         if (TraceExecution) {
482           errs() << ToolName << ": Debug Event: LOAD_DLL_DEBUG_EVENT\n";
483           errs().indent(ToolName.size()) << ": DLL Name : " << DLLName << '\n';
484         }
485 
486         if (NoUser32 && sys::path::stem(DLLName) == "user32") {
487           // Program is loading user32.dll, in the applications we are testing,
488           // this only happens if an assert has fired. By now the message has
489           // already been printed, so simply close the program.
490           errs() << ToolName << ": user32.dll loaded!\n";
491           errs().indent(ToolName.size())
492                  << ": This probably means that assert was called. Closing "
493                     "program to prevent message box from popping up.\n";
494           dwContinueStatus = DBG_CONTINUE;
495           ::TerminateProcess(ProcessIDToHandle[DebugEvent.dwProcessId], -1);
496           return -1;
497         }
498       }
499       break;
500     case EXCEPTION_DEBUG_EVENT: {
501         // Close the application if this exception will not be handled by the
502         // child application.
503         if (TraceExecution)
504           errs() << ToolName << ": Debug Event: EXCEPTION_DEBUG_EVENT\n";
505 
506         EXCEPTION_DEBUG_INFO  &Exception = DebugEvent.u.Exception;
507         if (Exception.dwFirstChance > 0) {
508           if (TraceExecution) {
509             errs().indent(ToolName.size()) << ": Debug Info : ";
510             errs() << "First chance exception at "
511                    << Exception.ExceptionRecord.ExceptionAddress
512                    << ", exception code: "
513                    << ExceptionCodeToString(
514                         Exception.ExceptionRecord.ExceptionCode)
515                    << " (" << Exception.ExceptionRecord.ExceptionCode << ")\n";
516           }
517           dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
518         } else {
519           errs() << ToolName << ": Unhandled exception in: " << ProgramToRun
520                  << "!\n";
521                  errs().indent(ToolName.size()) << ": location: ";
522                  errs() << Exception.ExceptionRecord.ExceptionAddress
523                         << ", exception code: "
524                         << ExceptionCodeToString(
525                             Exception.ExceptionRecord.ExceptionCode)
526                         << " (" << Exception.ExceptionRecord.ExceptionCode
527                         << ")\n";
528           dwContinueStatus = DBG_CONTINUE;
529           ::TerminateProcess(ProcessIDToHandle[DebugEvent.dwProcessId], -1);
530           return -1;
531         }
532       }
533       break;
534     default:
535       // Do nothing.
536       if (TraceExecution)
537         errs() << ToolName << ": Debug Event: <unknown>\n";
538       break;
539     }
540 
541     success = ContinueDebugEvent(DebugEvent.dwProcessId,
542                                  DebugEvent.dwThreadId,
543                                  dwContinueStatus);
544     if (!success) {
545       ec = windows_error(::GetLastError());
546       errs() << ToolName << ": Failed to continue debugging program: '"
547              << ProgramToRun << "': " << ec.message() << '\n';
548       return -1;
549     }
550 
551     dwContinueStatus = DBG_CONTINUE;
552   }
553 
554   assert(0 && "Fell out of debug loop. This shouldn't be possible!");
555   return -1;
556 }
557