Make net::DataURL's MIME string check stricter

net/base/mime_util.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.
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/mime_util.h"
 #include "net/base/platform_mime_util.h"
+#include "net/http/http_util.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 using std::string;
 
 namespace {
 
 struct MediaType {
@@ skipping 33 matching lines @@
   bool IsSupportedMediaMimeType(const std::string& mime_type) const;
   bool IsSupportedNonImageMimeType(const std::string& mime_type) const;
   bool IsUnsupportedTextMimeType(const std::string& mime_type) const;
   bool IsSupportedJavascriptMimeType(const std::string& mime_type) const;
 
   bool IsSupportedMimeType(const std::string& mime_type) const;
 
   bool MatchesMimeType(const std::string &mime_type_pattern,
                        const std::string &mime_type) const;
 
-  bool IsMimeType(const std::string& type_string) const;
+  bool ParseMimeTypeWithoutParameter(const std::string& type_string,
+                                     std::string* top_level_type,
+                                     std::string* subtype) const;
+
+  bool IsValidTopLevelMimeType(const std::string& type_string) const;
 
   bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) const;
 
   void ParseCodecString(const std::string& codecs,
                         std::vector<std::string>* codecs_out,
                         bool strip);
 
   bool IsStrictMediaMimeType(const std::string& mime_type) const;
   bool IsSupportedStrictMediaMimeType(
       const std::string& mime_type,
@@ skipping 534 matching lines @@
   if (base_type.find(left) != 0)
     return false;
 
   if (!right.empty() &&
       base_type.rfind(right) != base_type.length() - right.length())
     return false;
 
   return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
 }
 
-// See http://www.iana.org/assignments/media-types/index.html
+// See http://www.iana.org/assignments/media-types/media-types.xhtml
 static const char* legal_top_level_types[] = {
-  "application/",
-  "audio/",
-  "example/",
-  "image/",
-  "message/",
-  "model/",
-  "multipart/",
-  "text/",
-  "video/",
+  "application",
+  "audio",
+  "example",
+  "image",
+  "message",
+  "model",
+  "multipart",
+  "text",
+  "video",
 };
 
-bool MimeUtil::IsMimeType(const std::string& type_string) const {
-  // MIME types are always ASCII and case-insensitive (at least, the top-level
-  // and secondary types we care about).
-  if (!IsStringASCII(type_string))
+bool MimeUtil::ParseMimeTypeWithoutParameter(
+    const std::string& type_string,
+    std::string* top_level_type,
+    std::string* subtype) const {
+  std::vector<std::string> components;
+  base::SplitString(type_string, '/', &components);
+  if (components.size() != 2 ||
+      !HttpUtil::IsToken(components[0]) ||
+      !HttpUtil::IsToken(components[1]))
     return false;
 
-  if (type_string == "*/*" || type_string == "*")
-    return true;
+  if (top_level_type)
+    *top_level_type = components[0];
+  if (subtype)
+    *subtype = components[1];
+  return true;
+}
 
+bool MimeUtil::IsValidTopLevelMimeType(const std::string& type_string) const {
+  std::string lower_type = StringToLowerASCII(type_string);
   for (size_t i = 0; i < arraysize(legal_top_level_types); ++i) {
-    if (StartsWithASCII(type_string, legal_top_level_types[i], false) &&
-        type_string.length() > strlen(legal_top_level_types[i])) {
+    if (lower_type.compare(legal_top_level_types[i]) == 0)
       return true;
-    }
   }
 
-  // If there's a "/" separator character, and the token before it is
-  // "x-" + (ascii characters), it is also a MIME type.
-  size_t slash = type_string.find('/');
-  if (slash < 3 ||
-      slash == std::string::npos || slash == type_string.length() - 1) {
-    return false;
-  }
-
-  if (StartsWithASCII(type_string, "x-", false))
-    return true;
-
-  return false;
+  return type_string.size() > 2 && StartsWithASCII(type_string, "x-", false);
 }
 
 bool MimeUtil::AreSupportedMediaCodecs(
     const std::vector<std::string>& codecs) const {
   return AreSupportedCodecs(codecs_map_, codecs);
 }
 
 void MimeUtil::ParseCodecString(const std::string& codecs,
                                 std::vector<std::string>* codecs_out,
                                 bool strip) {
@@ skipping 84 matching lines @@
 
 bool IsSupportedMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsSupportedMimeType(mime_type);
 }
 
 bool MatchesMimeType(const std::string& mime_type_pattern,
                      const std::string& mime_type) {
   return g_mime_util.Get().MatchesMimeType(mime_type_pattern, mime_type);
 }
 
-bool IsMimeType(const std::string& type_string) {
-  return g_mime_util.Get().IsMimeType(type_string);
+bool ParseMimeTypeWithoutParameter(const std::string& type_string,
+                                   std::string* top_level_type,
+                                   std::string* subtype) {
+  return g_mime_util.Get().ParseMimeTypeWithoutParameter(
+      type_string, top_level_type, subtype);
+}
+
+bool IsValidTopLevelMimeType(const std::string& type_string) {
+  return g_mime_util.Get().IsValidTopLevelMimeType(type_string);
 }
 
 bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) {
   return g_mime_util.Get().AreSupportedMediaCodecs(codecs);
 }
 
 bool IsStrictMediaMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsStrictMediaMimeType(mime_type);
 }
 
@@ skipping 240 matching lines @@
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net