[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: include all other asymmetric algorithms once they are defined,

[eroman, 2013/10/23 20:02:46]

nit: use the format TODO(padolph):

This doesn't mean you are signed up to do it, it just explains the "voice" that
stated the TODO. This is part of the google/chromium C++ style guide.

[padolph, 2013/10/23 23:21:47]

Done.

+  // 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) {
-  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);
+  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();

[eroman, 2013/10/23 20:02:46]

I think the structure of this function would be more readable if you return
after setting the result (rather than having "else"  clasues). So basically each
time "result.completeXXX" is called, there is an accompanying return statement.

[padolph, 2013/10/23 23:21:47]

Agreed for the error cases. But do you also want that for the true half of the
IsAlgorithmAsymmetric test? That does not seem right to me: it makes it look
like the asymmetric case is somehow special rather than a binary choice. That
is, is this what you want?

  if (IsAlgorithmAsymmetric(algorithm)) {
    scoped_ptr<WebKit::WebCryptoKeyHandle> public_key_handle;
    scoped_ptr<WebKit::WebCryptoKeyHandle> private_key_handle;
    //...
    result.completeWithKeyPair(public_key, private_key);
    return;
  } // << end of IsAlgorithmAsymmetric clause
  
  scoped_ptr<WebKit::WebCryptoKeyHandle> handle;
  WebKit::WebCryptoKeyType type;
  // ...
  result.completeWithKey(key);

+    } else {
+      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);
+    }
+  }
+  else {
+    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);
+    }
   }
 }
 
 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,
@@ skipping 49 matching lines @@
                                data,
                                data_size,
                                &signature_match)) {
     result.completeWithError();
   } else {
     result.completeWithBoolean(signature_match);
   }
 }
 
 }  // namespace content