Home | History | Annotate | Download | only in crypto 
      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_SERVER_CONFIG_PROTOBUF_H_
      6 #define NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_PROTOBUF_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/logging.h"
     12 #include "base/stl_util.h"
     13 #include "base/strings/string_piece.h"
     14 #include "net/base/net_export.h"
     15 #include "net/quic/crypto/crypto_protocol.h"
     16 
     17 namespace net {
     18 
     19 // QuicServerConfigProtobuf contains QUIC server config block and the private
     20 // keys needed to prove ownership.
     21 // TODO(rch): sync with server more rationally.
     22 class NET_EXPORT_PRIVATE QuicServerConfigProtobuf {
     23  public:
     24   // PrivateKey contains a QUIC tag of a key exchange algorithm and a
     25   // serialised private key for that algorithm. The format of the serialised
     26   // private key is specific to the algorithm in question.
     27   class NET_EXPORT_PRIVATE PrivateKey {
     28    public:
     29     QuicTag tag() const {
     30       return tag_;
     31     }
     32     void set_tag(QuicTag tag) {
     33       tag_ = tag;
     34     }
     35     std::string private_key() const {
     36       return private_key_;
     37     }
     38     void set_private_key(std::string key) {
     39       private_key_ = key;
     40     }
     41 
     42    private:
     43     QuicTag tag_;
     44     std::string private_key_;
     45   };
     46 
     47   QuicServerConfigProtobuf();
     48   ~QuicServerConfigProtobuf();
     49 
     50   size_t key_size() const {
     51     return keys_.size();
     52   }
     53 
     54   const PrivateKey& key(size_t i) const {
     55     DCHECK_GT(keys_.size(), i);
     56     return *keys_[i];
     57   }
     58 
     59   std::string config() const {
     60     return config_;
     61   }
     62 
     63   void set_config(base::StringPiece config) {
     64     config_ = config.as_string();
     65   }
     66 
     67   QuicServerConfigProtobuf::PrivateKey* add_key() {
     68     keys_.push_back(new PrivateKey);
     69     return keys_.back();
     70   }
     71 
     72   void clear_key() {
     73     STLDeleteElements(&keys_);
     74   }
     75 
     76   bool has_primary_time() const {
     77     return primary_time_ > 0;
     78   }
     79 
     80   int64 primary_time() const {
     81     return primary_time_;
     82   }
     83 
     84   void set_primary_time(int64 primary_time) {
     85     primary_time_ = primary_time;
     86   }
     87 
     88  private:
     89   std::vector<PrivateKey*> keys_;
     90 
     91   // config_ is a serialised config in QUIC wire format.
     92   std::string config_;
     93 
     94   // primary_time_ contains a UNIX epoch seconds value that indicates when this
     95   // config should become primary.
     96   int64 primary_time_;
     97 };
     98 
     99 }  // namespace net
    100 
    101 #endif  // NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_PROTOBUF_H_
    102