Instrument setup.exe in the SyzyAsan builds.

chrome/installer/mini_installer/mini_installer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // mini_installer.exe is the first exe that is run when chrome is being
 // installed or upgraded. It is designed to be extremely small (~5KB with no
 // extra resources linked) and it has two main jobs:
 //   1) unpack the resources (possibly decompressing some)
 //   2) run the real installer (setup.exe) with appropriate flags.
 //
@@ skipping 41 matching lines @@
 
 // This structure passes data back and forth for the processing
 // of resource callbacks.
 struct Context {
   // Input to the call back method. Specifies the dir to save resources.
   const wchar_t* base_path;
   // First output from call back method. Full path of Chrome archive.
   PathString* chrome_resource_path;
   // Second output from call back method. Full path of Setup archive/exe.
   PathString* setup_resource_path;
+#if defined(SYZYASAN)
+  PathString* syzyasan_resource_path;
+#endif
 };
 
 // TODO(grt): Frame this in terms of whether or not the brand supports
 // integation with Omaha, where Google Update is the Google-specific fork of
 // the open-source Omaha project.
 #if defined(GOOGLE_CHROME_BUILD)
 // Opens the Google Update ClientState key. If |binaries| is false, opens the
 // key for Google Chrome or Chrome SxS (canary). If |binaries| is true and an
 // existing multi-install Chrome is being updated, opens the key for the
 // multi-install binaries; otherwise, returns false.
@@ skipping 212 matching lines @@
       !full_path.append(name) ||
       !resource.WriteToDisk(full_path.get()))
     return FALSE;
 
   if (StrStartsWith(name, kChromeArchivePrefix)) {
     if (!ctx->chrome_resource_path->assign(full_path.get()))
       return FALSE;
   } else if (StrStartsWith(name, kSetupPrefix)) {
     if (!ctx->setup_resource_path->assign(full_path.get()))
       return FALSE;
+#if defined(SYZYASAN)
+  } else if (StrStartsWith(name, kSyzyAsanRuntimePrefix)) {
+    if (!ctx->syzyasan_resource_path->assign(full_path.get()))
+      return FALSE;
+#endif
   } else {
     // Resources should either start with 'chrome' or 'setup'. We don't handle
     // anything else.
     return FALSE;
   }
 
   return TRUE;
 }
 
-#if defined(COMPONENT_BUILD)
+#if defined(COMPONENT_BUILD) || defined(SYZYASAN)
 // An EnumResNameProc callback that writes the resource |name| to disk in the
 // directory |base_path_ptr| (which must end with a path separator).
 BOOL CALLBACK WriteResourceToDirectory(HMODULE module,
                                        const wchar_t* type,
                                        wchar_t* name,
                                        LONG_PTR base_path_ptr) {
   const wchar_t* base_path = reinterpret_cast<const wchar_t*>(base_path_ptr);
   PathString full_path;
 
   PEResource resource(name, type, module);
@@ skipping 10 matching lines @@
 // - Resource type 'B7', compressed using LZMA (*.7z)
 // - Resource type 'BL', compressed using LZ (*.ex_)
 // - Resource type 'BN', uncompressed (*.exe)
 // If setup.exe is present in more than one form, the precedence order is
 // BN < BL < B7
 // For more details see chrome/tools/build/win/create_installer_archive.py.
 // For component builds (where setup.ex_ is always used), all files stored as
 // uncompressed 'BN' resources are also extracted. This is generally the set of
 // DLLs/resources needed by setup.exe to run.
 ProcessExitResult UnpackBinaryResources(const Configuration& configuration,
-                                      HMODULE module, const wchar_t* base_path,
-                                      PathString* archive_path,
-                                      PathString* setup_path) {
+                                        HMODULE module,
+                                        Context* context) {
   // Generate the setup.exe path where we patch/uncompress setup resource.
   PathString setup_dest_path;
-  if (!setup_dest_path.assign(base_path) ||
+  if (!setup_dest_path.assign(context->base_path) ||
       !setup_dest_path.append(kSetupExe))
     return ProcessExitResult(PATH_STRING_OVERFLOW);
 
-  // Prepare the input to OnResourceFound method that needs a location where
-  // it will write all the resources.
-  Context context = {
-    base_path,
-    archive_path,
-    setup_path,
-  };
-
   // Get the resources of type 'B7' (7zip archive).
   // We need a chrome archive to do the installation. So if there
   // is a problem in fetching B7 resource, just return an error.
   if (!::EnumResourceNames(module, kLZMAResourceType, OnResourceFound,
-                           reinterpret_cast<LONG_PTR>(&context))) {
+                           reinterpret_cast<LONG_PTR>(context))) {
     return ProcessExitResult(UNABLE_TO_EXTRACT_CHROME_ARCHIVE,
                              ::GetLastError());
   }
-  if (archive_path->length() == 0) {
+  if (context->chrome_resource_path->length() == 0) {
     return ProcessExitResult(UNABLE_TO_EXTRACT_CHROME_ARCHIVE);
   }
 
   ProcessExitResult exit_code = ProcessExitResult(SUCCESS_EXIT_CODE);
 
   // If we found setup 'B7' resource (used for differential updates), handle
   // it.  Note that this is only for Chrome; Chromium installs are always
   // "full" installs.
-  if (setup_path->length() > 0) {
+  if (context->setup_resource_path->length() > 0) {
     CommandString cmd_line;
     PathString exe_path;
     // Get the path to setup.exe first.
     exit_code = GetPreviousSetupExePath(configuration, exe_path.get(),
                                         exe_path.capacity());
     if (exit_code.IsSuccess()) {
-      if (!cmd_line.append(exe_path.get()) ||
-          !cmd_line.append(L" --") ||
-          !cmd_line.append(kCmdUpdateSetupExe) ||
-          !cmd_line.append(L"=\"") ||
-          !cmd_line.append(setup_path->get()) ||
-          !cmd_line.append(L"\" --") ||
-          !cmd_line.append(kCmdNewSetupExe) ||
-          !cmd_line.append(L"=\"") ||
-          !cmd_line.append(setup_dest_path.get()) ||
+      if (!cmd_line.append(exe_path.get()) || !cmd_line.append(L" --") ||
+          !cmd_line.append(kCmdUpdateSetupExe) || !cmd_line.append(L"=\"") ||
+          !cmd_line.append(context->setup_resource_path->get()) ||
+          !cmd_line.append(L"\" --") || !cmd_line.append(kCmdNewSetupExe) ||
+          !cmd_line.append(L"=\"") || !cmd_line.append(setup_dest_path.get()) ||
           !cmd_line.append(L"\"")) {
         exit_code = ProcessExitResult(COMMAND_STRING_OVERFLOW);
       }
     }
 
     // Get any command line option specified for mini_installer and pass them
     // on to setup.exe.
     AppendCommandLineFlags(configuration.command_line(), &cmd_line);
 
     if (exit_code.IsSuccess())
       exit_code = RunProcessAndWait(exe_path.get(), cmd_line.get());
 
     if (!exit_code.IsSuccess())
-      DeleteFile(setup_path->get());
-    else if (!setup_path->assign(setup_dest_path.get()))
+      DeleteFile(context->setup_resource_path->get());
+    else if (!context->setup_resource_path->assign(setup_dest_path.get()))
       exit_code = ProcessExitResult(PATH_STRING_OVERFLOW);
 
     return exit_code;
   }
 
   // setup.exe wasn't sent as 'B7', lets see if it was sent as 'BL'
   // (compressed setup).
   if (!::EnumResourceNames(module, kLZCResourceType, OnResourceFound,
-                           reinterpret_cast<LONG_PTR>(&context))) {
+                           reinterpret_cast<LONG_PTR>(context))) {
     return ProcessExitResult(UNABLE_TO_EXTRACT_SETUP_BL, ::GetLastError());
   }
-  if (setup_path->length() == 0) {
+  if (context->setup_resource_path->length() == 0) {
     // Neither setup_patch.packed.7z nor setup.ex_ was found.
     return ProcessExitResult(UNABLE_TO_EXTRACT_SETUP);
   }
 
   // Uncompress LZ compressed resource. Setup is packed with 'MSCF'
   // as opposed to old DOS way of 'SZDD'. Hence we don't use LZCopy.
-  bool success =
-      mini_installer::Expand(setup_path->get(), setup_dest_path.get());
-  ::DeleteFile(setup_path->get());
+  bool success = mini_installer::Expand(context->setup_resource_path->get(),
+                                        setup_dest_path.get());
+  ::DeleteFile(context->setup_resource_path->get());
   if (success) {
-    if (!setup_path->assign(setup_dest_path.get())) {
+    if (!context->setup_resource_path->assign(setup_dest_path.get())) {
       ::DeleteFile(setup_dest_path.get());
       exit_code = ProcessExitResult(PATH_STRING_OVERFLOW);
     }
   } else {
     exit_code = ProcessExitResult(UNABLE_TO_EXTRACT_SETUP_EXE);
   }
 
+#if defined(SYZYASAN)
+  PathString syzyasan_dest_path;
+  if (!syzyasan_dest_path.assign(context->base_path) ||
+      !syzyasan_dest_path.append(L"syzyasan_rtl.dll")) {
+    return ProcessExitResult(PATH_STRING_OVERFLOW);
+  }
+  success = mini_installer::Expand(context->syzyasan_resource_path->get(),

[Sébastien Marchand, 2017/04/05 21:07:02]

This probably could be moved into a function, not sure if it's worth it?

+                                   syzyasan_dest_path.get());
+  ::DeleteFile(context->syzyasan_resource_path->get());
+  if (success) {
+    if (!context->syzyasan_resource_path->assign(syzyasan_dest_path.get())) {
+      ::DeleteFile(syzyasan_dest_path.get());
+      exit_code = ProcessExitResult(PATH_STRING_OVERFLOW);
+    }
+  } else {
+    // TODO(sebmarchand): Add a new exit code for syzyasan_rtl.dll?
+    exit_code = ProcessExitResult(UNABLE_TO_EXTRACT_SETUP_EXE);
+  }
+#endif
+
 #if defined(COMPONENT_BUILD)
   if (exit_code.IsSuccess()) {
     // Extract the (uncompressed) modules required by setup.exe.
     if (!::EnumResourceNames(module, kBinResourceType, WriteResourceToDirectory,
                              reinterpret_cast<LONG_PTR>(base_path))) {
       return ProcessExitResult(UNABLE_TO_EXTRACT_SETUP, ::GetLastError());
     }
   }
 #endif
 
@@ skipping 398 matching lines @@
   // Set the magic suffix in registry to try full installer next time. We ignore
   // any errors here and we try to set the suffix for user level unless
   // GoogleUpdateIsMachine=1 is present in the environment or --system-level is
   // on the command line in which case we set it for system level instead. This
   // only applies to the Google Chrome distribution.
   SetInstallerFlags(configuration);
 #endif
 
   PathString archive_path;
   PathString setup_path;
-  exit_code = UnpackBinaryResources(configuration, module, base_path.get(),
-                                    &archive_path, &setup_path);
+#if defined(SYZYASAN)
+  PathString syzyasan_rtl_path;
+#endif
+  Context context = {
+    base_path.get(),
+    &archive_path,
+    &setup_path,
+#if defined(SYZYASAN)
+    &syzyasan_rtl_path,
+#endif
+  };
+  exit_code = UnpackBinaryResources(configuration, module, &context);
 
   // While unpacking the binaries, we paged in a whole bunch of memory that
   // we don't need anymore.  Let's give it back to the pool before running
   // setup.
   ::SetProcessWorkingSetSize(::GetCurrentProcess(), (SIZE_T)-1, (SIZE_T)-1);
 
   if (exit_code.IsSuccess())
     exit_code = RunSetup(configuration, archive_path.get(), setup_path.get());
 
   if (ShouldDeleteExtractedFiles())
     DeleteExtractedFiles(base_path.get(), archive_path.get(), setup_path.get());
 
 #if defined(GOOGLE_CHROME_BUILD)
   WriteInstallResults(configuration, exit_code);
 #endif
 
   return exit_code;
 }
 
 }  // namespace mini_installer