Sign self-signed certs with SHA256.

content/browser/media/webrtc_identity_store.cc

 // Copyright 2013 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/media/webrtc_identity_store.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 21 matching lines @@
 };
 
 // Generates a new identity using |common_name| which expires after
 // |validity_period| and returns the result in |result|.
 static void GenerateIdentityWorker(const std::string& common_name,
                                    base::TimeDelta validity_period,
                                    WebRTCIdentityRequestResult* result) {
   result->error = net::OK;
   int serial_number = base::RandInt(0, std::numeric_limits<int>::max());
 
-  scoped_ptr<crypto::RSAPrivateKey> key(crypto::RSAPrivateKey::Create(1024));
-  if (!key.get()) {
-    DLOG(ERROR) << "Unable to create key pair for client";
-    result->error = net::ERR_KEY_GENERATION_FAILED;
-    return;
-  }
+  crypto::RSAPrivateKey* raw_key;
+  base::Time now = base::Time::Now();
+  bool success = net::x509_util::CreateKeyAndSelfSignedCert(
+      "CN=" + common_name,
+      serial_number,
+      now,
+      now + validity_period,
+      &raw_key,
+      &result->certificate);
 
-  base::Time now = base::Time::Now();
-  bool success = net::x509_util::CreateSelfSignedCert(key.get(),
-                                                      "CN=" + common_name,
-                                                      serial_number,
-                                                      now,
-                                                      now + validity_period,
-                                                      &result->certificate);
   if (!success) {
     DLOG(ERROR) << "Unable to create x509 cert for client";
     result->error = net::ERR_SELF_SIGNED_CERT_GENERATION_FAILED;
     return;
   }
 
+  scoped_ptr<crypto::RSAPrivateKey> key(raw_key);
   std::vector<uint8> private_key_info;
   if (!key->ExportPrivateKey(&private_key_info)) {
     DLOG(ERROR) << "Unable to export private key";
     result->error = net::ERR_PRIVATE_KEY_EXPORT_FAILED;
     return;
   }
 
   result->private_key =
       std::string(private_key_info.begin(), private_key_info.end());
 }
@@ skipping 238 matching lines @@
     if (in_flight_requests_[i]->origin_ == origin &&
         in_flight_requests_[i]->identity_name_ == identity_name &&
         in_flight_requests_[i]->common_name_ == common_name) {
       return in_flight_requests_[i];
     }
   }
   return NULL;
 }
 
 }  // namespace content