[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) {
+  // 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 62 matching lines @@
     result.completeWithBuffer(buffer);
   }
 }
 
 void WebCryptoImpl::generateKey(
     const WebKit::WebCryptoAlgorithm& algorithm,
     bool extractable,
     WebKit::WebCryptoKeyUsageMask usage_mask,
     WebKit::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
-  WebKit::WebCryptoKey key = NullKey();
-  if (!GenerateKeyInternal(algorithm, extractable, usage_mask, &key)) {
-    result.completeWithError();
+  if (IsAlgorithmAsymmetric(algorithm)) {
+    WebKit::WebCryptoKey public_key = WebKit::WebCryptoKey::createNull();
+    WebKit::WebCryptoKey private_key = WebKit::WebCryptoKey::createNull();
+    if (!GenerateKeyPairInternal(
+             algorithm, extractable, usage_mask, &public_key, &private_key)) {
+      result.completeWithError();
+    } else {
+      DCHECK(public_key.handle());
+      DCHECK(private_key.handle());
+      DCHECK_EQ(algorithm.id(), public_key.algorithm().id());
+      DCHECK_EQ(algorithm.id(), private_key.algorithm().id());
+      // TODO(padolph): The public key should probably always be extractable,
+      // regardless of the input 'extractable' parameter, but that is not called
+      // out in the Web Crypto API spec.
+      // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=23695
+      DCHECK_EQ(extractable, public_key.extractable());
+      DCHECK_EQ(extractable, private_key.extractable());
+      DCHECK_EQ(usage_mask, public_key.usages());
+      DCHECK_EQ(usage_mask, private_key.usages());
+      result.completeWithKeyPair(public_key, private_key);
+    }
   } else {
-    DCHECK(key.handle());
-    DCHECK_EQ(algorithm.id(), key.algorithm().id());
-    DCHECK_EQ(extractable, key.extractable());
-    DCHECK_EQ(usage_mask, key.usages());
-    result.completeWithKey(key);
+    WebKit::WebCryptoKey key = WebKit::WebCryptoKey::createNull();
+    if (!GenerateKeyInternal(algorithm, extractable, usage_mask, &key)) {
+      result.completeWithError();
+    } else {
+      DCHECK(key.handle());
+      DCHECK_EQ(algorithm.id(), key.algorithm().id());
+      DCHECK_EQ(extractable, key.extractable());
+      DCHECK_EQ(usage_mask, key.usages());
+      result.completeWithKey(key);
+    }
   }
 }
 
 void WebCryptoImpl::importKey(
     WebKit::WebCryptoKeyFormat format,
     const unsigned char* key_data,
     unsigned key_data_size,
     const WebKit::WebCryptoAlgorithm& algorithm_or_null,
     bool extractable,
     WebKit::WebCryptoKeyUsageMask usage_mask,
     WebKit::WebCryptoResult result) {
-  WebKit::WebCryptoKey key = NullKey();
+  WebKit::WebCryptoKey key = WebKit::WebCryptoKey::createNull();
   if (!ImportKeyInternal(format,
                          key_data,
                          key_data_size,
                          algorithm_or_null,
                          extractable,
                          usage_mask,
                          &key)) {
     result.completeWithError();
     return;
   }
@@ skipping 35 matching lines @@
                                data,
                                data_size,
                                &signature_match)) {
     result.completeWithError();
   } else {
     result.completeWithBoolean(signature_match);
   }
 }
 
 }  // namespace content