[VM, Precompiler] PoC Obfuscator

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 7435 matching lines @@
   ICData& ic_data = ICData::Handle();
   for (intptr_t i = 1; i < array.Length(); i++) {
     ic_data ^= array.At(i);
     if (ic_data.deopt_id() == deopt_id) {
       ic_data.AddDeoptReason(reason);
     }
   }
 }
 
 bool Function::CheckSourceFingerprint(const char* prefix, int32_t fp) const {
+  /*

[rmacnak, 2017/08/23 01:16:50]

if (Isolate::Current()->flags->obfuscate) return;

[Vyacheslav Egorov (Google), 2017/08/23 15:54:52]

Done.

   if ((kernel_offset() <= 0) && (SourceFingerprint() != fp)) {
     const bool recalculatingFingerprints = false;
     if (recalculatingFingerprints) {
       // This output can be copied into a file, then used with sed
       // to replace the old values.
       // sed -i.bak -f /tmp/newkeys runtime/vm/method_recognizer.h
       THR_Print("s/0x%08x/0x%08x/\n", fp, SourceFingerprint());
     } else {
       THR_Print(
           "FP mismatch while recognizing method %s:"
           " expecting 0x%08x found 0x%08x\n",
           ToFullyQualifiedCString(), fp, SourceFingerprint());
       return false;
     }
-  }
+  }*/
   return true;
 }
 
 RawCode* Function::EnsureHasCode() const {
   if (HasCode()) return CurrentCode();
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const Object& result =
       Object::Handle(zone, Compiler::CompileFunction(thread, *this));
   if (result.IsError()) {
@@ skipping 1168 matching lines @@
 };
 typedef UnorderedHashMap<CompressedTokenTraits> CompressedTokenMap;
 
 // Helper class for creation of compressed token stream data.
 class CompressedTokenStreamData : public Scanner::TokenCollector {
  public:
   static const intptr_t kInitialBufferSize = 16 * KB;
   static const bool kPrintTokenObjects = false;
 
   CompressedTokenStreamData(const GrowableObjectArray& ta,
-                            CompressedTokenMap* map)
+                            CompressedTokenMap* map,
+                            Obfuscator* obfuscator)
       : buffer_(NULL),
         stream_(&buffer_, Reallocate, kInitialBufferSize),
         token_objects_(ta),
         tokens_(map),
+        str_(String::Handle()),
         value_(Object::Handle()),
         fresh_index_smi_(Smi::Handle()),
-        num_tokens_collected_(0) {}
+        num_tokens_collected_(0),
+        obfuscator_(obfuscator) {}
   virtual ~CompressedTokenStreamData() {}
 
   virtual void AddToken(const Scanner::TokenDescriptor& token) {
     if (token.kind == Token::kIDENT) {  // Identifier token.
       AddIdentToken(*token.literal);
+    } else if (token.kind == Token::kINTERPOL_VAR) {
+      str_ = token.literal->raw();
+      str_ = obfuscator_->Rename(str_);
+
+      Scanner::TokenDescriptor token_copy = token;
+      token_copy.literal = &str_;
+      AddLiteralToken(token_copy);
     } else if (Token::NeedsLiteralToken(token.kind)) {  // Literal token.
       AddLiteralToken(token);
     } else {  // Keyword, pseudo keyword etc.
       ASSERT(token.kind < Token::kNumTokens);
       AddSimpleToken(token.kind);
     }
     num_tokens_collected_++;
   }
 
   // Return the compressed token stream.
   uint8_t* GetStream() const { return buffer_; }
 
   // Return the compressed token stream length.
   intptr_t Length() const { return stream_.bytes_written(); }
 
   intptr_t NumTokens() const { return num_tokens_collected_; }
 
  private:
   // Add an IDENT token into the stream and the token hash map.
   void AddIdentToken(const String& ident) {
     ASSERT(ident.IsSymbol());
     const intptr_t fresh_index = token_objects_.Length();
+    str_ = ident.raw();
+    str_ = obfuscator_->Rename(str_);
     fresh_index_smi_ = Smi::New(fresh_index);
     intptr_t index = Smi::Value(
         Smi::RawCast(tokens_->InsertOrGetValue(ident, fresh_index_smi_)));
     if (index == fresh_index) {
-      token_objects_.Add(ident);
+      token_objects_.Add(str_);
       if (kPrintTokenObjects) {
         int iid = Isolate::Current()->main_port() % 1024;
-        OS::Print("ident  %03x  %p <%s>\n", iid, ident.raw(),
-                  ident.ToCString());
+        OS::Print("%03x ident <%s -> %s>\n", iid, ident.ToCString(),
+                  str_.ToCString());
       }
     }
     WriteIndex(index);
   }
 
   // Add a LITERAL token into the stream and the token hash map.
   void AddLiteralToken(const Scanner::TokenDescriptor& descriptor) {
     ASSERT(descriptor.literal->IsSymbol());
     bool is_present = false;
     value_ = tokens_->GetOrNull(descriptor, &is_present);
@@ skipping 42 matching lines @@
                              intptr_t old_size,
                              intptr_t new_size) {
     void* new_ptr = ::realloc(reinterpret_cast<void*>(ptr), new_size);
     return reinterpret_cast<uint8_t*>(new_ptr);
   }
 
   uint8_t* buffer_;
   WriteStream stream_;
   const GrowableObjectArray& token_objects_;
   CompressedTokenMap* tokens_;
+  String& str_;
   Object& value_;
   Smi& fresh_index_smi_;
   intptr_t num_tokens_collected_;
+  Obfuscator* obfuscator_;
 
   DISALLOW_COPY_AND_ASSIGN(CompressedTokenStreamData);
 };
 
 RawTokenStream* TokenStream::New(const String& source,
                                  const String& private_key,
                                  bool use_shared_tokens) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
   GrowableObjectArray& token_objects = GrowableObjectArray::Handle(zone);
   Array& token_objects_map = Array::Handle(zone);
   if (use_shared_tokens) {
     // Use the shared token objects array in the object store. Allocate
     // a new array if necessary.
     ObjectStore* store = thread->isolate()->object_store();
     if (store->token_objects() == GrowableObjectArray::null()) {
       OpenSharedTokenList(thread->isolate());
     }
     token_objects = store->token_objects();
     token_objects_map = store->token_objects_map();
   } else {
     // Use new, non-shared token array.
     const int kInitialPrivateCapacity = 256;
     token_objects =
         GrowableObjectArray::New(kInitialPrivateCapacity, Heap::kOld);
     token_objects_map = HashTables::New<CompressedTokenMap>(
         kInitialPrivateCapacity, Heap::kOld);
   }
+  Obfuscator obfuscator(thread, private_key);
   CompressedTokenMap map(token_objects_map.raw());
-  CompressedTokenStreamData data(token_objects, &map);
+  CompressedTokenStreamData data(token_objects, &map, &obfuscator);
   Scanner scanner(source, private_key);
   scanner.ScanAll(&data);
   INC_STAT(thread, num_tokens_scanned, data.NumTokens());
 
   // Create and setup the token stream object.
   const ExternalTypedData& stream = ExternalTypedData::Handle(
       zone,
       ExternalTypedData::New(kExternalTypedDataUint8ArrayCid, data.GetStream(),
                              data.Length(), Heap::kOld));
   intptr_t external_size = data.Length();
@@ skipping 420 matching lines @@
     return;
   }
 
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const TokenStream& tkns = TokenStream::Handle(zone, tokens());
   if (!tkns.IsNull()) {
     // Already tokenized.
     return;
   }
+
   // Get the source, scan and allocate the token stream.
   VMTagScope tagScope(thread, VMTag::kCompileScannerTagId);
   CSTAT_TIMER_SCOPE(thread, scanner_timer);
   const String& src = String::Handle(zone, Source());
   const TokenStream& ts = TokenStream::Handle(
       zone, TokenStream::New(src, private_key, use_shared_tokens));
   set_tokens(ts);
   INC_STAT(thread, src_length, src.Length());
 }
 
@@ skipping 13190 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart