net/quic/crypto/crypto_handshake.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_H_
   6 #define NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/memory/scoped_ptr.h"
  12 #include "net/base/net_export.h"
  13 #include "net/quic/quic_protocol.h"
  14
  15 namespace net {
  16
  17 class CommonCertSets;
  18 class KeyExchange;
  19 class QuicDecrypter;
  20 class QuicEncrypter;
  21
  22 // A CrypterPair contains the encrypter and decrypter for an encryption level.
  23 struct NET_EXPORT_PRIVATE CrypterPair {
  24   CrypterPair();
  25   ~CrypterPair();
  26   scoped_ptr<QuicEncrypter> encrypter;
  27   scoped_ptr<QuicDecrypter> decrypter;
  28 };
  29
  30 // Parameters negotiated by the crypto handshake.
  31 struct NET_EXPORT_PRIVATE QuicCryptoNegotiatedParameters {
  32   // Initializes the members to 0 or empty values.
  33   QuicCryptoNegotiatedParameters();
  34   ~QuicCryptoNegotiatedParameters();
  35
  36   QuicTag key_exchange;
  37   QuicTag aead;
  38   std::string initial_premaster_secret;
  39   std::string forward_secure_premaster_secret;
  40   CrypterPair initial_crypters;
  41   CrypterPair forward_secure_crypters;
  42   // Normalized SNI: converted to lower case and trailing '.' removed.
  43   std::string sni;
  44   std::string client_nonce;
  45   std::string server_nonce;
  46   // hkdf_input_suffix contains the HKDF input following the label: the
  47   // ConnectionId, client hello and server config. This is only populated in the
  48   // client because only the client needs to derive the forward secure keys at a
  49   // later time from the initial keys.
  50   std::string hkdf_input_suffix;
  51   // cached_certs contains the cached certificates that a client used when
  52   // sending a client hello.
  53   std::vector<std::string> cached_certs;
  54   // client_key_exchange is used by clients to store the ephemeral KeyExchange
  55   // for the connection.
  56   scoped_ptr<KeyExchange> client_key_exchange;
  57   // channel_id is set by servers to a ChannelID key when the client correctly
  58   // proves possession of the corresponding private key. It consists of 32
  59   // bytes of x coordinate, followed by 32 bytes of y coordinate. Both values
  60   // are big-endian and the pair is a P-256 public key.
  61   std::string channel_id;
  62 };
  63
  64 // QuicCryptoConfig contains common configuration between clients and servers.
  65 class NET_EXPORT_PRIVATE QuicCryptoConfig {
  66  public:
  67   // kInitialLabel is a constant that is used when deriving the initial
  68   // (non-forward secure) keys for the connection in order to tie the resulting
  69   // key to this protocol.
  70   static const char kInitialLabel[];
  71
  72   // kCETVLabel is a constant that is used when deriving the keys for the
  73   // encrypted tag/value block in the client hello.
  74   static const char kCETVLabel[];
  75
  76   // kForwardSecureLabel is a constant that is used when deriving the forward
  77   // secure keys for the connection in order to tie the resulting key to this
  78   // protocol.
  79   static const char kForwardSecureLabel[];
  80
  81   QuicCryptoConfig();
  82   ~QuicCryptoConfig();
  83
  84   // Key exchange methods. The following two members' values correspond by
  85   // index.
  86   QuicTagVector kexs;
  87   // Authenticated encryption with associated data (AEAD) algorithms.
  88   QuicTagVector aead;
  89
  90   const CommonCertSets* common_cert_sets;
  91
  92  private:
  93   DISALLOW_COPY_AND_ASSIGN(QuicCryptoConfig);
  94 };
  95
  96 }  // namespace net
  97
  98 #endif  // NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_H_