Do not hash default and communications media device ID

content/browser/renderer_host/media/media_stream_manager.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 "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <cctype>
 #include <list>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/media/capture/web_contents_capture_util.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/audio_output_device_enumerator.h"
 #include "content/browser/renderer_host/media/media_capture_devices_impl.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/media_device_id.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/media_request_state.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/media_stream_request.h"
+#include "crypto/hmac.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/channel_layout.h"
 #include "media/base/media_switches.h"
 #include "media/capture/video/video_capture_device_factory.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
@@ skipping 827 matching lines @@
 
   const EnumerationCache* cache =
       stream_type == MEDIA_DEVICE_AUDIO_CAPTURE ?
       &audio_enumeration_cache_ : &video_enumeration_cache_;
 
   // If device monitoring hasn't started, the |device_guid| is not valid.
   if (!cache->valid)
     return false;
 
   for (const StreamDeviceInfo& device_info : cache->devices) {
-    if (content::DoesMediaDeviceIDMatchHMAC(sc, security_origin, source_id,
-                                            device_info.device.id)) {
+    if (DoesMediaDeviceIDMatchHMAC(sc, security_origin, source_id,
+                                   device_info.device.id)) {
       *device_id = device_info.device.id;
       return true;
     }
   }
   return false;
 }
 
 void MediaStreamManager::EnsureDeviceMonitorStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   StartMonitoring();
@@ skipping 20 matching lines @@
       StopRemovedDevice(old_device_info.device);
     }
   }
 }
 
 void MediaStreamManager::StopRemovedDevice(const MediaStreamDevice& device) {
   std::vector<int> session_ids;
   for (const LabeledDeviceRequest& labeled_request : requests_) {
     const DeviceRequest* request = labeled_request.second;
     for (const StreamDeviceInfo& device_info : request->devices) {
-      const std::string source_id = content::GetHMACForMediaDeviceID(
+      const std::string source_id = GetHMACForMediaDeviceID(
           request->salt_callback, request->security_origin, device.id);
       if (device_info.device.id == source_id &&
           device_info.device.type == device.type) {
         session_ids.push_back(device_info.session_id);
         if (labeled_request.second->requester) {
           labeled_request.second->requester->DeviceStopped(
               labeled_request.second->requesting_frame_id,
               labeled_request.first, device_info);
         }
       }
@@ skipping 132 matching lines @@
   }
   return true;
 }
 
 void MediaStreamManager::TranslateDeviceIdToSourceId(
     DeviceRequest* request,
     MediaStreamDevice* device) {
   if (request->audio_type() == MEDIA_DEVICE_AUDIO_CAPTURE ||
       request->audio_type() == MEDIA_DEVICE_AUDIO_OUTPUT ||
       request->video_type() == MEDIA_DEVICE_VIDEO_CAPTURE) {
-    device->id = content::GetHMACForMediaDeviceID(
-        request->salt_callback,
-        request->security_origin,
-        device->id);
+    device->id = GetHMACForMediaDeviceID(request->salt_callback,
+                                         request->security_origin, device->id);
   }
 }
 
 void MediaStreamManager::ClearEnumerationCache(EnumerationCache* cache) {
   DCHECK(CalledOnIOThread());
   cache->valid = false;
 }
 
 bool MediaStreamManager::EnumerationRequired(EnumerationCache* cache,
                                              MediaStreamType stream_type) {
@@ skipping 317 matching lines @@
 }
 
 bool MediaStreamManager::FindExistingRequestedDeviceInfo(
     const DeviceRequest& new_request,
     const MediaStreamDevice& new_device_info,
     StreamDeviceInfo* existing_device_info,
     MediaRequestState* existing_request_state) const {
   DCHECK(existing_device_info);
   DCHECK(existing_request_state);
 
-  std::string source_id = content::GetHMACForMediaDeviceID(
-      new_request.salt_callback,
-      new_request.security_origin,
-      new_device_info.id);
+  std::string source_id =
+      GetHMACForMediaDeviceID(new_request.salt_callback,
+                              new_request.security_origin, new_device_info.id);
 
   for (const LabeledDeviceRequest& labeled_request : requests_) {
     const DeviceRequest* request = labeled_request.second;
     if (request->requesting_process_id == new_request.requesting_process_id &&
         request->requesting_frame_id == new_request.requesting_frame_id &&
         request->request_type == new_request.request_type) {
       for (const StreamDeviceInfo& device_info : request->devices) {
         if (device_info.device.id == source_id &&
             device_info.device.type == new_device_info.type) {
           *existing_device_info = device_info;
@@ skipping 691 matching lines @@
                    base::Unretained(this)));
   }
 }
 
 void MediaStreamManager::SetKeyboardMicOnDeviceThread() {
   DCHECK(device_task_runner_->BelongsToCurrentThread());
   audio_manager_->SetHasKeyboardMic();
 }
 #endif
 
+// static
+std::string MediaStreamManager::GetHMACForMediaDeviceID(
+    const ResourceContext::SaltCallback& sc,
+    const GURL& security_origin,
+    const std::string& raw_unique_id) {
+  DCHECK(security_origin.is_valid());
+  DCHECK(!raw_unique_id.empty());
+  if (raw_unique_id == media::AudioManagerBase::kDefaultDeviceId ||
+      raw_unique_id == media::AudioManagerBase::kCommunicationsDeviceId) {
+    return raw_unique_id;
+  }
+
+  crypto::HMAC hmac(crypto::HMAC::SHA256);
+  const size_t digest_length = hmac.DigestLength();
+  std::vector<uint8> digest(digest_length);
+  std::string salt = sc.Run();
+  bool result = hmac.Init(security_origin.spec()) &&
+                hmac.Sign(raw_unique_id + salt, &digest[0], digest.size());
+  DCHECK(result);
+  return base::ToLowerASCII(base::HexEncode(&digest[0], digest.size()));
+}
+
+// static
+bool MediaStreamManager::DoesMediaDeviceIDMatchHMAC(
+    const ResourceContext::SaltCallback& sc,
+    const GURL& security_origin,
+    const std::string& device_guid,
+    const std::string& raw_unique_id) {
+  DCHECK(security_origin.is_valid());
+  DCHECK(!raw_unique_id.empty());
+  std::string guid_from_raw_device_id =
+      GetHMACForMediaDeviceID(sc, security_origin, raw_unique_id);
+  return guid_from_raw_device_id == device_guid;
+}
+
 }  // namespace content