[webcrypto] Add RSA key generation using NSS.

content/renderer/webcrypto/webcrypto_impl.cc

 // Copyright (c) 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/renderer/webcrypto/webcrypto_impl.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoKey.h"
 
 namespace content {
 
+namespace {
+
+bool IsAlgorithmAsymmetric(const WebKit::WebCryptoAlgorithm& algorithm) {
+  const WebKit::WebCryptoAlgorithmId algorithm_id = algorithm.id();
+  // TODO(padolph): include all other asymmetric algorithms once they are
+  // defined, e.g. EC and DH.
+  return (algorithm_id == WebKit::WebCryptoAlgorithmIdRsaEsPkcs1v1_5  ||
+          algorithm_id == WebKit::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 ||
+          algorithm_id == WebKit::WebCryptoAlgorithmIdRsaOaep);
+}
+
+} // namespace
+
 WebCryptoImpl::WebCryptoImpl() {
   Init();
 }
 
 // static
 // TODO(eroman): This works by re-allocating a new buffer. It would be better if
 //               the WebArrayBuffer could just be truncated instead.
 void WebCryptoImpl::ShrinkBuffer(
     WebKit::WebArrayBuffer* buffer,
     unsigned new_size) {
@@ skipping 48 matching lines @@
   } else {
     result.completeWithBuffer(buffer);
   }
 }
 
 void WebCryptoImpl::generateKey(
     const WebKit::WebCryptoAlgorithm& algorithm,
     bool exportable,
     WebKit::WebCryptoKeyUsageMask usage,
     WebKit::WebCryptoResult result) {
+  if (IsAlgorithmAsymmetric(algorithm)) {
+    scoped_ptr<WebKit::WebCryptoKeyHandle> public_key_handle;
+    scoped_ptr<WebKit::WebCryptoKeyHandle> private_key_handle;
+    if (!GenerateKeyPairInternal(algorithm,
+                                 &public_key_handle,
+                                 &private_key_handle)) {
+      result.completeWithError();
+      return;
+    }
+    WebKit::WebCryptoKey public_key(
+        WebKit::WebCryptoKey::create(public_key_handle.release(),
+                                     WebKit::WebCryptoKeyTypePublic,
+                                     exportable,
+                                     algorithm,
+                                     usage));
+    WebKit::WebCryptoKey private_key(
+        WebKit::WebCryptoKey::create(private_key_handle.release(),
+                                     WebKit::WebCryptoKeyTypePrivate,
+                                     exportable,
+                                     algorithm,
+                                     usage));
+    result.completeWithKeyPair(public_key, private_key);
+    return;
+  }
   scoped_ptr<WebKit::WebCryptoKeyHandle> handle;
   WebKit::WebCryptoKeyType type;
   if (!GenerateKeyInternal(algorithm, &handle, &type)) {
     result.completeWithError();
-  } else {
-    WebKit::WebCryptoKey key(
-        WebKit::WebCryptoKey::create(handle.release(), type, exportable,
-                                     algorithm, usage));
-    result.completeWithKey(key);
+    return;
   }
+  WebKit::WebCryptoKey key(
+      WebKit::WebCryptoKey::create(handle.release(), type, exportable,
+                                   algorithm, usage));
+  result.completeWithKey(key);
 }
 
 void WebCryptoImpl::importKey(
     WebKit::WebCryptoKeyFormat format,
     const unsigned char* key_data,
     unsigned key_data_size,
     const WebKit::WebCryptoAlgorithm& algorithm,
     bool extractable,
     WebKit::WebCryptoKeyUsageMask usage_mask,
     WebKit::WebCryptoResult result) {
@@ skipping 48 matching lines @@
                                data,
                                data_size,
                                &signature_match)) {
     result.completeWithError();
   } else {
     result.completeWithBoolean(signature_match);
   }
 }
 
 }  // namespace content