Land Recent QUIC changes.

net/quic/crypto/crypto_server_config.h

 // 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.
 
 #ifndef NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_H_
 #define NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 124 matching lines @@
   // SetProofSource installs |proof_source| as the ProofSource for handshakes.
   // This object takes ownership of |proof_source|.
   void SetProofSource(ProofSource* proof_source);
 
   // SetEphemeralKeySource installs an object that can cache ephemeral keys for
   // a short period of time. This object takes ownership of
   // |ephemeral_key_source|. If not set then ephemeral keys will be generated
   // per-connection.
   void SetEphemeralKeySource(EphemeralKeySource* ephemeral_key_source);
 
+  // set_replay_protection controls whether replay protection is enabled. If
+  // replay protection is disabled then no strike registers are needed and
+  // frontends can share an orbit value without a shared strike-register.
+  // However, an attacker can duplicate a handshake and cause a client's
+  // request to be processed twice.
+  void set_replay_protection(bool on);
+
   // set_strike_register_max_entries sets the maximum number of entries that
   // the internal strike register will hold. If the strike register fills up
   // then the oldest entries (by the client's clock) will be dropped.
   void set_strike_register_max_entries(uint32 max_entries);
 
   // set_strike_register_window_secs sets the number of seconds around the
   // current time that the strike register will attempt to be authoritative
   // for. Setting a larger value allows for greater client clock-skew, but
   // means that the quiescent startup period must be longer.
   void set_strike_register_window_secs(uint32 window_secs);
@@ skipping 63 matching lines @@
     // will not be promoted at a specific time.
     QuicWallTime primary_time;
 
    private:
     friend class base::RefCounted<Config>;
     virtual ~Config();
 
     DISALLOW_COPY_AND_ASSIGN(Config);
   };
 
+  typedef std::map<ServerConfigID, scoped_refptr<Config> > ConfigMap;
+
   // ConfigPrimaryTimeLessThan returns true if a->primary_time <
   // b->primary_time.
   static bool ConfigPrimaryTimeLessThan(const scoped_refptr<Config>& a,
                                         const scoped_refptr<Config>& b);
 
   // SelectNewPrimaryConfig reevaluates the primary config based on the
   // "primary_time" deadlines contained in each.
   void SelectNewPrimaryConfig(QuicWallTime now) const;
 
   // EvaluateClientHello checks |client_hello| for gross errors and determines
@@ skipping 35 matching lines @@
   std::string NewServerNonce(QuicRandom* rand, QuicWallTime now) const;
 
   // ValidateServerNonce decrypts |token| and verifies that it hasn't been
   // previously used and is recent enough that it is plausible that it was part
   // of a very recently provided rejection ("recent" will be on the order of
   // 10-30 seconds). If so, it records that it has been used and returns true.
   // Otherwise it returns false.
   bool ValidateServerNonce(base::StringPiece echoed_server_nonce,
                            QuicWallTime now) const;
 
+  // replay_protection_ controls whether the server enforces that handshakes
+  // aren't replays.
+  bool replay_protection_;
+
   // configs_ satisfies the following invariants:
   //   1) configs_.empty() <-> primary_config_ == NULL
   //   2) primary_config_ != NULL -> primary_config_->is_primary
   //   3) ∀ c∈configs_, c->is_primary <-> c == primary_config_
   mutable base::Lock configs_lock_;
   // configs_ contains all active server configs. It's expected that there are
   // about half-a-dozen configs active at any one time.
-  typedef std::map<ServerConfigID, scoped_refptr<Config> > ConfigMap;
   ConfigMap configs_;
   // primary_config_ points to a Config (which is also in |configs_|) which is
   // the primary config - i.e. the one that we'll give out to new clients.
   mutable scoped_refptr<Config> primary_config_;
   // next_config_promotion_time_ contains the nearest, future time when an
   // active config will be promoted to primary.
   mutable QuicWallTime next_config_promotion_time_;
 
   mutable base::Lock strike_register_lock_;
   // strike_register_ contains a data structure that keeps track of previously
@@ skipping 33 matching lines @@
   uint32 strike_register_window_secs_;
   uint32 source_address_token_future_secs_;
   uint32 source_address_token_lifetime_secs_;
   uint32 server_nonce_strike_register_max_entries_;
   uint32 server_nonce_strike_register_window_secs_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_H_