RTCCertificate, RTCPeerConnection.generateCertificate (WebRTC JavaScript) added.

third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/mediastream/RTCPeerConnection.h"
 
 #include "bindings/core/v8/ArrayValue.h"
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/Nullable.h"
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "bindings/modules/v8/V8RTCCertificate.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/VoidCallback.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "modules/mediastream/MediaConstraintsImpl.h"
 #include "modules/mediastream/MediaStreamEvent.h"
 #include "modules/mediastream/RTCDTMFSender.h"
 #include "modules/mediastream/RTCDataChannel.h"
 #include "modules/mediastream/RTCDataChannelEvent.h"
 #include "modules/mediastream/RTCErrorCallback.h"
 #include "modules/mediastream/RTCIceCandidateEvent.h"
 #include "modules/mediastream/RTCSessionDescription.h"
 #include "modules/mediastream/RTCSessionDescriptionCallback.h"
 #include "modules/mediastream/RTCSessionDescriptionRequestImpl.h"
 #include "modules/mediastream/RTCStatsCallback.h"
 #include "modules/mediastream/RTCStatsRequestImpl.h"
 #include "modules/mediastream/RTCVoidRequestImpl.h"
 #include "platform/mediastream/RTCConfiguration.h"
 #include "platform/mediastream/RTCOfferOptions.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebMediaStream.h"
+#include "public/platform/WebRTCCertificate.h"
+#include "public/platform/WebRTCCertificateGenerator.h"
 #include "public/platform/WebRTCConfiguration.h"
 #include "public/platform/WebRTCDataChannelHandler.h"
 #include "public/platform/WebRTCDataChannelInit.h"
 #include "public/platform/WebRTCICECandidate.h"
+#include "public/platform/WebRTCKeyParams.h"
 #include "public/platform/WebRTCOfferOptions.h"
 #include "public/platform/WebRTCSessionDescription.h"
 #include "public/platform/WebRTCSessionDescriptionRequest.h"
 #include "public/platform/WebRTCStatsRequest.h"
 #include "public/platform/WebRTCVoidRequest.h"
 
 namespace blink {
 
 namespace {
 
 static bool throwExceptionIfSignalingStateClosed(RTCPeerConnection::SignalingState state, ExceptionState& exceptionState)
 {
     if (state == RTCPeerConnection::SignalingStateClosed) {
         exceptionState.throwDOMException(InvalidStateError, "The RTCPeerConnection's signalingState is 'closed'.");
         return true;
     }
 
     return false;
 }
 
+// Helper class for RTCPeerConnection::generateCertificate.
+class WebRTCCertificateObserver : public WebCallbacks<WebRTCCertificate*, void> {
+public:
+    // The created observer is responsible for deleting itself after onSuccess/onError. To avoid memory
+    // leak the observer should therefore be used in a WebRTCCertificateGenerator::generateCertificate call
+    // which is ensured to invoke one of these. Takes ownership of |resolver|.
+    static WebRTCCertificateObserver* create(ScriptPromiseResolver* resolver)
+    {
+        return new WebRTCCertificateObserver(resolver);
+    }
+
+    DEFINE_INLINE_TRACE() { visitor->trace(m_resolver); }
+
+private:
+    WebRTCCertificateObserver(ScriptPromiseResolver* resolver)
+        : m_resolver(resolver) {}
+
+    ~WebRTCCertificateObserver() override {}
+
+    void onSuccess(WebRTCCertificate* certificate) override
+    {
+        m_resolver->resolve(new RTCCertificate(certificate));
+        delete this;
+    }
+
+    void onError() override
+    {
+        m_resolver->reject();
+        delete this;
+    }
+
+    Persistent<ScriptPromiseResolver> m_resolver;
+};
+
 } // namespace
 
 RTCConfiguration* RTCPeerConnection::parseConfiguration(const Dictionary& configuration, ExceptionState& exceptionState)
 {
     if (configuration.isUndefinedOrNull())
         return 0;
 
     RTCIceTransports iceTransports = RTCIceTransportsAll;
     String iceTransportsString;
     if (DictionaryHelper::get(configuration, "iceTransports", iceTransportsString)) {
@@ skipping 105 matching lines @@
             KURL url(KURL(), *iter);
             if (!url.isValid() || !(url.protocolIs("turn") || url.protocolIs("turns") || url.protocolIs("stun"))) {
                 exceptionState.throwTypeError("Malformed URL");
                 return 0;
             }
 
             rtcConfiguration->iceServers()->appendServer(RTCIceServer::create(url, username, credential));
         }
     }
 
+    ArrayValue certificates;
+    if (DictionaryHelper::get(configuration, "certificates", certificates) && !certificates.isUndefinedOrNull()) {
+        size_t numberOfCertificates;
+        certificates.length(numberOfCertificates);
+        for (size_t i = 0; i < numberOfCertificates; ++i) {
+            RTCCertificate* certificate = nullptr;
+
+            Dictionary dictCert;
+            certificates.get(i, dictCert);
+            v8::Local<v8::Value> valCert = dictCert.v8Value();
+            if (!valCert.IsEmpty()) {
+                certificate = V8RTCCertificate::toImplWithTypeCheck(configuration.isolate(), valCert);
+            }
+            if (!certificate) {
+                exceptionState.throwTypeError("Malformed sequence<RTCCertificate>");
+                return 0;
+            }
+
+            rtcConfiguration->appendCertificate(certificate->certificateShallowCopy());
+        }
+    }
+
     return rtcConfiguration;
 }
 
 RTCOfferOptions* RTCPeerConnection::parseOfferOptions(const Dictionary& options, ExceptionState& exceptionState)
 {
     if (options.isUndefinedOrNull())
         return 0;
 
     Vector<String> propertyNames;
     options.getPropertyNames(propertyNames);
@@ skipping 184 matching lines @@
 
     WebMediaConstraints constraints = MediaConstraintsImpl::create(mediaConstraints, exceptionState);
     if (exceptionState.hadException())
         return;
 
     bool valid = m_peerHandler->updateICE(configuration, constraints);
     if (!valid)
         exceptionState.throwDOMException(SyntaxError, "Could not update the ICE Agent with the given configuration.");
 }
 
+ScriptPromise RTCPeerConnection::generateCertificate(ScriptState* scriptState, const Dictionary& keygenAlgorithm, ExceptionState& exceptionState)
+{
+    // Validate and interpret input |keygenAlgorithm|.
+    // TODO(hbos): Use WebCrypto normalization process to validate and interpret |keygenAlgorithm|.
+    // This may create a dependency between the Blink and WebCrypto modules? crbug.com/544917

[eroman, 2015/10/21 22:55:50]

As discussed over email, depending on NormalizeAlgorithm.h is fine.

[hbos_chromium, 2015/10/22 09:40:56]

Acknowledged.

+    Nullable<WebRTCKeyParams> keyParams;
+    String name;
+    if (DictionaryHelper::get(keygenAlgorithm, "name", name)) {

[eroman, 2015/10/21 22:55:50]

As-written the AlgorithmIdentifier parsing code here has two main problems:

  (1) publicExponent must be a BigInteger and not a Number
(https://github.com/w3c/webrtc-pc/issues/310)
  (2) Algorithm names must be case-insensitive (so for instance EcDsA should
also be recognized)

If your intention is to submit this changelist as-is as a temporary measure, and
then follow-up quickly with a switchover to calling WebCrypto's parsing
algorithm (which should actually involve less code for more features), that is
fine -- I am happy to review that as a separate CL.

[hbos_chromium, 2015/10/22 09:40:56]

That's what I'll do :) Btw there is a third problem. WebCrypto requires RSA to
have a "hash" value too: https://github.com/w3c/webrtc-pc/issues/322.

[eroman, 2015/10/22 17:49:49]

Oh right, that too ... Yuck!

+        if (name == "RSASSA-PKCS1-v1_5") {
+            // RSA - Supported |keygenAlgorithm|:
+            // { name: "RSASSA-PKCS1-v1_5", modulusLength: <int>, publicExponent: 65537 }
+            int modulusLength = -1;
+            int publicExponent = -1;
+            if (DictionaryHelper::get(keygenAlgorithm, "modulusLength", modulusLength)
+                && modulusLength >= 0
+                && DictionaryHelper::get(keygenAlgorithm, "publicExponent", publicExponent)
+                && publicExponent >= 0) {
+                keyParams.set(blink::WebRTCKeyParams::createRSA(modulusLength, publicExponent));
+            }
+        } else if (name == "ECDSA") {
+            // ECDSA - Supported |keygenAlgorithm|:
+            // { name: "ECDSA", namedCurve: "P-256" }
+            String namedCurve;
+            DictionaryHelper::get(keygenAlgorithm, "namedCurve", namedCurve);
+            if (namedCurve == "P-256") {
+                keyParams.set(blink::WebRTCKeyParams::createECDSA(WebRTCECCurveNistP256));
+            }
+        }
+    }
+    if (keyParams.isNull()) {
+        // Invalid argument.
+        return ScriptPromise::rejectWithDOMException(
+            scriptState, DOMException::create(InvalidAccessError, ExceptionMessages::argumentNullOrIncorrectType(1, "AlgorithmIdentifier")));

[eroman, 2015/10/21 22:55:51]

According to the WebRTC spec you should be failing a number of these with
NotSupported error.
(Or if the WebCrypto algorithm normalization failed, then return that error.)

For instance keyParams will be null when using a P-384, and subsequently result
in InvalidAcessError when it should be NotSupported.

[hbos_chromium, 2015/10/22 09:40:56]

Acknowledged. To be addressed in follow-up.

+    }
+
+    OwnPtr<WebRTCCertificateGenerator> certificateGenerator = adoptPtr(
+        Platform::current()->createRTCCertificateGenerator());
+
+    // Check validity of |keyParams|.
+    if (!certificateGenerator->isValidKeyParams(keyParams.get())) {
+        return ScriptPromise::rejectWithDOMException(
+            scriptState, DOMException::create(NotSupportedError, "The 1st argument provided is an AlgorithmIdentifier, but it has unsupported parameter values."));
+    }
+
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    WebRTCCertificateObserver* certificateObserver = WebRTCCertificateObserver::create(resolver);
+
+    // Generate certificate. The |certificateObserver| will resolve the promise asynchronously upon completion.
+    // The observer will manage its own destruction as well as the resolver's destruction.
+    certificateGenerator->generateCertificate(
+        keyParams.get(),
+        toDocument(scriptState->executionContext())->url(),
+        toDocument(scriptState->executionContext())->firstPartyForCookies(),
+        certificateObserver);
+
+    return promise;
+}
+
 void RTCPeerConnection::addIceCandidate(RTCIceCandidate* iceCandidate, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     if (!iceCandidate) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "RTCIceCandidate"));
         return;
     }
 
@@ skipping 423 matching lines @@
 {
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dataChannels);
     visitor->trace(m_scheduledEvents);
     RefCountedGarbageCollectedEventTargetWithInlineData<RTCPeerConnection>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink