[VM, Precompiler] PoC Obfuscator

runtime/vm/parser.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 "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 10 matching lines @@
 #include "vm/hash_table.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/kernel_binary_flowgraph.h"
 #include "vm/longjump.h"
 #include "vm/native_arguments.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
+#include "vm/precompiler.h"
 #include "vm/regexp_assembler.h"
 #include "vm/resolver.h"
 #include "vm/safepoint.h"
 #include "vm/scanner.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/timeline.h"
 #include "vm/timer.h"
@@ skipping 6225 matching lines @@
       ExpectToken(Token::kLPAREN);
       // Parse dotted name.
       const GrowableObjectArray& pieces = GrowableObjectArray::Handle(
           Z, GrowableObjectArray::New(allocation_space_));
       pieces.Add(*ExpectIdentifier("identifier expected"), allocation_space_);
       while (CurrentToken() == Token::kPERIOD) {
         pieces.Add(Symbols::Dot(), allocation_space_);
         ConsumeToken();
         pieces.Add(*ExpectIdentifier("identifier expected"), allocation_space_);
       }
+      if (I->obfuscate()) {
+        // If we are obfuscating then we need to deobfuscate environment name.
+        Obfuscator::Deobfuscate(T, pieces);
+      }
       AstNode* valueNode = NULL;
       if (CurrentToken() == Token::kEQ) {
         ConsumeToken();
         CheckToken(Token::kSTRING, "string literal expected");
         valueNode = ParseStringLiteral(false);
         ASSERT(valueNode->IsLiteralNode());
         ASSERT(valueNode->AsLiteralNode()->literal().IsString());
       }
       ExpectToken(Token::kRPAREN);
       CheckToken(Token::kSTRING, "library url expected");
@@ skipping 6358 matching lines @@
     return NULL;
   }
   ASSERT(getter.kind() == RawFunction::kImplicitGetter);
   return new (Z) StaticGetterNode(field_ref_pos, NULL, field_owner, field_name);
 }
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
-    ArgumentListNode* arguments) {
+    ArgumentListNode* arguments,
+    bool obfuscate_symbol_instances /* = true */) {
   NoReloadScope no_reload_scope(isolate(), thread());
   NoOOBMessageScope no_msg_scope(thread());
   // Factories and constructors are not generic functions.
   const int kTypeArgsLen = 0;
   // Factories have one extra argument: the type arguments.
   // Constructors have one extra arguments: receiver.
   const int kNumExtraArgs = 1;
   const int num_arguments = arguments->length() + kNumExtraArgs;
   const Array& arg_values =
       Array::Handle(Z, Array::New(num_arguments, allocation_space_));
@@ skipping 34 matching lines @@
     } else {
       thread()->long_jump_base()->Jump(1, Error::Cast(result));
       UNREACHABLE();
       return Object::null();
     }
   } else {
     if (constructor.IsFactory()) {
       // The factory method returns the allocated object.
       instance ^= result.raw();
     }
+    if (obfuscate_symbol_instances && I->obfuscate() &&
+        (instance.clazz() == I->object_store()->symbol_class())) {
+      Obfuscator::ObfuscateSymbolInstance(T, instance);
+    }
     return TryCanonicalize(instance, TokenPos());
   }
 }
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(TokenPosition ident_pos,
                                       const String& ident,
                                       AstNode** node,
@@ skipping 1042 matching lines @@
   }
 
   // Call Symbol class constructor to create a symbol instance.
   const Class& symbol_class = Class::Handle(I->object_store()->symbol_class());
   ASSERT(!symbol_class.IsNull());
   ArgumentListNode* constr_args = new (Z) ArgumentListNode(symbol_pos);
   constr_args->Add(new (Z) LiteralNode(symbol_pos, symbol));
   const Function& constr = Function::ZoneHandle(
       Z, symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!constr.IsNull());
-  const Object& result = Object::Handle(
-      Z, EvaluateConstConstructorCall(symbol_class, TypeArguments::Handle(Z),
-                                      constr, constr_args));
+  const Object& result =
+      Object::Handle(Z, EvaluateConstConstructorCall(
+                            symbol_class, TypeArguments::Handle(Z), constr,
+                            constr_args, /*obfuscate_symbol_instances=*/false));
   if (result.IsUnhandledException()) {
     ReportErrors(Error::Cast(result), script_, symbol_pos,
                  "error executing const Symbol constructor");
   }
   symbol_instance ^= result.raw();
   CacheConstantValue(symbol_pos, symbol_instance);
   return new (Z) LiteralNode(symbol_pos, symbol_instance);
 }
 
 RawFunction* Parser::BuildConstructorClosureFunction(const Function& ctr,
@@ skipping 1318 matching lines @@
 bool Parser::FieldHasFunctionLiteralInitializer(const Field& field,
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME