[VM, Precompiler] PoC Obfuscator

runtime/bin/main.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 105 matching lines @@
 
 // Global flag that is used to indicate that we want to compile all the
 // dart functions and not run anything.
 static bool compile_all = false;
 static bool parse_all = false;
 
 // Global flag that is used to indicate that we want to use blobs/mmap instead
 // of assembly/shared libraries for precompilation.
 static bool use_blobs = false;
 
+// Global flag is used to indicate that we want to obfuscate identifiers.
+static bool obfuscate = false;

[rmacnak, 2017/08/24 01:00:27]

Flutter will want these options on gen_snapshot.

[Vyacheslav Egorov (Google), 2017/08/24 14:27:19]

I have added these options to the gen_snapshot. I also refactored options
parsing in gen_snapshot to avoid duplicating tons of code when we add a single
new option.

+
+// Value of the --save-obfuscation-map= flag.
+static const char* obfuscation_map_filename = NULL;
+
 // Global flag that is used to indicate that we want to trace resolution of
 // URIs and the loading of libraries, parts and scripts.
 static bool trace_loading = false;
 
 static char* app_script_uri = NULL;
 static const uint8_t* app_isolate_snapshot_data = NULL;
 static const uint8_t* app_isolate_snapshot_instructions = NULL;
 
 static Dart_Isolate main_isolate = NULL;
 
@@ skipping 235 matching lines @@
 static bool ProcessUseBlobsOption(const char* arg,
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   use_blobs = true;
   return true;
 }
 
+static bool ProcessObfuscateOption(const char* arg,
+                                   CommandLineOptions* vm_options) {
+  ASSERT(arg != NULL);
+  if (*arg != '\0') {
+    return false;
+  }
+  obfuscate = true;
+  return true;
+}
+
+static bool ProcessObfuscationMapFilenameOption(
+    const char* filename,
+    CommandLineOptions* vm_options) {
+  obfuscation_map_filename = filename;
+  return true;
+}
+
 static bool ProcessSnapshotFilenameOption(const char* filename,
                                           CommandLineOptions* vm_options) {
   snapshot_filename = filename;
   if (gen_snapshot_kind == kNone) {
     gen_snapshot_kind = kScript;  // Default behavior.
   }
   return true;
 }
 
 static bool ProcessSnapshotKindOption(const char* kind,
@@ skipping 189 matching lines @@
     {"--dfe=", ProcessFrontendOption},
     {"--kernel-binaries=", ProcessKernelBinariesOption},
 #endif
     {"--enable-vm-service", ProcessEnableVmServiceOption},
     {"--disable-service-origin-check", ProcessDisableServiceOriginCheckOption},
     {"--observe", ProcessObserveOption},
     {"--snapshot=", ProcessSnapshotFilenameOption},
     {"--snapshot-kind=", ProcessSnapshotKindOption},
     {"--snapshot-depfile=", ProcessSnapshotDepsFilenameOption},
     {"--use-blobs", ProcessUseBlobsOption},
+    {"--obfuscate", ProcessObfuscateOption},
+    {"--save-obfuscation-map=", ProcessObfuscationMapFilenameOption},
     {"--save-compilation-trace=", ProcessSaveCompilationTraceOption},
     {"--load-compilation-trace=", ProcessLoadCompilationTraceOption},
     {"--save-feedback=", ProcessSaveFeedbackOption},
     {"--load-feedback=", ProcessLoadFeedbackOption},
     {"--trace-loading", ProcessTraceLoadingOption},
     {"--hot-reload-test-mode", ProcessHotReloadTestModeOption},
     {"--hot-reload-rollback-test-mode", ProcessHotReloadRollbackTestModeOption},
     {"--short_socket_read", ProcessShortSocketReadOption},
     {"--short_socket_write", ProcessShortSocketWriteOption},
     {"--root-certs-file=", ProcessRootCertsFileOption},
@@ skipping 807 matching lines @@
     ErrorExit(kErrorExitCode, "Unable to open file %s\n", filename);
   }
   *size = file->Length();
   *buffer = reinterpret_cast<uint8_t*>(malloc(*size));
   if (!file->ReadFully(*buffer, *size)) {
     ErrorExit(kErrorExitCode, "Unable to read file %s\n", filename);
   }
   file->Release();
 }
 
+static Dart_QualifiedFunctionName standalone_entry_points[] = {
+    // Functions.
+    {"dart:_builtin", "::", "_getPrintClosure"},
+    {"dart:_builtin", "::", "_getUriBaseClosure"},
+    {"dart:_builtin", "::", "_libraryFilePath"},
+    {"dart:_builtin", "::", "_resolveInWorkingDirectory"},
+    {"dart:_builtin", "::", "_setPackageRoot"},
+    {"dart:_builtin", "::", "_setPackagesMap"},
+    {"dart:_builtin", "::", "_setWorkingDirectory"},
+    {"dart:async", "::", "_setScheduleImmediateClosure"},
+    {"dart:io", "::", "_getWatchSignalInternal"},
+    {"dart:io", "::", "_makeDatagram"},
+    {"dart:io", "::", "_makeUint8ListView"},
+    {"dart:io", "::", "_setupHooks"},
+    {"dart:io", "CertificateException", "CertificateException."},
+    {"dart:io", "Directory", "Directory."},
+    {"dart:io", "File", "File."},
+    {"dart:io", "FileSystemException", "FileSystemException."},
+    {"dart:io", "HandshakeException", "HandshakeException."},
+    {"dart:io", "Link", "Link."},
+    {"dart:io", "OSError", "OSError."},
+    {"dart:io", "TlsException", "TlsException."},
+    {"dart:io", "X509Certificate", "X509Certificate._"},
+    {"dart:io", "_ExternalBuffer", "get:end"},
+    {"dart:io", "_ExternalBuffer", "get:start"},
+    {"dart:io", "_ExternalBuffer", "set:data"},
+    {"dart:io", "_ExternalBuffer", "set:end"},
+    {"dart:io", "_ExternalBuffer", "set:start"},
+    {"dart:io", "_Platform", "set:_nativeScript"},
+    {"dart:io", "_ProcessStartStatus", "set:_errorCode"},
+    {"dart:io", "_ProcessStartStatus", "set:_errorMessage"},
+    {"dart:io", "_SecureFilterImpl", "get:ENCRYPTED_SIZE"},
+    {"dart:io", "_SecureFilterImpl", "get:SIZE"},
+    {"dart:io", "_SecureFilterImpl", "get:buffers"},
+    {"dart:isolate", "::", "_getIsolateScheduleImmediateClosure"},
+    {"dart:isolate", "::", "_setupHooks"},
+    {"dart:isolate", "::", "_startMainIsolate"},
+    {"dart:vmservice_io", "::", "main"},
+    // Fields
+    {"dart:_builtin", "::", "_isolateId"},
+    {"dart:_builtin", "::", "_loadPort"},
+    {"dart:_internal", "::", "_printClosure"},
+    {"dart:vmservice_io", "::", "_autoStart"},
+    {"dart:vmservice_io", "::", "_ip"},
+    {"dart:vmservice_io", "::", "_isFuchsia"},
+    {"dart:vmservice_io", "::", "_isWindows"},
+    {"dart:vmservice_io", "::", "_originCheckDisabled"},
+    {"dart:vmservice_io", "::", "_port"},
+    {"dart:vmservice_io", "::", "_signalWatch"},
+    {"dart:vmservice_io", "::", "_traceLoading"},
+    {NULL, NULL, NULL}  // Must be terminated with NULL entries.
+};
+
 bool RunMainIsolate(const char* script_name, CommandLineOptions* dart_options) {
   // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
   char* error = NULL;
   bool is_main_isolate = true;
   int exit_code = 0;
   char* isolate_name = BuildIsolateName(script_name, "main");
+  Dart_IsolateFlags flags;
+  Dart_IsolateFlagsInitialize(&flags);
+
+  if (gen_snapshot_kind == kAppAOT) {
+    flags.obfuscate = obfuscate;
+    flags.entry_points = standalone_entry_points;
+  }
+
   Dart_Isolate isolate = CreateIsolateAndSetupHelper(
       is_main_isolate, script_name, "main", commandline_package_root,
-      commandline_packages_file, NULL, &error, &exit_code);
+      commandline_packages_file, &flags, &error, &exit_code);
   if (isolate == NULL) {
     delete[] isolate_name;
     Log::PrintErr("%s\n", error);
     free(error);
     error = NULL;
     Process::TerminateExitCodeHandler();
     error = Dart_Cleanup();
     if (error != NULL) {
       Log::PrintErr("VM cleanup failed: %s\n", error);
       free(error);
@@ skipping 53 matching lines @@
     if (parse_all) {
       result = Dart_ParseAll();
       CHECK_RESULT(result);
       Dart_ExitScope();
       // Shutdown the isolate.
       Dart_ShutdownIsolate();
       return false;
     }
 
     if (gen_snapshot_kind == kAppAOT) {
-      Dart_QualifiedFunctionName standalone_entry_points[] = {
-          {"dart:_builtin", "::", "_getPrintClosure"},
-          {"dart:_builtin", "::", "_getUriBaseClosure"},
-          {"dart:_builtin", "::", "_libraryFilePath"},
-          {"dart:_builtin", "::", "_resolveInWorkingDirectory"},
-          {"dart:_builtin", "::", "_setPackageRoot"},
-          {"dart:_builtin", "::", "_setPackagesMap"},
-          {"dart:_builtin", "::", "_setWorkingDirectory"},
-          {"dart:async", "::", "_setScheduleImmediateClosure"},
-          {"dart:io", "::", "_getWatchSignalInternal"},
-          {"dart:io", "::", "_makeDatagram"},
-          {"dart:io", "::", "_makeUint8ListView"},
-          {"dart:io", "::", "_setupHooks"},
-          {"dart:io", "CertificateException", "CertificateException."},
-          {"dart:io", "Directory", "Directory."},
-          {"dart:io", "File", "File."},
-          {"dart:io", "FileSystemException", "FileSystemException."},
-          {"dart:io", "HandshakeException", "HandshakeException."},
-          {"dart:io", "Link", "Link."},
-          {"dart:io", "OSError", "OSError."},
-          {"dart:io", "TlsException", "TlsException."},
-          {"dart:io", "X509Certificate", "X509Certificate._"},
-          {"dart:io", "_ExternalBuffer", "get:end"},
-          {"dart:io", "_ExternalBuffer", "get:start"},
-          {"dart:io", "_ExternalBuffer", "set:data"},
-          {"dart:io", "_ExternalBuffer", "set:end"},
-          {"dart:io", "_ExternalBuffer", "set:start"},
-          {"dart:io", "_Platform", "set:_nativeScript"},
-          {"dart:io", "_ProcessStartStatus", "set:_errorCode"},
-          {"dart:io", "_ProcessStartStatus", "set:_errorMessage"},
-          {"dart:io", "_SecureFilterImpl", "get:ENCRYPTED_SIZE"},
-          {"dart:io", "_SecureFilterImpl", "get:SIZE"},
-          {"dart:io", "_SecureFilterImpl", "get:buffers"},
-          {"dart:isolate", "::", "_getIsolateScheduleImmediateClosure"},
-          {"dart:isolate", "::", "_setupHooks"},
-          {"dart:isolate", "::", "_startMainIsolate"},
-          {"dart:vmservice_io", "::", "main"},
-          {NULL, NULL, NULL}  // Must be terminated with NULL entries.
-      };
-
       uint8_t* feedback_buffer = NULL;
       intptr_t feedback_length = 0;
       if (load_feedback_filename != NULL) {
         File* file = File::Open(load_feedback_filename, File::kRead);
         if (file == NULL) {
           ErrorExit(kErrorExitCode, "Failed to read JIT feedback.\n");
         }
         feedback_length = file->Length();
         feedback_buffer = reinterpret_cast<uint8_t*>(malloc(feedback_length));
         if (!file->ReadFully(feedback_buffer, feedback_length)) {
           ErrorExit(kErrorExitCode, "Failed to read JIT feedback.\n");
         }
         file->Release();
       }
 
       result = Dart_Precompile(standalone_entry_points, feedback_buffer,
                                feedback_length);
       if (feedback_buffer != NULL) {
         free(feedback_buffer);
       }
       CHECK_RESULT(result);
+
+      if (obfuscate && obfuscation_map_filename != NULL) {
+        uint8_t* buffer = NULL;
+        intptr_t size = 0;
+        result = Dart_GetObfuscationMap(&buffer, &size);
+        CHECK_RESULT(result);
+        WriteFile(obfuscation_map_filename, buffer, size);
+      }
     }
 
     if (gen_snapshot_kind == kAppAOT) {
       GenerateAppAOTSnapshot();
     } else {
       if (Dart_IsNull(root_lib)) {
         ErrorExit(kErrorExitCode, "Unable to find root library for '%s'\n",
                   script_name);
       }
 
@@ skipping 297 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }