1 // Copyright 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_CHANNEL_ID_H_ 6 #define NET_QUIC_CRYPTO_CHANNEL_ID_H_ 7 8 #include <string> 9 10 #include "base/memory/scoped_ptr.h" 11 #include "base/strings/string_piece.h" 12 #include "net/base/net_export.h" 13 #include "net/quic/quic_types.h" 14 15 namespace net { 16 17 // ChannelIDKey is an interface that supports signing with and serializing a 18 // ChannelID key. 19 class NET_EXPORT_PRIVATE ChannelIDKey { 20 public: ~ChannelIDKey()21 virtual ~ChannelIDKey() {} 22 23 // Sign signs |signed_data| using the ChannelID private key and puts the 24 // signature into |out_signature|. It returns true on success. 25 virtual bool Sign(base::StringPiece signed_data, 26 std::string* out_signature) const = 0; 27 28 // SerializeKey returns the serialized ChannelID public key. 29 virtual std::string SerializeKey() const = 0; 30 }; 31 32 // ChannelIDSourceCallback provides a generic mechanism for a ChannelIDSource 33 // to call back after an asynchronous GetChannelIDKey operation. 34 class ChannelIDSourceCallback { 35 public: ~ChannelIDSourceCallback()36 virtual ~ChannelIDSourceCallback() {} 37 38 // Run is called on the original thread to mark the completion of an 39 // asynchonous GetChannelIDKey operation. If |*channel_id_key| is not NULL 40 // then the channel ID lookup is successful. |Run| may take ownership of 41 // |*channel_id_key| by calling |release| on it. 42 virtual void Run(scoped_ptr<ChannelIDKey>* channel_id_key) = 0; 43 }; 44 45 // ChannelIDSource is an abstract interface by which a QUIC client can obtain 46 // a ChannelIDKey for a given hostname. 47 class NET_EXPORT_PRIVATE ChannelIDSource { 48 public: ~ChannelIDSource()49 virtual ~ChannelIDSource() {} 50 51 // GetChannelIDKey looks up the ChannelIDKey for |hostname|. On success it 52 // returns QUIC_SUCCESS and stores the ChannelIDKey in |*channel_id_key|, 53 // which the caller takes ownership of. On failure, it returns QUIC_FAILURE. 54 // 55 // This function may also return QUIC_PENDING, in which case the 56 // ChannelIDSource will call back, on the original thread, via |callback| 57 // when complete. In this case, the ChannelIDSource will take ownership of 58 // |callback|. 59 virtual QuicAsyncStatus GetChannelIDKey( 60 const std::string& hostname, 61 scoped_ptr<ChannelIDKey>* channel_id_key, 62 ChannelIDSourceCallback* callback) = 0; 63 }; 64 65 // ChannelIDVerifier verifies ChannelID signatures. 66 class NET_EXPORT_PRIVATE ChannelIDVerifier { 67 public: 68 // kContextStr is prepended to the data to be signed in order to ensure that 69 // a ChannelID signature cannot be used in a different context. (The 70 // terminating NUL byte is inclued.) 71 static const char kContextStr[]; 72 // kClientToServerStr follows kContextStr to specify that the ChannelID is 73 // being used in the client to server direction. (The terminating NUL byte is 74 // included.) 75 static const char kClientToServerStr[]; 76 77 // Verify returns true iff |signature| is a valid signature of |signed_data| 78 // by |key|. 79 static bool Verify(base::StringPiece key, 80 base::StringPiece signed_data, 81 base::StringPiece signature); 82 83 // FOR TESTING ONLY: VerifyRaw returns true iff |signature| is a valid 84 // signature of |signed_data| by |key|. |is_channel_id_signature| indicates 85 // whether |signature| is a ChannelID signature (with kContextStr prepended 86 // to the data to be signed). 87 static bool VerifyRaw(base::StringPiece key, 88 base::StringPiece signed_data, 89 base::StringPiece signature, 90 bool is_channel_id_signature); 91 92 private: 93 DISALLOW_COPY_AND_ASSIGN(ChannelIDVerifier); 94 }; 95 96 } // namespace net 97 98 #endif // NET_QUIC_CRYPTO_CHANNEL_ID_H_ 99