OpenSSL/NSS implementation of ProofVerfifier.

net/quic/quic_crypto_client_stream.cc

 // Copyright (c) 2012 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 "net/quic/quic_crypto_client_stream.h"
 
+#include "net/base/completion_callback.h"
+#include "net/base/net_errors.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_session.h"
 
 namespace net {
 
 QuicCryptoClientStream::QuicCryptoClientStream(
     const string& server_hostname,
     QuicSession* session,
     QuicCryptoClientConfig* crypto_config)
     : QuicCryptoStream(session),
+      weak_factory_(this),
       next_state_(STATE_IDLE),
       num_client_hellos_(0),
       crypto_config_(crypto_config),
-      server_hostname_(server_hostname) {
+      server_hostname_(server_hostname),
+      generation_counter_(0) {
 }
 
 QuicCryptoClientStream::~QuicCryptoClientStream() {
 }
 
 void QuicCryptoClientStream::OnHandshakeMessage(
     const CryptoHandshakeMessage& message) {
-  DoHandshakeLoop(&message);
+  DoHandshakeLoop(&message, OK);
 }
 
 bool QuicCryptoClientStream::CryptoConnect() {
   next_state_ = STATE_SEND_CHLO;
-  DoHandshakeLoop(NULL);
+  DoHandshakeLoop(NULL, OK);
   return true;
 }
 
 int QuicCryptoClientStream::num_sent_client_hellos() const {
   return num_client_hellos_;
 }
 
 // kMaxClientHellos is the maximum number of times that we'll send a client
 // hello. The value 3 accounts for:
 //   * One failure due to an incorrect or missing source-address token.
 //   * One failure due the server's certificate chain being unavailible and the
 //     server being unwilling to send it without a valid source-address token.
 static const int kMaxClientHellos = 3;
 
 void QuicCryptoClientStream::DoHandshakeLoop(
-    const CryptoHandshakeMessage* in) {
+    const CryptoHandshakeMessage* in,
+    int result) {
   CryptoHandshakeMessage out;
   QuicErrorCode error;
   string error_details;
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_->LookupOrCreate(server_hostname_);
 
   if (in != NULL) {
     DVLOG(1) << "Client received: " << in->DebugString();
   }
 
   for (;;) {
     const State state = next_state_;
     next_state_ = STATE_IDLE;
     switch (state) {
       case STATE_SEND_CHLO: {

[wtc, 2013/07/03 00:20:26]

Nit: we may want to DCHECK that |in| is NULL and |result| is |OK|
for the STATE_SEND_CHLO state.

[ramant (doing other things), 2013/07/03 05:46:34]

Added the DCHECK for |result| is |OK|. IMO, |in| need not be NULL if the session
(or config) doesn't have a ProofVerifier and the next_state_ was STATE_RECV_REJ.
I could be wrong.

[wtc, 2013/07/03 18:50:23]

Ah, I see. Yes, there are three ways to enter the
STATE_SEND_CHLO state. In the first way (CryptoConnect),
|in| is NULL, but in the other two ways, we enter via
some other state (STATE_RECV_REJ or STATE_VERIFY_PROOF_COMPLETE).
If we enter via STATE_RECV_REJ, |in| is not null.

+        // Send the subsequent client hello in plaintext.
+        session()->connection()->SetDefaultEncryptionLevel(ENCRYPTION_NONE);

[wtc, 2013/07/03 00:20:26]

"subsequent" probably should be removed from this comment.
It made sense when this comment was in the STATE_RECV_REJ state.

[ramant (doing other things), 2013/07/03 05:46:34]

Done.

         if (num_client_hellos_ > kMaxClientHellos) {
           CloseConnection(QUIC_CRYPTO_TOO_MANY_REJECTS);
           return;
         }
         num_client_hellos_++;
 
         if (!cached->IsComplete(session()->connection()->clock()->WallNow())) {
           crypto_config_->FillInchoateClientHello(
               server_hostname_, cached, &crypto_negotiated_params_, &out);
           next_state_ = STATE_RECV_REJ;
@@ skipping 36 matching lines @@
           encryption_established_ = true;
           session()->OnCryptoHandshakeEvent(
               QuicSession::ENCRYPTION_FIRST_ESTABLISHED);
         } else {
           session()->OnCryptoHandshakeEvent(
               QuicSession::ENCRYPTION_REESTABLISHED);
         }
         return;
       }
       case STATE_RECV_REJ:
+        DCHECK_EQ(OK, result);
         // We sent a dummy CHLO because we didn't have enough information to
         // perform a handshake, or we sent a full hello that the server
         // rejected. Here we hope to have a REJ that contains the information
         // that we need.
         if (in->tag() != kREJ) {
           CloseConnectionWithDetails(QUIC_INVALID_CRYPTO_MESSAGE_TYPE,
                                      "Expected REJ");
           return;
         }
         error = crypto_config_->ProcessRejection(
             cached, *in, session()->connection()->clock()->WallNow(),
             &crypto_negotiated_params_, &error_details);
         if (error != QUIC_NO_ERROR) {
           CloseConnectionWithDetails(error, error_details);
           return;
         }
         if (!cached->proof_valid()) {
-          const ProofVerifier* verifier = crypto_config_->proof_verifier();
+          ProofVerifier* verifier = session()->proof_verifier();
           if (!verifier) {
             // If no verifier is set then we don't check the certificates.
             cached->SetProofValid();
           } else if (!cached->signature().empty()) {
-            // TODO(rtenneti): In Chromium, we will need to make VerifyProof()
-            // asynchronous.
-            if (!verifier->VerifyProof(server_hostname_,
-                                       cached->server_config(),
-                                       cached->certs(),
-                                       cached->signature(),
-                                       &error_details)) {
-              CloseConnectionWithDetails(QUIC_PROOF_INVALID,
-                                         "Proof invalid: " + error_details);
-              return;
-            }
-            cached->SetProofValid();
+            next_state_ = STATE_VERIFY_PROOF;
+            continue;

[wtc, 2013/07/03 00:20:26]

Nit: it is equivalent, but I think it looks nicer to use "break"
instead of "continue" here.

[ramant (doing other things), 2013/07/03 05:46:34]

Done.

           }
         }
-        // Send the subsequent client hello in plaintext.
-        session()->connection()->SetDefaultEncryptionLevel(
-            ENCRYPTION_NONE);
         next_state_ = STATE_SEND_CHLO;
         break;
+      case STATE_VERIFY_PROOF: {
+        ProofVerifier* verifier = session()->proof_verifier();
+        DCHECK(verifier);
+        next_state_ = STATE_VERIFY_PROOF_COMPLETED;
+        generation_counter_ = cached->generation_counter();
+        result = verifier->VerifyProof(
+            server_hostname_,
+            cached->server_config(),
+            cached->certs(),
+            cached->signature(),
+            &error_details_,
+            base::Bind(&QuicCryptoClientStream::OnVerifyProofComplete,
+                       weak_factory_.GetWeakPtr()));
+        if (result == ERR_IO_PENDING) {
+          DVLOG(1) << "Doing VerifyProof";
+          return;
+        }
+        break;
+      }
+      case STATE_VERIFY_PROOF_COMPLETED: {
+        if (result != OK) {
+            CloseConnectionWithDetails(
+                QUIC_PROOF_INVALID, "Proof invalid: " + error_details_);
+            return;
+        }
+        ProofVerifier* verifier = session()->proof_verifier();
+        DCHECK(verifier);

[wtc, 2013/07/03 00:20:26]

Delete these two lines. |verifier| is unused. You are getting
the generation counter from |cached| instead.

[ramant (doing other things), 2013/07/03 05:46:34]

Done.

+        // Check if generation_counter has changed between STATE_VERIFY_PROOF
+        // and STATE_VERIFY_PROOF_COMPLETED state changes.
+        if (generation_counter_ != cached->generation_counter()) {
+          next_state_ = STATE_VERIFY_PROOF;
+          continue;

[wtc, 2013/07/03 00:20:26]

Nit: similarly, I suggest using "break" instead of "continue" here.
Or you can use if-else:

  if (generation_counter_ != cached->generation_counter()) {
    next_state_ = STATE_VERIFY_PROOF;
  } else {
    cached->SetProofValid();
    next_state_ = STATE_SEND_CHLO;
  }
  break;

[ramant (doing other things), 2013/07/03 05:46:34]

Done.

+        }
+        cached->SetProofValid();
+        next_state_ = STATE_SEND_CHLO;
+        break;
+      }
       case STATE_RECV_SHLO: {
         // We sent a CHLO that we expected to be accepted and now we're hoping
         // for a SHLO from the server to confirm that.
         if (in->tag() == kREJ) {
           // alternative_decrypter will be NULL if the original alternative
           // decrypter latched and became the primary decrypter. That happens
           // if we received a message encrypted with the INITIAL key.
           if (session()->connection()->alternative_decrypter() == NULL) {
             // The rejection was sent encrypted!
             CloseConnectionWithDetails(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT,
@@ skipping 49 matching lines @@
         return;
       }
       case STATE_IDLE:
         // This means that the peer sent us a message that we weren't expecting.
         CloseConnection(QUIC_INVALID_CRYPTO_MESSAGE_TYPE);
         return;
     }
   }
 }
 
+void QuicCryptoClientStream::OnVerifyProofComplete(int result) {
+  DCHECK_EQ(STATE_VERIFY_PROOF_COMPLETED, next_state_);
+  DVLOG(1) << "VerifyProof completed: " << result;
+  DoHandshakeLoop(NULL, result);
+}
+
 }  // namespace net