[PPAPI] Quarantine files that are writeable by a Pepper plugin.

content/common/quarantine/quarantine_win.cc

 // Copyright 2016 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.
 
-#include "content/browser/download/quarantine.h"
+#include "content/public/common/quarantine.h"
 
 #include <windows.h>
 
 #include <cguid.h>
 #include <objbase.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <shobjidl.h>
 #include <wininet.h>
 
+#include <vector>
+
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "url/gurl.h"
 
 namespace content {
 namespace {
 
 // [MS-FSCC] Section 5.6.1
@@ skipping 27 matching lines @@
   base::FilePath::StringType zone_identifier_path =
       path.value() + kZoneIdentifierStreamSuffix;
   base::win::ScopedHandle file(
       CreateFile(zone_identifier_path.c_str(), GENERIC_READ, kShare, nullptr,
                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
   if (!file.IsValid())
     return false;
 
   // The zone identifier contents is expected to be:
   // "[ZoneTransfer]\r\nZoneId=3\r\n". The actual ZoneId can be different. A
-  // buffer of 16 bytes is sufficient for testing whether the contents start
-  // with "[ZoneTransfer]".
-  std::vector<char> zone_identifier_contents(16);
+  // buffer of 32 bytes is sufficient for verifying the contents.
+  std::vector<char> zone_identifier_contents_buffer(32);
   DWORD actual_length = 0;
-  if (!ReadFile(file.Get(), &zone_identifier_contents.front(),
-                zone_identifier_contents.size(), &actual_length, NULL))
+  if (!ReadFile(file.Get(), &zone_identifier_contents_buffer.front(),
+                zone_identifier_contents_buffer.size(), &actual_length, NULL))
     return false;
-  base::StringPiece zone_identifier_string(&zone_identifier_contents.front(),
-                                           actual_length);
-  return zone_identifier_string.find("[ZoneTransfer]") == 0;
+  zone_identifier_contents_buffer.resize(actual_length);
+
+  std::string zone_identifier_contents(zone_identifier_contents_buffer.begin(),
+                                       zone_identifier_contents_buffer.end());
+
+  std::vector<std::string> lines =
+      base::SplitString(zone_identifier_contents, "\n", base::TRIM_WHITESPACE,

[brettw, 2016/12/06 22:48:42]

I think you could use SplitStringPiece here instead since nothing needs to
outlive the input. This will prevent a bunch of string allocs.

[asanka, 2016/12/08 15:13:29]

Done.

+                        base::SPLIT_WANT_NONEMPTY);
+  return lines.size() == 2 && lines[0] == "[ZoneTransfer]" &&
+         lines[1].find("ZoneId=") == 0;
 }
 
 void RecordAttachmentServicesSaveResult(const base::FilePath& file,
                                         HRESULT hr) {
   bool file_exists = base::PathExists(file);
   switch (hr) {
     case INET_E_SECURITY_PROBLEM:
       RecordAttachmentServicesResult(
           file_exists ? AttachmentServicesResult::BLOCKED_WITH_FILE
                       : AttachmentServicesResult::BLOCKED_WITHOUT_FILE);
@@ skipping 236 matching lines @@
   // if it was found to be infected.
   //
   // If the file is still there, then the error could be due to Windows
   // Attachment Services not being available or some other error during the AES
   // invocation. In either case, we don't surface the error to the user.
   if (!base::PathExists(file))
     return FailedSaveResultToQuarantineResult(save_result);
   return QuarantineFileResult::OK;
 }
 
+bool IsFileQuarantined(const base::FilePath& file,
+                       const GURL& source_url,
+                       const GURL& referrer_url) {
+  return ZoneIdentifierPresentForFile(file);
+}
+
 }  // namespace content