Use quiche string libraries in //third_party/quic/core/crypto gfe-relnote: n/a, no functional change PiperOrigin-RevId: 285405224 Change-Id: I4a7f6d34ee42a2929cbbff2f303ee36b5b6ceb8a
diff --git a/quic/core/crypto/aead_base_decrypter.cc b/quic/core/crypto/aead_base_decrypter.cc index ab441b7..baaf6ce 100644 --- a/quic/core/crypto/aead_base_decrypter.cc +++ b/quic/core/crypto/aead_base_decrypter.cc
@@ -14,6 +14,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -68,7 +69,7 @@ AeadBaseDecrypter::~AeadBaseDecrypter() {} -bool AeadBaseDecrypter::SetKey(QuicStringPiece key) { +bool AeadBaseDecrypter::SetKey(quiche::QuicheStringPiece key) { DCHECK_EQ(key.size(), key_size_); if (key.size() != key_size_) { return false; @@ -85,7 +86,7 @@ return true; } -bool AeadBaseDecrypter::SetNoncePrefix(QuicStringPiece nonce_prefix) { +bool AeadBaseDecrypter::SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) { if (use_ietf_nonce_construction_) { QUIC_BUG << "Attempted to set nonce prefix on IETF QUIC crypter"; return false; @@ -98,7 +99,7 @@ return true; } -bool AeadBaseDecrypter::SetIV(QuicStringPiece iv) { +bool AeadBaseDecrypter::SetIV(quiche::QuicheStringPiece iv) { if (!use_ietf_nonce_construction_) { QUIC_BUG << "Attempted to set IV on Google QUIC crypter"; return false; @@ -111,7 +112,7 @@ return true; } -bool AeadBaseDecrypter::SetPreliminaryKey(QuicStringPiece key) { +bool AeadBaseDecrypter::SetPreliminaryKey(quiche::QuicheStringPiece key) { DCHECK(!have_preliminary_key_); SetKey(key); have_preliminary_key_ = true; @@ -131,9 +132,10 @@ prefix_size -= sizeof(QuicPacketNumber); } DiversifyPreliminaryKey( - QuicStringPiece(reinterpret_cast<const char*>(key_), key_size_), - QuicStringPiece(reinterpret_cast<const char*>(iv_), prefix_size), nonce, - key_size_, prefix_size, &key, &nonce_prefix); + quiche::QuicheStringPiece(reinterpret_cast<const char*>(key_), key_size_), + quiche::QuicheStringPiece(reinterpret_cast<const char*>(iv_), + prefix_size), + nonce, key_size_, prefix_size, &key, &nonce_prefix); if (!SetKey(key) || (!use_ietf_nonce_construction_ && !SetNoncePrefix(nonce_prefix)) || @@ -147,8 +149,8 @@ } bool AeadBaseDecrypter::DecryptPacket(uint64_t packet_number, - QuicStringPiece associated_data, - QuicStringPiece ciphertext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext, char* output, size_t* output_length, size_t max_output_length) { @@ -199,13 +201,14 @@ return nonce_size_; } -QuicStringPiece AeadBaseDecrypter::GetKey() const { - return QuicStringPiece(reinterpret_cast<const char*>(key_), key_size_); +quiche::QuicheStringPiece AeadBaseDecrypter::GetKey() const { + return quiche::QuicheStringPiece(reinterpret_cast<const char*>(key_), + key_size_); } -QuicStringPiece AeadBaseDecrypter::GetNoncePrefix() const { - return QuicStringPiece(reinterpret_cast<const char*>(iv_), - nonce_size_ - sizeof(QuicPacketNumber)); +quiche::QuicheStringPiece AeadBaseDecrypter::GetNoncePrefix() const { + return quiche::QuicheStringPiece(reinterpret_cast<const char*>(iv_), + nonce_size_ - sizeof(QuicPacketNumber)); } } // namespace quic
diff --git a/quic/core/crypto/aead_base_decrypter.h b/quic/core/crypto/aead_base_decrypter.h index f0c5b01..e69b0ed 100644 --- a/quic/core/crypto/aead_base_decrypter.h +++ b/quic/core/crypto/aead_base_decrypter.h
@@ -10,7 +10,7 @@ #include "third_party/boringssl/src/include/openssl/aead.h" #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -29,22 +29,22 @@ ~AeadBaseDecrypter() override; // QuicDecrypter implementation - bool SetKey(QuicStringPiece key) override; - bool SetNoncePrefix(QuicStringPiece nonce_prefix) override; - bool SetIV(QuicStringPiece iv) override; - bool SetPreliminaryKey(QuicStringPiece key) override; + bool SetKey(quiche::QuicheStringPiece key) override; + bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) override; + bool SetIV(quiche::QuicheStringPiece iv) override; + bool SetPreliminaryKey(quiche::QuicheStringPiece key) override; bool SetDiversificationNonce(const DiversificationNonce& nonce) override; bool DecryptPacket(uint64_t packet_number, - QuicStringPiece associated_data, - QuicStringPiece ciphertext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext, char* output, size_t* output_length, size_t max_output_length) override; size_t GetKeySize() const override; size_t GetNoncePrefixSize() const override; size_t GetIVSize() const override; - QuicStringPiece GetKey() const override; - QuicStringPiece GetNoncePrefix() const override; + quiche::QuicheStringPiece GetKey() const override; + quiche::QuicheStringPiece GetNoncePrefix() const override; protected: // Make these constants available to the subclasses so that the subclasses
diff --git a/quic/core/crypto/aead_base_encrypter.cc b/quic/core/crypto/aead_base_encrypter.cc index a3173f5..b794e7e 100644 --- a/quic/core/crypto/aead_base_encrypter.cc +++ b/quic/core/crypto/aead_base_encrypter.cc
@@ -12,6 +12,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -58,7 +59,7 @@ AeadBaseEncrypter::~AeadBaseEncrypter() {} -bool AeadBaseEncrypter::SetKey(QuicStringPiece key) { +bool AeadBaseEncrypter::SetKey(quiche::QuicheStringPiece key) { DCHECK_EQ(key.size(), key_size_); if (key.size() != key_size_) { return false; @@ -76,7 +77,7 @@ return true; } -bool AeadBaseEncrypter::SetNoncePrefix(QuicStringPiece nonce_prefix) { +bool AeadBaseEncrypter::SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) { if (use_ietf_nonce_construction_) { QUIC_BUG << "Attempted to set nonce prefix on IETF QUIC crypter"; return false; @@ -89,7 +90,7 @@ return true; } -bool AeadBaseEncrypter::SetIV(QuicStringPiece iv) { +bool AeadBaseEncrypter::SetIV(quiche::QuicheStringPiece iv) { if (!use_ietf_nonce_construction_) { QUIC_BUG << "Attempted to set IV on Google QUIC crypter"; return false; @@ -102,9 +103,9 @@ return true; } -bool AeadBaseEncrypter::Encrypt(QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece plaintext, +bool AeadBaseEncrypter::Encrypt(quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext, unsigned char* output) { DCHECK_EQ(nonce.size(), nonce_size_); @@ -124,8 +125,8 @@ } bool AeadBaseEncrypter::EncryptPacket(uint64_t packet_number, - QuicStringPiece associated_data, - QuicStringPiece plaintext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext, char* output, size_t* output_length, size_t max_output_length) { @@ -147,8 +148,9 @@ memcpy(nonce_buffer + prefix_len, &packet_number, sizeof(packet_number)); } - if (!Encrypt(QuicStringPiece(nonce_buffer, nonce_size_), associated_data, - plaintext, reinterpret_cast<unsigned char*>(output))) { + if (!Encrypt(quiche::QuicheStringPiece(nonce_buffer, nonce_size_), + associated_data, plaintext, + reinterpret_cast<unsigned char*>(output))) { return false; } *output_length = ciphertext_size; @@ -175,13 +177,14 @@ return plaintext_size + auth_tag_size_; } -QuicStringPiece AeadBaseEncrypter::GetKey() const { - return QuicStringPiece(reinterpret_cast<const char*>(key_), key_size_); +quiche::QuicheStringPiece AeadBaseEncrypter::GetKey() const { + return quiche::QuicheStringPiece(reinterpret_cast<const char*>(key_), + key_size_); } -QuicStringPiece AeadBaseEncrypter::GetNoncePrefix() const { - return QuicStringPiece(reinterpret_cast<const char*>(iv_), - GetNoncePrefixSize()); +quiche::QuicheStringPiece AeadBaseEncrypter::GetNoncePrefix() const { + return quiche::QuicheStringPiece(reinterpret_cast<const char*>(iv_), + GetNoncePrefixSize()); } } // namespace quic
diff --git a/quic/core/crypto/aead_base_encrypter.h b/quic/core/crypto/aead_base_encrypter.h index 51ac8e3..5209a02 100644 --- a/quic/core/crypto/aead_base_encrypter.h +++ b/quic/core/crypto/aead_base_encrypter.h
@@ -10,7 +10,7 @@ #include "third_party/boringssl/src/include/openssl/aead.h" #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -29,12 +29,12 @@ ~AeadBaseEncrypter() override; // QuicEncrypter implementation - bool SetKey(QuicStringPiece key) override; - bool SetNoncePrefix(QuicStringPiece nonce_prefix) override; - bool SetIV(QuicStringPiece iv) override; + bool SetKey(quiche::QuicheStringPiece key) override; + bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) override; + bool SetIV(quiche::QuicheStringPiece iv) override; bool EncryptPacket(uint64_t packet_number, - QuicStringPiece associated_data, - QuicStringPiece plaintext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext, char* output, size_t* output_length, size_t max_output_length) override; @@ -43,14 +43,14 @@ size_t GetIVSize() const override; size_t GetMaxPlaintextSize(size_t ciphertext_size) const override; size_t GetCiphertextSize(size_t plaintext_size) const override; - QuicStringPiece GetKey() const override; - QuicStringPiece GetNoncePrefix() const override; + quiche::QuicheStringPiece GetKey() const override; + quiche::QuicheStringPiece GetNoncePrefix() const override; // Necessary so unit tests can explicitly specify a nonce, instead of an IV // (or nonce prefix) and packet number. - bool Encrypt(QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece plaintext, + bool Encrypt(quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext, unsigned char* output); protected:
diff --git a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc index 9ce4bda..130ebd0 100644 --- a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc +++ b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
@@ -10,8 +10,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -200,12 +201,12 @@ // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing // in an nonce and also to allocate the buffer needed for the plaintext. QuicData* DecryptWithNonce(Aes128Gcm12Decrypter* decrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece ciphertext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext) { uint64_t packet_number; - QuicStringPiece nonce_prefix(nonce.data(), - nonce.size() - sizeof(packet_number)); + quiche::QuicheStringPiece nonce_prefix(nonce.data(), + nonce.size() - sizeof(packet_number)); decrypter->SetNoncePrefix(nonce_prefix); memcpy(&packet_number, nonce.data() + nonce_prefix.size(), sizeof(packet_number)); @@ -232,14 +233,14 @@ bool has_pt = test_vectors[j].pt; // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[j].key); - std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv); - std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct); - std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad); - std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad); + std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag); std::string pt; if (has_pt) { - pt = QuicTextUtils::HexDecode(test_vectors[j].pt); + pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt); } // The test vector's lengths should look sane. Note that the lengths @@ -263,12 +264,12 @@ Aes128Gcm12Decrypter decrypter; ASSERT_TRUE(decrypter.SetKey(key)); - std::unique_ptr<QuicData> decrypted( - DecryptWithNonce(&decrypter, iv, - // This deliberately tests that the decrypter can - // handle an AAD that is set to nullptr, as opposed - // to a zero-length, non-nullptr pointer. - aad.length() ? aad : QuicStringPiece(), ciphertext)); + std::unique_ptr<QuicData> decrypted(DecryptWithNonce( + &decrypter, iv, + // This deliberately tests that the decrypter can + // handle an AAD that is set to nullptr, as opposed + // to a zero-length, non-nullptr pointer. + aad.length() ? aad : quiche::QuicheStringPiece(), ciphertext)); if (!decrypted) { EXPECT_FALSE(has_pt); continue;
diff --git a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc index d529d5d..0ca6b18 100644 --- a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc +++ b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
@@ -10,8 +10,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -158,9 +159,9 @@ // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing // in an nonce and also to allocate the buffer needed for the ciphertext. QuicData* EncryptWithNonce(Aes128Gcm12Encrypter* encrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece plaintext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext) { size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length()); std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]); @@ -181,12 +182,12 @@ const TestGroupInfo& test_info = test_group_info[i]; for (size_t j = 0; test_vectors[j].key != nullptr; j++) { // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[j].key); - std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv); - std::string pt = QuicTextUtils::HexDecode(test_vectors[j].pt); - std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad); - std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct); - std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv); + std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct); + std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag); // The test vector's lengths should look sane. Note that the lengths // in |test_info| are in bits. @@ -199,12 +200,12 @@ Aes128Gcm12Encrypter encrypter; ASSERT_TRUE(encrypter.SetKey(key)); - std::unique_ptr<QuicData> encrypted( - EncryptWithNonce(&encrypter, iv, - // This deliberately tests that the encrypter can - // handle an AAD that is set to nullptr, as opposed - // to a zero-length, non-nullptr pointer. - aad.length() ? aad : QuicStringPiece(), pt)); + std::unique_ptr<QuicData> encrypted(EncryptWithNonce( + &encrypter, iv, + // This deliberately tests that the encrypter can + // handle an AAD that is set to nullptr, as opposed + // to a zero-length, non-nullptr pointer. + aad.length() ? aad : quiche::QuicheStringPiece(), pt)); ASSERT_TRUE(encrypted.get()); // The test vectors have 16 byte authenticators but this code only uses
diff --git a/quic/core/crypto/aes_128_gcm_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_decrypter_test.cc index 579f76d..3b6ad4d 100644 --- a/quic/core/crypto/aes_128_gcm_decrypter_test.cc +++ b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
@@ -10,8 +10,8 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -200,9 +200,9 @@ // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing // in an nonce and also to allocate the buffer needed for the plaintext. QuicData* DecryptWithNonce(Aes128GcmDecrypter* decrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece ciphertext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext) { decrypter->SetIV(nonce); std::unique_ptr<char[]> output(new char[ciphertext.length()]); size_t output_length = 0; @@ -227,14 +227,14 @@ bool has_pt = test_vectors[j].pt; // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[j].key); - std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv); - std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct); - std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad); - std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad); + std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag); std::string pt; if (has_pt) { - pt = QuicTextUtils::HexDecode(test_vectors[j].pt); + pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt); } // The test vector's lengths should look sane. Note that the lengths @@ -252,12 +252,12 @@ Aes128GcmDecrypter decrypter; ASSERT_TRUE(decrypter.SetKey(key)); - std::unique_ptr<QuicData> decrypted( - DecryptWithNonce(&decrypter, iv, - // This deliberately tests that the decrypter can - // handle an AAD that is set to nullptr, as opposed - // to a zero-length, non-nullptr pointer. - aad.length() ? aad : QuicStringPiece(), ciphertext)); + std::unique_ptr<QuicData> decrypted(DecryptWithNonce( + &decrypter, iv, + // This deliberately tests that the decrypter can + // handle an AAD that is set to nullptr, as opposed + // to a zero-length, non-nullptr pointer. + aad.length() ? aad : quiche::QuicheStringPiece(), ciphertext)); if (!decrypted) { EXPECT_FALSE(has_pt); continue; @@ -274,14 +274,14 @@ TEST_F(Aes128GcmDecrypterTest, GenerateHeaderProtectionMask) { Aes128GcmDecrypter decrypter; std::string key = - QuicTextUtils::HexDecode("d9132370cb18476ab833649cf080d970"); + quiche::QuicheTextUtils::HexDecode("d9132370cb18476ab833649cf080d970"); std::string sample = - QuicTextUtils::HexDecode("d1d7998068517adb769b48b924a32c47"); + quiche::QuicheTextUtils::HexDecode("d1d7998068517adb769b48b924a32c47"); QuicDataReader sample_reader(sample.data(), sample.size()); ASSERT_TRUE(decrypter.SetHeaderProtectionKey(key)); std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader); std::string expected_mask = - QuicTextUtils::HexDecode("b132c37d6164da4ea4dc9b763aceec27"); + quiche::QuicheTextUtils::HexDecode("b132c37d6164da4ea4dc9b763aceec27"); test::CompareCharArraysWithHexError("header protection mask", mask.data(), mask.size(), expected_mask.data(), expected_mask.size());
diff --git a/quic/core/crypto/aes_128_gcm_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_encrypter_test.cc index c557e11..8e48bfd 100644 --- a/quic/core/crypto/aes_128_gcm_encrypter_test.cc +++ b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
@@ -10,8 +10,8 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -158,9 +158,9 @@ // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing // in an nonce and also to allocate the buffer needed for the ciphertext. QuicData* EncryptWithNonce(Aes128GcmEncrypter* encrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece plaintext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext) { size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length()); std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]); @@ -181,12 +181,12 @@ const TestGroupInfo& test_info = test_group_info[i]; for (size_t j = 0; test_vectors[j].key != nullptr; j++) { // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[j].key); - std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv); - std::string pt = QuicTextUtils::HexDecode(test_vectors[j].pt); - std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad); - std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct); - std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv); + std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct); + std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag); // The test vector's lengths should look sane. Note that the lengths // in |test_info| are in bits. @@ -199,12 +199,12 @@ Aes128GcmEncrypter encrypter; ASSERT_TRUE(encrypter.SetKey(key)); - std::unique_ptr<QuicData> encrypted( - EncryptWithNonce(&encrypter, iv, - // This deliberately tests that the encrypter can - // handle an AAD that is set to nullptr, as opposed - // to a zero-length, non-nullptr pointer. - aad.length() ? aad : QuicStringPiece(), pt)); + std::unique_ptr<QuicData> encrypted(EncryptWithNonce( + &encrypter, iv, + // This deliberately tests that the encrypter can + // handle an AAD that is set to nullptr, as opposed + // to a zero-length, non-nullptr pointer. + aad.length() ? aad : quiche::QuicheStringPiece(), pt)); ASSERT_TRUE(encrypted.get()); ASSERT_EQ(ct.length() + tag.length(), encrypted->length()); @@ -219,13 +219,15 @@ TEST_F(Aes128GcmEncrypterTest, EncryptPacket) { std::string key = - QuicTextUtils::HexDecode("d95a145250826c25a77b6a84fd4d34fc"); - std::string iv = QuicTextUtils::HexDecode("50c4431ebb18283448e276e2"); + quiche::QuicheTextUtils::HexDecode("d95a145250826c25a77b6a84fd4d34fc"); + std::string iv = + quiche::QuicheTextUtils::HexDecode("50c4431ebb18283448e276e2"); uint64_t packet_num = 0x13278f44; std::string aad = - QuicTextUtils::HexDecode("875d49f64a70c9cbe713278f44ff000005"); - std::string pt = QuicTextUtils::HexDecode("aa0003a250bd000000000001"); - std::string ct = QuicTextUtils::HexDecode( + quiche::QuicheTextUtils::HexDecode("875d49f64a70c9cbe713278f44ff000005"); + std::string pt = + quiche::QuicheTextUtils::HexDecode("aa0003a250bd000000000001"); + std::string ct = quiche::QuicheTextUtils::HexDecode( "7dd4708b989ee7d38a013e3656e9b37beefd05808fe1ab41e3b4f2c0"); std::vector<char> out(ct.size()); @@ -258,13 +260,13 @@ TEST_F(Aes128GcmEncrypterTest, GenerateHeaderProtectionMask) { Aes128GcmEncrypter encrypter; std::string key = - QuicTextUtils::HexDecode("d9132370cb18476ab833649cf080d970"); + quiche::QuicheTextUtils::HexDecode("d9132370cb18476ab833649cf080d970"); std::string sample = - QuicTextUtils::HexDecode("d1d7998068517adb769b48b924a32c47"); + quiche::QuicheTextUtils::HexDecode("d1d7998068517adb769b48b924a32c47"); ASSERT_TRUE(encrypter.SetHeaderProtectionKey(key)); std::string mask = encrypter.GenerateHeaderProtectionMask(sample); std::string expected_mask = - QuicTextUtils::HexDecode("b132c37d6164da4ea4dc9b763aceec27"); + quiche::QuicheTextUtils::HexDecode("b132c37d6164da4ea4dc9b763aceec27"); test::CompareCharArraysWithHexError("header protection mask", mask.data(), mask.size(), expected_mask.data(), expected_mask.size());
diff --git a/quic/core/crypto/aes_256_gcm_decrypter_test.cc b/quic/core/crypto/aes_256_gcm_decrypter_test.cc index b3d61c7..f59a532 100644 --- a/quic/core/crypto/aes_256_gcm_decrypter_test.cc +++ b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
@@ -10,8 +10,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -204,9 +205,9 @@ // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing // in an nonce and also to allocate the buffer needed for the plaintext. QuicData* DecryptWithNonce(Aes256GcmDecrypter* decrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece ciphertext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext) { decrypter->SetIV(nonce); std::unique_ptr<char[]> output(new char[ciphertext.length()]); size_t output_length = 0; @@ -231,14 +232,14 @@ bool has_pt = test_vectors[j].pt; // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[j].key); - std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv); - std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct); - std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad); - std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad); + std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag); std::string pt; if (has_pt) { - pt = QuicTextUtils::HexDecode(test_vectors[j].pt); + pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt); } // The test vector's lengths should look sane. Note that the lengths @@ -256,12 +257,12 @@ Aes256GcmDecrypter decrypter; ASSERT_TRUE(decrypter.SetKey(key)); - std::unique_ptr<QuicData> decrypted( - DecryptWithNonce(&decrypter, iv, - // This deliberately tests that the decrypter can - // handle an AAD that is set to nullptr, as opposed - // to a zero-length, non-nullptr pointer. - aad.length() ? aad : QuicStringPiece(), ciphertext)); + std::unique_ptr<QuicData> decrypted(DecryptWithNonce( + &decrypter, iv, + // This deliberately tests that the decrypter can + // handle an AAD that is set to nullptr, as opposed + // to a zero-length, non-nullptr pointer. + aad.length() ? aad : quiche::QuicheStringPiece(), ciphertext)); if (!decrypted) { EXPECT_FALSE(has_pt); continue; @@ -277,15 +278,15 @@ TEST_F(Aes256GcmDecrypterTest, GenerateHeaderProtectionMask) { Aes256GcmDecrypter decrypter; - std::string key = QuicTextUtils::HexDecode( + std::string key = quiche::QuicheTextUtils::HexDecode( "ed23ecbf54d426def5c52c3dcfc84434e62e57781d3125bb21ed91b7d3e07788"); std::string sample = - QuicTextUtils::HexDecode("4d190c474be2b8babafb49ec4e38e810"); + quiche::QuicheTextUtils::HexDecode("4d190c474be2b8babafb49ec4e38e810"); QuicDataReader sample_reader(sample.data(), sample.size()); ASSERT_TRUE(decrypter.SetHeaderProtectionKey(key)); std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader); std::string expected_mask = - QuicTextUtils::HexDecode("db9ed4e6ccd033af2eae01407199c56e"); + quiche::QuicheTextUtils::HexDecode("db9ed4e6ccd033af2eae01407199c56e"); test::CompareCharArraysWithHexError("header protection mask", mask.data(), mask.size(), expected_mask.data(), expected_mask.size());
diff --git a/quic/core/crypto/aes_256_gcm_encrypter_test.cc b/quic/core/crypto/aes_256_gcm_encrypter_test.cc index 03f6b75..5136424 100644 --- a/quic/core/crypto/aes_256_gcm_encrypter_test.cc +++ b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
@@ -10,8 +10,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -165,9 +166,9 @@ // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing // in an nonce and also to allocate the buffer needed for the ciphertext. QuicData* EncryptWithNonce(Aes256GcmEncrypter* encrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece plaintext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext) { size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length()); std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]); @@ -188,12 +189,12 @@ const TestGroupInfo& test_info = test_group_info[i]; for (size_t j = 0; test_vectors[j].key != nullptr; j++) { // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[j].key); - std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv); - std::string pt = QuicTextUtils::HexDecode(test_vectors[j].pt); - std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad); - std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct); - std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv); + std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct); + std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag); // The test vector's lengths should look sane. Note that the lengths // in |test_info| are in bits. @@ -206,12 +207,12 @@ Aes256GcmEncrypter encrypter; ASSERT_TRUE(encrypter.SetKey(key)); - std::unique_ptr<QuicData> encrypted( - EncryptWithNonce(&encrypter, iv, - // This deliberately tests that the encrypter can - // handle an AAD that is set to nullptr, as opposed - // to a zero-length, non-nullptr pointer. - aad.length() ? aad : QuicStringPiece(), pt)); + std::unique_ptr<QuicData> encrypted(EncryptWithNonce( + &encrypter, iv, + // This deliberately tests that the encrypter can + // handle an AAD that is set to nullptr, as opposed + // to a zero-length, non-nullptr pointer. + aad.length() ? aad : quiche::QuicheStringPiece(), pt)); ASSERT_TRUE(encrypted.get()); ASSERT_EQ(ct.length() + tag.length(), encrypted->length()); @@ -240,14 +241,14 @@ TEST_F(Aes256GcmEncrypterTest, GenerateHeaderProtectionMask) { Aes256GcmEncrypter encrypter; - std::string key = QuicTextUtils::HexDecode( + std::string key = quiche::QuicheTextUtils::HexDecode( "ed23ecbf54d426def5c52c3dcfc84434e62e57781d3125bb21ed91b7d3e07788"); std::string sample = - QuicTextUtils::HexDecode("4d190c474be2b8babafb49ec4e38e810"); + quiche::QuicheTextUtils::HexDecode("4d190c474be2b8babafb49ec4e38e810"); ASSERT_TRUE(encrypter.SetHeaderProtectionKey(key)); std::string mask = encrypter.GenerateHeaderProtectionMask(sample); std::string expected_mask = - QuicTextUtils::HexDecode("db9ed4e6ccd033af2eae01407199c56e"); + quiche::QuicheTextUtils::HexDecode("db9ed4e6ccd033af2eae01407199c56e"); test::CompareCharArraysWithHexError("header protection mask", mask.data(), mask.size(), expected_mask.data(), expected_mask.size());
diff --git a/quic/core/crypto/aes_base_decrypter.cc b/quic/core/crypto/aes_base_decrypter.cc index 6888ab2..f8c83f3 100644 --- a/quic/core/crypto/aes_base_decrypter.cc +++ b/quic/core/crypto/aes_base_decrypter.cc
@@ -6,10 +6,11 @@ #include "third_party/boringssl/src/include/openssl/aes.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { -bool AesBaseDecrypter::SetHeaderProtectionKey(QuicStringPiece key) { +bool AesBaseDecrypter::SetHeaderProtectionKey(quiche::QuicheStringPiece key) { if (key.size() != GetKeySize()) { QUIC_BUG << "Invalid key size for header protection"; return false; @@ -24,7 +25,7 @@ std::string AesBaseDecrypter::GenerateHeaderProtectionMask( QuicDataReader* sample_reader) { - QuicStringPiece sample; + quiche::QuicheStringPiece sample; if (!sample_reader->ReadStringPiece(&sample, AES_BLOCK_SIZE)) { return std::string(); }
diff --git a/quic/core/crypto/aes_base_decrypter.h b/quic/core/crypto/aes_base_decrypter.h index e8e1cc8..2ff63a7 100644 --- a/quic/core/crypto/aes_base_decrypter.h +++ b/quic/core/crypto/aes_base_decrypter.h
@@ -10,7 +10,7 @@ #include "third_party/boringssl/src/include/openssl/aes.h" #include "net/third_party/quiche/src/quic/core/crypto/aead_base_decrypter.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -18,7 +18,7 @@ public: using AeadBaseDecrypter::AeadBaseDecrypter; - bool SetHeaderProtectionKey(QuicStringPiece key) override; + bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override; std::string GenerateHeaderProtectionMask( QuicDataReader* sample_reader) override;
diff --git a/quic/core/crypto/aes_base_encrypter.cc b/quic/core/crypto/aes_base_encrypter.cc index cdb21b8..c620329 100644 --- a/quic/core/crypto/aes_base_encrypter.cc +++ b/quic/core/crypto/aes_base_encrypter.cc
@@ -6,10 +6,11 @@ #include "third_party/boringssl/src/include/openssl/aes.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { -bool AesBaseEncrypter::SetHeaderProtectionKey(QuicStringPiece key) { +bool AesBaseEncrypter::SetHeaderProtectionKey(quiche::QuicheStringPiece key) { if (key.size() != GetKeySize()) { QUIC_BUG << "Invalid key size for header protection: " << key.size(); return false; @@ -23,7 +24,7 @@ } std::string AesBaseEncrypter::GenerateHeaderProtectionMask( - QuicStringPiece sample) { + quiche::QuicheStringPiece sample) { if (sample.size() != AES_BLOCK_SIZE) { return std::string(); }
diff --git a/quic/core/crypto/aes_base_encrypter.h b/quic/core/crypto/aes_base_encrypter.h index e115eba..ba518fe 100644 --- a/quic/core/crypto/aes_base_encrypter.h +++ b/quic/core/crypto/aes_base_encrypter.h
@@ -10,7 +10,7 @@ #include "third_party/boringssl/src/include/openssl/aes.h" #include "net/third_party/quiche/src/quic/core/crypto/aead_base_encrypter.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -18,8 +18,9 @@ public: using AeadBaseEncrypter::AeadBaseEncrypter; - bool SetHeaderProtectionKey(QuicStringPiece key) override; - std::string GenerateHeaderProtectionMask(QuicStringPiece sample) override; + bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override; + std::string GenerateHeaderProtectionMask( + quiche::QuicheStringPiece sample) override; private: // The key used for packet number encryption.
diff --git a/quic/core/crypto/cert_compressor.cc b/quic/core/crypto/cert_compressor.cc index 45d842d..a1ba748 100644 --- a/quic/core/crypto/cert_compressor.cc +++ b/quic/core/crypto/cert_compressor.cc
@@ -10,6 +10,7 @@ #include <utility> #include "net/third_party/quiche/src/quic/core/quic_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "third_party/zlib/zlib.h" namespace quic { @@ -174,10 +175,11 @@ // efficiently represent |certs| to a peer who has the common sets identified // by |client_common_set_hashes| and who has cached the certificates with the // 64-bit, FNV-1a hashes in |client_cached_cert_hashes|. -std::vector<CertEntry> MatchCerts(const std::vector<std::string>& certs, - QuicStringPiece client_common_set_hashes, - QuicStringPiece client_cached_cert_hashes, - const CommonCertSets* common_sets) { +std::vector<CertEntry> MatchCerts( + const std::vector<std::string>& certs, + quiche::QuicheStringPiece client_common_set_hashes, + quiche::QuicheStringPiece client_cached_cert_hashes, + const CommonCertSets* common_sets) { std::vector<CertEntry> entries; entries.reserve(certs.size()); @@ -328,12 +330,12 @@ // |in_out| and writes them to |out_entries|. CACHED and COMMON entries are // resolved using |cached_certs| and |common_sets| and written to |out_certs|. // |in_out| is updated to contain the trailing data. -bool ParseEntries(QuicStringPiece* in_out, +bool ParseEntries(quiche::QuicheStringPiece* in_out, const std::vector<std::string>& cached_certs, const CommonCertSets* common_sets, std::vector<CertEntry>* out_entries, std::vector<std::string>* out_certs) { - QuicStringPiece in = *in_out; + quiche::QuicheStringPiece in = *in_out; std::vector<uint64_t> cached_hashes; out_entries->clear(); @@ -392,7 +394,7 @@ memcpy(&entry.index, in.data(), sizeof(uint32_t)); in.remove_prefix(sizeof(uint32_t)); - QuicStringPiece cert = + quiche::QuicheStringPiece cert = common_sets->GetCert(entry.set_hash, entry.index); if (cert.empty()) { return false; @@ -450,8 +452,8 @@ // static std::string CertCompressor::CompressChain( const std::vector<std::string>& certs, - QuicStringPiece client_common_set_hashes, - QuicStringPiece client_cached_cert_hashes, + quiche::QuicheStringPiece client_common_set_hashes, + quiche::QuicheStringPiece client_cached_cert_hashes, const CommonCertSets* common_sets) { const std::vector<CertEntry> entries = MatchCerts( certs, client_common_set_hashes, client_cached_cert_hashes, common_sets); @@ -551,7 +553,7 @@ // static bool CertCompressor::DecompressChain( - QuicStringPiece in, + quiche::QuicheStringPiece in, const std::vector<std::string>& cached_certs, const CommonCertSets* common_sets, std::vector<std::string>* out_certs) { @@ -562,7 +564,7 @@ DCHECK_EQ(entries.size(), out_certs->size()); std::unique_ptr<uint8_t[]> uncompressed_data; - QuicStringPiece uncompressed; + quiche::QuicheStringPiece uncompressed; if (!in.empty()) { if (in.size() < sizeof(uint32_t)) { @@ -607,7 +609,7 @@ return false; } - uncompressed = QuicStringPiece( + uncompressed = quiche::QuicheStringPiece( reinterpret_cast<char*>(uncompressed_data.get()), uncompressed_size); }
diff --git a/quic/core/crypto/cert_compressor.h b/quic/core/crypto/cert_compressor.h index ca696bd..dfb4d21 100644 --- a/quic/core/crypto/cert_compressor.h +++ b/quic/core/crypto/cert_compressor.h
@@ -11,7 +11,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/common_cert_set.h" #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -36,16 +36,17 @@ // sets known locally and |client_common_set_hashes| contains the hashes of // the common sets known to the peer. |client_cached_cert_hashes| contains // 64-bit, FNV-1a hashes of certificates that the peer already possesses. - static std::string CompressChain(const std::vector<std::string>& certs, - QuicStringPiece client_common_set_hashes, - QuicStringPiece client_cached_cert_hashes, - const CommonCertSets* common_sets); + static std::string CompressChain( + const std::vector<std::string>& certs, + quiche::QuicheStringPiece client_common_set_hashes, + quiche::QuicheStringPiece client_cached_cert_hashes, + const CommonCertSets* common_sets); // DecompressChain decompresses the result of |CompressChain|, given in |in|, // into a series of certificates that are written to |out_certs|. // |cached_certs| contains certificates that the peer may have omitted and // |common_sets| contains the common certificate sets known locally. - static bool DecompressChain(QuicStringPiece in, + static bool DecompressChain(quiche::QuicheStringPiece in, const std::vector<std::string>& cached_certs, const CommonCertSets* common_sets, std::vector<std::string>* out_certs);
diff --git a/quic/core/crypto/cert_compressor_test.cc b/quic/core/crypto/cert_compressor_test.cc index 1341f79..a7517f4 100644 --- a/quic/core/crypto/cert_compressor_test.cc +++ b/quic/core/crypto/cert_compressor_test.cc
@@ -9,8 +9,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { namespace test { @@ -20,8 +21,8 @@ TEST_F(CertCompressorTest, EmptyChain) { std::vector<std::string> chain; const std::string compressed = CertCompressor::CompressChain( - chain, QuicStringPiece(), QuicStringPiece(), nullptr); - EXPECT_EQ("00", QuicTextUtils::HexEncode(compressed)); + chain, quiche::QuicheStringPiece(), quiche::QuicheStringPiece(), nullptr); + EXPECT_EQ("00", quiche::QuicheTextUtils::HexEncode(compressed)); std::vector<std::string> chain2, cached_certs; ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs, nullptr, @@ -33,9 +34,10 @@ std::vector<std::string> chain; chain.push_back("testcert"); const std::string compressed = CertCompressor::CompressChain( - chain, QuicStringPiece(), QuicStringPiece(), nullptr); + chain, quiche::QuicheStringPiece(), quiche::QuicheStringPiece(), nullptr); ASSERT_GE(compressed.size(), 2u); - EXPECT_EQ("0100", QuicTextUtils::HexEncode(compressed.substr(0, 2))); + EXPECT_EQ("0100", + quiche::QuicheTextUtils::HexEncode(compressed.substr(0, 2))); std::vector<std::string> chain2, cached_certs; ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs, nullptr, @@ -52,15 +54,15 @@ crypto_test_utils::MockCommonCertSets(chain[0], set_hash, 1)); const std::string compressed = CertCompressor::CompressChain( chain, - QuicStringPiece(reinterpret_cast<const char*>(&set_hash), - sizeof(set_hash)), - QuicStringPiece(), common_sets.get()); + quiche::QuicheStringPiece(reinterpret_cast<const char*>(&set_hash), + sizeof(set_hash)), + quiche::QuicheStringPiece(), common_sets.get()); EXPECT_EQ( "03" /* common */ "2a00000000000000" /* set hash 42 */ "01000000" /* index 1 */ "00" /* end of list */, - QuicTextUtils::HexEncode(compressed)); + quiche::QuicheTextUtils::HexEncode(compressed)); std::vector<std::string> chain2, cached_certs; ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs, @@ -73,13 +75,14 @@ std::vector<std::string> chain; chain.push_back("testcert"); uint64_t hash = QuicUtils::FNV1a_64_Hash(chain[0]); - QuicStringPiece hash_bytes(reinterpret_cast<char*>(&hash), sizeof(hash)); + quiche::QuicheStringPiece hash_bytes(reinterpret_cast<char*>(&hash), + sizeof(hash)); const std::string compressed = CertCompressor::CompressChain( - chain, QuicStringPiece(), hash_bytes, nullptr); + chain, quiche::QuicheStringPiece(), hash_bytes, nullptr); - EXPECT_EQ("02" /* cached */ + QuicTextUtils::HexEncode(hash_bytes) + + EXPECT_EQ("02" /* cached */ + quiche::QuicheTextUtils::HexEncode(hash_bytes) + "00" /* end of list */, - QuicTextUtils::HexEncode(compressed)); + quiche::QuicheTextUtils::HexEncode(compressed)); std::vector<std::string> cached_certs, chain2; cached_certs.push_back(chain[0]); @@ -93,26 +96,26 @@ std::vector<std::string> cached_certs, chain; EXPECT_FALSE(CertCompressor::DecompressChain( - QuicTextUtils::HexEncode("04") /* bad entry type */, cached_certs, - nullptr, &chain)); + quiche::QuicheTextUtils::HexEncode("04") /* bad entry type */, + cached_certs, nullptr, &chain)); EXPECT_FALSE(CertCompressor::DecompressChain( - QuicTextUtils::HexEncode("01") /* no terminator */, cached_certs, nullptr, - &chain)); + quiche::QuicheTextUtils::HexEncode("01") /* no terminator */, + cached_certs, nullptr, &chain)); EXPECT_FALSE(CertCompressor::DecompressChain( - QuicTextUtils::HexEncode("0200") /* hash truncated */, cached_certs, - nullptr, &chain)); + quiche::QuicheTextUtils::HexEncode("0200") /* hash truncated */, + cached_certs, nullptr, &chain)); EXPECT_FALSE(CertCompressor::DecompressChain( - QuicTextUtils::HexEncode("0300") /* hash and index truncated */, + quiche::QuicheTextUtils::HexEncode("0300") /* hash and index truncated */, cached_certs, nullptr, &chain)); /* without a CommonCertSets */ EXPECT_FALSE(CertCompressor::DecompressChain( - QuicTextUtils::HexEncode("03" - "0000000000000000" - "00000000"), + quiche::QuicheTextUtils::HexEncode("03" + "0000000000000000" + "00000000"), cached_certs, nullptr, &chain)); std::unique_ptr<CommonCertSets> common_sets( @@ -120,9 +123,9 @@ /* incorrect hash and index */ EXPECT_FALSE(CertCompressor::DecompressChain( - QuicTextUtils::HexEncode("03" - "a200000000000000" - "00000000"), + quiche::QuicheTextUtils::HexEncode("03" + "a200000000000000" + "00000000"), cached_certs, nullptr, &chain)); }
diff --git a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc index 930af24..7be2251 100644 --- a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc +++ b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
@@ -9,8 +9,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -113,12 +114,12 @@ // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing // in an nonce and also to allocate the buffer needed for the plaintext. QuicData* DecryptWithNonce(ChaCha20Poly1305Decrypter* decrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece ciphertext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext) { uint64_t packet_number; - QuicStringPiece nonce_prefix(nonce.data(), - nonce.size() - sizeof(packet_number)); + quiche::QuicheStringPiece nonce_prefix(nonce.data(), + nonce.size() - sizeof(packet_number)); decrypter->SetNoncePrefix(nonce_prefix); memcpy(&packet_number, nonce.data() + nonce_prefix.size(), sizeof(packet_number)); @@ -141,14 +142,15 @@ bool has_pt = test_vectors[i].pt; // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[i].key); - std::string iv = QuicTextUtils::HexDecode(test_vectors[i].iv); - std::string fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed); - std::string aad = QuicTextUtils::HexDecode(test_vectors[i].aad); - std::string ct = QuicTextUtils::HexDecode(test_vectors[i].ct); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[i].key); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[i].iv); + std::string fixed = + quiche::QuicheTextUtils::HexDecode(test_vectors[i].fixed); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[i].aad); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[i].ct); std::string pt; if (has_pt) { - pt = QuicTextUtils::HexDecode(test_vectors[i].pt); + pt = quiche::QuicheTextUtils::HexDecode(test_vectors[i].pt); } ChaCha20Poly1305Decrypter decrypter; @@ -157,7 +159,8 @@ &decrypter, fixed + iv, // This deliberately tests that the decrypter can handle an AAD that // is set to nullptr, as opposed to a zero-length, non-nullptr pointer. - QuicStringPiece(aad.length() ? aad.data() : nullptr, aad.length()), + quiche::QuicheStringPiece(aad.length() ? aad.data() : nullptr, + aad.length()), ct)); if (!decrypted) { EXPECT_FALSE(has_pt);
diff --git a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc index 4584d96..edb81a4 100644 --- a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc +++ b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
@@ -11,8 +11,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -70,9 +71,9 @@ // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing // in an nonce and also to allocate the buffer needed for the ciphertext. QuicData* EncryptWithNonce(ChaCha20Poly1305Encrypter* encrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece plaintext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext) { size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length()); std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]); @@ -90,7 +91,7 @@ ChaCha20Poly1305Encrypter encrypter; ChaCha20Poly1305Decrypter decrypter; - std::string key = QuicTextUtils::HexDecode(test_vectors[0].key); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[0].key); ASSERT_TRUE(encrypter.SetKey(key)); ASSERT_TRUE(decrypter.SetKey(key)); ASSERT_TRUE(encrypter.SetNoncePrefix("abcd")); @@ -104,7 +105,7 @@ ASSERT_TRUE(encrypter.EncryptPacket(packet_number, associated_data, plaintext, encrypted, &len, QUIC_ARRAYSIZE(encrypted))); - QuicStringPiece ciphertext(encrypted, len); + quiche::QuicheStringPiece ciphertext(encrypted, len); char decrypted[1024]; ASSERT_TRUE(decrypter.DecryptPacket(packet_number, associated_data, ciphertext, decrypted, &len, @@ -114,12 +115,13 @@ TEST_F(ChaCha20Poly1305EncrypterTest, Encrypt) { for (size_t i = 0; test_vectors[i].key != nullptr; i++) { // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[i].key); - std::string pt = QuicTextUtils::HexDecode(test_vectors[i].pt); - std::string iv = QuicTextUtils::HexDecode(test_vectors[i].iv); - std::string fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed); - std::string aad = QuicTextUtils::HexDecode(test_vectors[i].aad); - std::string ct = QuicTextUtils::HexDecode(test_vectors[i].ct); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[i].key); + std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[i].pt); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[i].iv); + std::string fixed = + quiche::QuicheTextUtils::HexDecode(test_vectors[i].fixed); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[i].aad); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[i].ct); ChaCha20Poly1305Encrypter encrypter; ASSERT_TRUE(encrypter.SetKey(key)); @@ -127,7 +129,8 @@ &encrypter, fixed + iv, // This deliberately tests that the encrypter can handle an AAD that // is set to nullptr, as opposed to a zero-length, non-nullptr pointer. - QuicStringPiece(aad.length() ? aad.data() : nullptr, aad.length()), + quiche::QuicheStringPiece(aad.length() ? aad.data() : nullptr, + aad.length()), pt)); ASSERT_TRUE(encrypted.get()); EXPECT_EQ(12u, ct.size() - pt.size());
diff --git a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc index 90052d6..d4fcd2b 100644 --- a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc +++ b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
@@ -9,8 +9,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -113,9 +114,9 @@ // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing // in an nonce and also to allocate the buffer needed for the plaintext. QuicData* DecryptWithNonce(ChaCha20Poly1305TlsDecrypter* decrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece ciphertext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext) { decrypter->SetIV(nonce); std::unique_ptr<char[]> output(new char[ciphertext.length()]); size_t output_length = 0; @@ -136,14 +137,15 @@ bool has_pt = test_vectors[i].pt; // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[i].key); - std::string iv = QuicTextUtils::HexDecode(test_vectors[i].iv); - std::string fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed); - std::string aad = QuicTextUtils::HexDecode(test_vectors[i].aad); - std::string ct = QuicTextUtils::HexDecode(test_vectors[i].ct); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[i].key); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[i].iv); + std::string fixed = + quiche::QuicheTextUtils::HexDecode(test_vectors[i].fixed); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[i].aad); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[i].ct); std::string pt; if (has_pt) { - pt = QuicTextUtils::HexDecode(test_vectors[i].pt); + pt = quiche::QuicheTextUtils::HexDecode(test_vectors[i].pt); } ChaCha20Poly1305TlsDecrypter decrypter; @@ -152,7 +154,8 @@ &decrypter, fixed + iv, // This deliberately tests that the decrypter can handle an AAD that // is set to nullptr, as opposed to a zero-length, non-nullptr pointer. - QuicStringPiece(aad.length() ? aad.data() : nullptr, aad.length()), + quiche::QuicheStringPiece(aad.length() ? aad.data() : nullptr, + aad.length()), ct)); if (!decrypted) { EXPECT_FALSE(has_pt); @@ -169,14 +172,14 @@ TEST_F(ChaCha20Poly1305TlsDecrypterTest, GenerateHeaderProtectionMask) { ChaCha20Poly1305TlsDecrypter decrypter; - std::string key = QuicTextUtils::HexDecode( + std::string key = quiche::QuicheTextUtils::HexDecode( "6a067f432787bd6034dd3f08f07fc9703a27e58c70e2d88d948b7f6489923cc7"); std::string sample = - QuicTextUtils::HexDecode("1210d91cceb45c716b023f492c29e612"); + quiche::QuicheTextUtils::HexDecode("1210d91cceb45c716b023f492c29e612"); QuicDataReader sample_reader(sample.data(), sample.size()); ASSERT_TRUE(decrypter.SetHeaderProtectionKey(key)); std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader); - std::string expected_mask = QuicTextUtils::HexDecode("1cc2cd98dc"); + std::string expected_mask = quiche::QuicheTextUtils::HexDecode("1cc2cd98dc"); test::CompareCharArraysWithHexError("header protection mask", mask.data(), mask.size(), expected_mask.data(), expected_mask.size());
diff --git a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc index ef4a8e8..a62c843 100644 --- a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc +++ b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
@@ -11,8 +11,9 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace { @@ -70,9 +71,9 @@ // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing // in an nonce and also to allocate the buffer needed for the ciphertext. QuicData* EncryptWithNonce(ChaCha20Poly1305TlsEncrypter* encrypter, - QuicStringPiece nonce, - QuicStringPiece associated_data, - QuicStringPiece plaintext) { + quiche::QuicheStringPiece nonce, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext) { size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length()); std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]); @@ -90,7 +91,7 @@ ChaCha20Poly1305TlsEncrypter encrypter; ChaCha20Poly1305TlsDecrypter decrypter; - std::string key = QuicTextUtils::HexDecode(test_vectors[0].key); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[0].key); ASSERT_TRUE(encrypter.SetKey(key)); ASSERT_TRUE(decrypter.SetKey(key)); ASSERT_TRUE(encrypter.SetIV("abcdefghijkl")); @@ -104,7 +105,7 @@ ASSERT_TRUE(encrypter.EncryptPacket(packet_number, associated_data, plaintext, encrypted, &len, QUIC_ARRAYSIZE(encrypted))); - QuicStringPiece ciphertext(encrypted, len); + quiche::QuicheStringPiece ciphertext(encrypted, len); char decrypted[1024]; ASSERT_TRUE(decrypter.DecryptPacket(packet_number, associated_data, ciphertext, decrypted, &len, @@ -114,12 +115,13 @@ TEST_F(ChaCha20Poly1305TlsEncrypterTest, Encrypt) { for (size_t i = 0; test_vectors[i].key != nullptr; i++) { // Decode the test vector. - std::string key = QuicTextUtils::HexDecode(test_vectors[i].key); - std::string pt = QuicTextUtils::HexDecode(test_vectors[i].pt); - std::string iv = QuicTextUtils::HexDecode(test_vectors[i].iv); - std::string fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed); - std::string aad = QuicTextUtils::HexDecode(test_vectors[i].aad); - std::string ct = QuicTextUtils::HexDecode(test_vectors[i].ct); + std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[i].key); + std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[i].pt); + std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[i].iv); + std::string fixed = + quiche::QuicheTextUtils::HexDecode(test_vectors[i].fixed); + std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[i].aad); + std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[i].ct); ChaCha20Poly1305TlsEncrypter encrypter; ASSERT_TRUE(encrypter.SetKey(key)); @@ -127,7 +129,8 @@ &encrypter, fixed + iv, // This deliberately tests that the encrypter can handle an AAD that // is set to nullptr, as opposed to a zero-length, non-nullptr pointer. - QuicStringPiece(aad.length() ? aad.data() : nullptr, aad.length()), + quiche::QuicheStringPiece(aad.length() ? aad.data() : nullptr, + aad.length()), pt)); ASSERT_TRUE(encrypted.get()); EXPECT_EQ(16u, ct.size() - pt.size()); @@ -155,13 +158,13 @@ TEST_F(ChaCha20Poly1305TlsEncrypterTest, GenerateHeaderProtectionMask) { ChaCha20Poly1305TlsEncrypter encrypter; - std::string key = QuicTextUtils::HexDecode( + std::string key = quiche::QuicheTextUtils::HexDecode( "6a067f432787bd6034dd3f08f07fc9703a27e58c70e2d88d948b7f6489923cc7"); std::string sample = - QuicTextUtils::HexDecode("1210d91cceb45c716b023f492c29e612"); + quiche::QuicheTextUtils::HexDecode("1210d91cceb45c716b023f492c29e612"); ASSERT_TRUE(encrypter.SetHeaderProtectionKey(key)); std::string mask = encrypter.GenerateHeaderProtectionMask(sample); - std::string expected_mask = QuicTextUtils::HexDecode("1cc2cd98dc"); + std::string expected_mask = quiche::QuicheTextUtils::HexDecode("1cc2cd98dc"); test::CompareCharArraysWithHexError("header protection mask", mask.data(), mask.size(), expected_mask.data(), expected_mask.size());
diff --git a/quic/core/crypto/chacha_base_decrypter.cc b/quic/core/crypto/chacha_base_decrypter.cc index c67fd89..d7a4984 100644 --- a/quic/core/crypto/chacha_base_decrypter.cc +++ b/quic/core/crypto/chacha_base_decrypter.cc
@@ -11,10 +11,12 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { -bool ChaChaBaseDecrypter::SetHeaderProtectionKey(QuicStringPiece key) { +bool ChaChaBaseDecrypter::SetHeaderProtectionKey( + quiche::QuicheStringPiece key) { if (key.size() != GetKeySize()) { QUIC_BUG << "Invalid key size for header protection"; return false; @@ -25,7 +27,7 @@ std::string ChaChaBaseDecrypter::GenerateHeaderProtectionMask( QuicDataReader* sample_reader) { - QuicStringPiece sample; + quiche::QuicheStringPiece sample; if (!sample_reader->ReadStringPiece(&sample, 16)) { return std::string(); }
diff --git a/quic/core/crypto/chacha_base_decrypter.h b/quic/core/crypto/chacha_base_decrypter.h index d7ad741..24ca820 100644 --- a/quic/core/crypto/chacha_base_decrypter.h +++ b/quic/core/crypto/chacha_base_decrypter.h
@@ -9,7 +9,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/aead_base_decrypter.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -17,7 +17,7 @@ public: using AeadBaseDecrypter::AeadBaseDecrypter; - bool SetHeaderProtectionKey(QuicStringPiece key) override; + bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override; std::string GenerateHeaderProtectionMask( QuicDataReader* sample_reader) override;
diff --git a/quic/core/crypto/chacha_base_encrypter.cc b/quic/core/crypto/chacha_base_encrypter.cc index 9c465a9..1e0d80f 100644 --- a/quic/core/crypto/chacha_base_encrypter.cc +++ b/quic/core/crypto/chacha_base_encrypter.cc
@@ -9,10 +9,12 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { -bool ChaChaBaseEncrypter::SetHeaderProtectionKey(QuicStringPiece key) { +bool ChaChaBaseEncrypter::SetHeaderProtectionKey( + quiche::QuicheStringPiece key) { if (key.size() != GetKeySize()) { QUIC_BUG << "Invalid key size for header protection"; return false; @@ -22,7 +24,7 @@ } std::string ChaChaBaseEncrypter::GenerateHeaderProtectionMask( - QuicStringPiece sample) { + quiche::QuicheStringPiece sample) { if (sample.size() != 16) { return std::string(); }
diff --git a/quic/core/crypto/chacha_base_encrypter.h b/quic/core/crypto/chacha_base_encrypter.h index 7c086ac..16d1df1 100644 --- a/quic/core/crypto/chacha_base_encrypter.h +++ b/quic/core/crypto/chacha_base_encrypter.h
@@ -9,7 +9,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/aead_base_encrypter.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -17,8 +17,9 @@ public: using AeadBaseEncrypter::AeadBaseEncrypter; - bool SetHeaderProtectionKey(QuicStringPiece key) override; - std::string GenerateHeaderProtectionMask(QuicStringPiece sample) override; + bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override; + std::string GenerateHeaderProtectionMask( + quiche::QuicheStringPiece sample) override; private: // The key used for packet number encryption.
diff --git a/quic/core/crypto/channel_id.cc b/quic/core/crypto/channel_id.cc index 0c4a3e9..facd552 100644 --- a/quic/core/crypto/channel_id.cc +++ b/quic/core/crypto/channel_id.cc
@@ -11,6 +11,7 @@ #include "third_party/boringssl/src/include/openssl/ecdsa.h" #include "third_party/boringssl/src/include/openssl/nid.h" #include "third_party/boringssl/src/include/openssl/sha.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -20,16 +21,16 @@ const char ChannelIDVerifier::kClientToServerStr[] = "client -> server"; // static -bool ChannelIDVerifier::Verify(QuicStringPiece key, - QuicStringPiece signed_data, - QuicStringPiece signature) { +bool ChannelIDVerifier::Verify(quiche::QuicheStringPiece key, + quiche::QuicheStringPiece signed_data, + quiche::QuicheStringPiece signature) { return VerifyRaw(key, signed_data, signature, true); } // static -bool ChannelIDVerifier::VerifyRaw(QuicStringPiece key, - QuicStringPiece signed_data, - QuicStringPiece signature, +bool ChannelIDVerifier::VerifyRaw(quiche::QuicheStringPiece key, + quiche::QuicheStringPiece signed_data, + quiche::QuicheStringPiece signature, bool is_channel_id_signature) { if (key.size() != 32 * 2 || signature.size() != 32 * 2) { return false;
diff --git a/quic/core/crypto/channel_id.h b/quic/core/crypto/channel_id.h index 8719394..c04aac3 100644 --- a/quic/core/crypto/channel_id.h +++ b/quic/core/crypto/channel_id.h
@@ -10,7 +10,7 @@ #include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -30,17 +30,17 @@ // Verify returns true iff |signature| is a valid signature of |signed_data| // by |key|. - static bool Verify(QuicStringPiece key, - QuicStringPiece signed_data, - QuicStringPiece signature); + static bool Verify(quiche::QuicheStringPiece key, + quiche::QuicheStringPiece signed_data, + quiche::QuicheStringPiece signature); // FOR TESTING ONLY: VerifyRaw returns true iff |signature| is a valid // signature of |signed_data| by |key|. |is_channel_id_signature| indicates // whether |signature| is a ChannelID signature (with kContextStr prepended // to the data to be signed). - static bool VerifyRaw(QuicStringPiece key, - QuicStringPiece signed_data, - QuicStringPiece signature, + static bool VerifyRaw(quiche::QuicheStringPiece key, + quiche::QuicheStringPiece signed_data, + quiche::QuicheStringPiece signature, bool is_channel_id_signature); };
diff --git a/quic/core/crypto/channel_id_test.cc b/quic/core/crypto/channel_id_test.cc index c69e328..d4a14cd 100644 --- a/quic/core/crypto/channel_id_test.cc +++ b/quic/core/crypto/channel_id_test.cc
@@ -9,6 +9,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { namespace test { @@ -277,8 +278,9 @@ EXPECT_EQ( test_vector[i].result, ChannelIDVerifier::VerifyRaw( - QuicStringPiece(key, sizeof(key)), QuicStringPiece(msg, msg_len), - QuicStringPiece(signature, sizeof(signature)), false)); + quiche::QuicheStringPiece(key, sizeof(key)), + quiche::QuicheStringPiece(msg, msg_len), + quiche::QuicheStringPiece(signature, sizeof(signature)), false)); } }
diff --git a/quic/core/crypto/common_cert_set.cc b/quic/core/crypto/common_cert_set.cc index 2f337f4..be4883b 100644 --- a/quic/core/crypto/common_cert_set.cc +++ b/quic/core/crypto/common_cert_set.cc
@@ -8,6 +8,7 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -55,7 +56,7 @@ // Compare returns a value less than, equal to or greater than zero if |a| is // lexicographically less than, equal to or greater than |b|, respectively. -int Compare(QuicStringPiece a, const unsigned char* b, size_t b_len) { +int Compare(quiche::QuicheStringPiece a, const unsigned char* b, size_t b_len) { size_t len = a.size(); if (len > b_len) { len = b_len; @@ -78,16 +79,18 @@ class CommonCertSetsQUIC : public CommonCertSets { public: // CommonCertSets interface. - QuicStringPiece GetCommonHashes() const override { - return QuicStringPiece(reinterpret_cast<const char*>(kSetHashes), - sizeof(uint64_t) * QUIC_ARRAYSIZE(kSetHashes)); + quiche::QuicheStringPiece GetCommonHashes() const override { + return quiche::QuicheStringPiece( + reinterpret_cast<const char*>(kSetHashes), + sizeof(uint64_t) * QUIC_ARRAYSIZE(kSetHashes)); } - QuicStringPiece GetCert(uint64_t hash, uint32_t index) const override { + quiche::QuicheStringPiece GetCert(uint64_t hash, + uint32_t index) const override { for (size_t i = 0; i < QUIC_ARRAYSIZE(kSets); i++) { if (kSets[i].hash == hash) { if (index < kSets[i].num_certs) { - return QuicStringPiece( + return quiche::QuicheStringPiece( reinterpret_cast<const char*>(kSets[i].certs[index]), kSets[i].lens[index]); } @@ -95,11 +98,11 @@ } } - return QuicStringPiece(); + return quiche::QuicheStringPiece(); } - bool MatchCert(QuicStringPiece cert, - QuicStringPiece common_set_hashes, + bool MatchCert(quiche::QuicheStringPiece cert, + quiche::QuicheStringPiece common_set_hashes, uint64_t* out_hash, uint32_t* out_index) const override { if (common_set_hashes.size() % sizeof(uint64_t) != 0) {
diff --git a/quic/core/crypto/common_cert_set.h b/quic/core/crypto/common_cert_set.h index 57c0fea..af211ad 100644 --- a/quic/core/crypto/common_cert_set.h +++ b/quic/core/crypto/common_cert_set.h
@@ -9,7 +9,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -22,22 +22,23 @@ // GetInstanceQUIC returns the standard QUIC common certificate sets. static const CommonCertSets* GetInstanceQUIC(); - // GetCommonHashes returns a QuicStringPiece containing the hashes of common - // sets supported by this object. The 64-bit hashes are concatenated in the - // QuicStringPiece. - virtual QuicStringPiece GetCommonHashes() const = 0; + // GetCommonHashes returns a quiche::QuicheStringPiece containing the hashes + // of common sets supported by this object. The 64-bit hashes are concatenated + // in the quiche::QuicheStringPiece. + virtual quiche::QuicheStringPiece GetCommonHashes() const = 0; // GetCert returns a specific certificate (at index |index|) in the common // set identified by |hash|. If no such certificate is known, an empty - // QuicStringPiece is returned. - virtual QuicStringPiece GetCert(uint64_t hash, uint32_t index) const = 0; + // quiche::QuicheStringPiece is returned. + virtual quiche::QuicheStringPiece GetCert(uint64_t hash, + uint32_t index) const = 0; // MatchCert tries to find |cert| in one of the common certificate sets // identified by |common_set_hashes|. On success it puts the hash of the // set in |out_hash|, the index of |cert| in the set in |out_index| and // returns true. Otherwise it returns false. - virtual bool MatchCert(QuicStringPiece cert, - QuicStringPiece common_set_hashes, + virtual bool MatchCert(quiche::QuicheStringPiece cert, + quiche::QuicheStringPiece common_set_hashes, uint64_t* out_hash, uint32_t* out_index) const = 0; };
diff --git a/quic/core/crypto/common_cert_set_test.cc b/quic/core/crypto/common_cert_set_test.cc index 04720e1..148914d 100644 --- a/quic/core/crypto/common_cert_set_test.cc +++ b/quic/core/crypto/common_cert_set_test.cc
@@ -7,6 +7,7 @@ #include <cstdint> #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { namespace test { @@ -192,8 +193,8 @@ class CommonCertSetsTest : public QuicTest {}; TEST_F(CommonCertSetsTest, FindGIA_2) { - QuicStringPiece gia(reinterpret_cast<const char*>(kGIACertificate2), - sizeof(kGIACertificate2)); + quiche::QuicheStringPiece gia(reinterpret_cast<const char*>(kGIACertificate2), + sizeof(kGIACertificate2)); const CommonCertSets* sets(CommonCertSets::GetInstanceQUIC()); // Common Cert Set 2's hash. @@ -202,19 +203,20 @@ uint32_t index; ASSERT_TRUE(sets->MatchCert( gia, - QuicStringPiece(reinterpret_cast<const char*>(&in_hash), sizeof(in_hash)), + quiche::QuicheStringPiece(reinterpret_cast<const char*>(&in_hash), + sizeof(in_hash)), &hash, &index)); EXPECT_EQ(in_hash, hash); - QuicStringPiece gia_copy = sets->GetCert(hash, index); + quiche::QuicheStringPiece gia_copy = sets->GetCert(hash, index); EXPECT_FALSE(gia_copy.empty()); ASSERT_EQ(gia.size(), gia_copy.size()); EXPECT_EQ(0, memcmp(gia.data(), gia_copy.data(), gia.size())); } TEST_F(CommonCertSetsTest, FindGIA_3) { - QuicStringPiece gia(reinterpret_cast<const char*>(kGIACertificate3), - sizeof(kGIACertificate3)); + quiche::QuicheStringPiece gia(reinterpret_cast<const char*>(kGIACertificate3), + sizeof(kGIACertificate3)); const CommonCertSets* sets(CommonCertSets::GetInstanceQUIC()); // Common Cert Set 3's hash. @@ -223,11 +225,12 @@ uint32_t index; ASSERT_TRUE(sets->MatchCert( gia, - QuicStringPiece(reinterpret_cast<const char*>(&in_hash), sizeof(in_hash)), + quiche::QuicheStringPiece(reinterpret_cast<const char*>(&in_hash), + sizeof(in_hash)), &hash, &index)); EXPECT_EQ(in_hash, hash); - QuicStringPiece gia_copy = sets->GetCert(hash, index); + quiche::QuicheStringPiece gia_copy = sets->GetCert(hash, index); EXPECT_FALSE(gia_copy.empty()); ASSERT_EQ(gia.size(), gia_copy.size()); EXPECT_EQ(0, memcmp(gia.data(), gia_copy.data(), gia.size())); @@ -235,13 +238,14 @@ TEST_F(CommonCertSetsTest, NonMatch) { const CommonCertSets* sets(CommonCertSets::GetInstanceQUIC()); - QuicStringPiece not_a_cert("hello"); + quiche::QuicheStringPiece not_a_cert("hello"); const uint64_t in_hash = UINT64_C(0xc9fef74053f99f39); uint64_t hash; uint32_t index; EXPECT_FALSE(sets->MatchCert( not_a_cert, - QuicStringPiece(reinterpret_cast<const char*>(&in_hash), sizeof(in_hash)), + quiche::QuicheStringPiece(reinterpret_cast<const char*>(&in_hash), + sizeof(in_hash)), &hash, &index)); }
diff --git a/quic/core/crypto/crypto_framer.cc b/quic/core/crypto/crypto_framer.cc index c3dd2aa..6a18884 100644 --- a/quic/core/crypto/crypto_framer.cc +++ b/quic/core/crypto/crypto_framer.cc
@@ -13,9 +13,9 @@ #include "net/third_party/quiche/src/quic/core/quic_packets.h" #include "net/third_party/quiche/src/quic/platform/api/quic_fallthrough.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -60,7 +60,7 @@ // static std::unique_ptr<CryptoHandshakeMessage> CryptoFramer::ParseMessage( - QuicStringPiece in) { + quiche::QuicheStringPiece in) { OneShotVisitor visitor; CryptoFramer framer; @@ -81,12 +81,12 @@ return error_detail_; } -bool CryptoFramer::ProcessInput(QuicStringPiece input, +bool CryptoFramer::ProcessInput(quiche::QuicheStringPiece input, EncryptionLevel /*level*/) { return ProcessInput(input); } -bool CryptoFramer::ProcessInput(QuicStringPiece input) { +bool CryptoFramer::ProcessInput(quiche::QuicheStringPiece input) { DCHECK_EQ(QUIC_NO_ERROR, error_); if (error_ != QUIC_NO_ERROR) { return false; @@ -121,7 +121,7 @@ QuicDataReader reader(buffer_.data(), buffer_.length(), quiche::HOST_BYTE_ORDER); for (const std::pair<QuicTag, size_t>& item : tags_and_lengths_) { - QuicStringPiece value; + quiche::QuicheStringPiece value; if (reader.BytesRemaining() < item.second) { break; } @@ -243,7 +243,7 @@ state_ = STATE_READING_TAG; } -QuicErrorCode CryptoFramer::Process(QuicStringPiece input) { +QuicErrorCode CryptoFramer::Process(quiche::QuicheStringPiece input) { // Add this data to the buffer. buffer_.append(input.data(), input.length()); QuicDataReader reader(buffer_.data(), buffer_.length(), @@ -265,7 +265,7 @@ } reader.ReadUInt16(&num_entries_); if (num_entries_ > kMaxEntries) { - error_detail_ = QuicStrCat(num_entries_, " entries"); + error_detail_ = quiche::QuicheStrCat(num_entries_, " entries"); return QUIC_CRYPTO_TOO_MANY_ENTRIES; } uint16_t padding; @@ -287,10 +287,10 @@ reader.ReadTag(&tag); if (i > 0 && tag <= tags_and_lengths_[i - 1].first) { if (tag == tags_and_lengths_[i - 1].first) { - error_detail_ = QuicStrCat("Duplicate tag:", tag); + error_detail_ = quiche::QuicheStrCat("Duplicate tag:", tag); return QUIC_CRYPTO_DUPLICATE_TAG; } - error_detail_ = QuicStrCat("Tag ", tag, " out of order"); + error_detail_ = quiche::QuicheStrCat("Tag ", tag, " out of order"); return QUIC_CRYPTO_TAGS_OUT_OF_ORDER; } @@ -298,8 +298,8 @@ reader.ReadUInt32(&end_offset); if (end_offset < last_end_offset) { - error_detail_ = - QuicStrCat("End offset: ", end_offset, " vs ", last_end_offset); + error_detail_ = quiche::QuicheStrCat("End offset: ", end_offset, + " vs ", last_end_offset); return QUIC_CRYPTO_TAGS_OUT_OF_ORDER; } tags_and_lengths_.push_back(std::make_pair( @@ -319,7 +319,7 @@ << values_len_ - reader.BytesRemaining() << " bytes."; } for (const std::pair<QuicTag, size_t>& item : tags_and_lengths_) { - QuicStringPiece value; + quiche::QuicheStringPiece value; if (!reader.ReadStringPiece(&value, item.second)) { DCHECK(process_truncated_messages_); // Store an empty value.
diff --git a/quic/core/crypto/crypto_framer.h b/quic/core/crypto/crypto_framer.h index 5dcc81a..8dc0d96 100644 --- a/quic/core/crypto/crypto_framer.h +++ b/quic/core/crypto/crypto_framer.h
@@ -15,7 +15,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h" #include "net/third_party/quiche/src/quic/core/crypto/crypto_message_parser.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -42,11 +42,11 @@ ~CryptoFramer() override; - // ParseMessage parses exactly one message from the given QuicStringPiece. If - // there is an error, the message is truncated, or the message has trailing - // garbage then nullptr will be returned. + // ParseMessage parses exactly one message from the given + // quiche::QuicheStringPiece. If there is an error, the message is truncated, + // or the message has trailing garbage then nullptr will be returned. static std::unique_ptr<CryptoHandshakeMessage> ParseMessage( - QuicStringPiece in); + quiche::QuicheStringPiece in); // Set callbacks to be called from the framer. A visitor must be set, or // else the framer will crash. It is acceptable for the visitor to do @@ -63,8 +63,9 @@ // false if there was an error, and true otherwise. ProcessInput optionally // takes an EncryptionLevel, but it is ignored. The variant with the // EncryptionLevel is provided to match the CryptoMessageParser interface. - bool ProcessInput(QuicStringPiece input, EncryptionLevel level) override; - bool ProcessInput(QuicStringPiece input); + bool ProcessInput(quiche::QuicheStringPiece input, + EncryptionLevel level) override; + bool ProcessInput(quiche::QuicheStringPiece input); // Returns the number of bytes of buffered input data remaining to be // parsed. @@ -95,7 +96,7 @@ // Process does does the work of |ProcessInput|, but returns an error code, // doesn't set error_ and doesn't call |visitor_->OnError()|. - QuicErrorCode Process(QuicStringPiece input); + QuicErrorCode Process(quiche::QuicheStringPiece input); static bool WritePadTag(QuicDataWriter* writer, size_t pad_length,
diff --git a/quic/core/crypto/crypto_framer_test.cc b/quic/core/crypto/crypto_framer_test.cc index d54de07..8a8787a 100644 --- a/quic/core/crypto/crypto_framer_test.cc +++ b/quic/core/crypto/crypto_framer_test.cc
@@ -16,6 +16,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { namespace test { @@ -262,7 +263,7 @@ }; EXPECT_TRUE(framer.ProcessInput( - QuicStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); + quiche::QuicheStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); EXPECT_EQ(0u, framer.InputBytesRemaining()); EXPECT_EQ(0, visitor.error_count_); ASSERT_EQ(1u, visitor.messages_.size()); @@ -306,7 +307,7 @@ }; EXPECT_TRUE(framer.ProcessInput( - QuicStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); + quiche::QuicheStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); EXPECT_EQ(0u, framer.InputBytesRemaining()); EXPECT_EQ(0, visitor.error_count_); ASSERT_EQ(1u, visitor.messages_.size()); @@ -345,7 +346,8 @@ }; for (size_t i = 0; i < QUIC_ARRAYSIZE(input); i++) { - EXPECT_TRUE(framer.ProcessInput(QuicStringPiece(AsChars(input) + i, 1))); + EXPECT_TRUE( + framer.ProcessInput(quiche::QuicheStringPiece(AsChars(input) + i, 1))); } EXPECT_EQ(0u, framer.InputBytesRemaining()); ASSERT_EQ(1u, visitor.messages_.size()); @@ -379,7 +381,7 @@ }; EXPECT_FALSE(framer.ProcessInput( - QuicStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); + quiche::QuicheStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); EXPECT_THAT(framer.error(), IsError(QUIC_CRYPTO_TAGS_OUT_OF_ORDER)); EXPECT_EQ(1, visitor.error_count_); } @@ -407,7 +409,7 @@ }; EXPECT_FALSE(framer.ProcessInput( - QuicStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); + quiche::QuicheStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); EXPECT_THAT(framer.error(), IsError(QUIC_CRYPTO_TAGS_OUT_OF_ORDER)); EXPECT_EQ(1, visitor.error_count_); } @@ -427,7 +429,7 @@ }; EXPECT_FALSE(framer.ProcessInput( - QuicStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); + quiche::QuicheStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); EXPECT_THAT(framer.error(), IsError(QUIC_CRYPTO_TOO_MANY_ENTRIES)); EXPECT_EQ(1, visitor.error_count_); } @@ -455,7 +457,7 @@ }; EXPECT_TRUE(framer.ProcessInput( - QuicStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); + quiche::QuicheStringPiece(AsChars(input), QUIC_ARRAYSIZE(input)))); EXPECT_EQ(0, visitor.error_count_); }
diff --git a/quic/core/crypto/crypto_handshake_message.cc b/quic/core/crypto/crypto_handshake_message.cc index 56f0bd6..d5b4635 100644 --- a/quic/core/crypto/crypto_handshake_message.cc +++ b/quic/core/crypto/crypto_handshake_message.cc
@@ -13,9 +13,10 @@ #include "net/third_party/quiche/src/quic/core/quic_socket_address_coder.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { @@ -85,7 +86,7 @@ } void CryptoHandshakeMessage::SetStringPiece(QuicTag tag, - QuicStringPiece value) { + quiche::QuicheStringPiece value) { tag_value_map_[tag] = std::string(value); } @@ -147,8 +148,9 @@ return QUIC_NO_ERROR; } -bool CryptoHandshakeMessage::GetStringPiece(QuicTag tag, - QuicStringPiece* out) const { +bool CryptoHandshakeMessage::GetStringPiece( + QuicTag tag, + quiche::QuicheStringPiece* out) const { auto it = tag_value_map_.find(tag); if (it == tag_value_map_.end()) { return false; @@ -164,8 +166,8 @@ QuicErrorCode CryptoHandshakeMessage::GetNthValue24( QuicTag tag, unsigned index, - QuicStringPiece* out) const { - QuicStringPiece value; + quiche::QuicheStringPiece* out) const { + quiche::QuicheStringPiece value; if (!GetStringPiece(tag, &value)) { return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND; } @@ -190,7 +192,7 @@ } if (i == index) { - *out = QuicStringPiece(value.data(), size); + *out = quiche::QuicheStringPiece(value.data(), size); return QUIC_NO_ERROR; } @@ -284,7 +286,7 @@ if (it->second.size() == 4) { uint32_t value; memcpy(&value, it->second.data(), sizeof(value)); - ret += QuicTextUtils::Uint64ToString(value); + ret += quiche::QuicheTextUtils::Uint64ToString(value); done = true; } break; @@ -345,8 +347,8 @@ } break; case kPAD: - ret += QuicStringPrintf("(%d bytes of padding)", - static_cast<int>(it->second.size())); + ret += quiche::QuicheStringPrintf("(%d bytes of padding)", + static_cast<int>(it->second.size())); done = true; break; case kSNI: @@ -359,7 +361,7 @@ if (!done) { // If there's no specific format for this tag, or the value is invalid, // then just use hex. - ret += "0x" + QuicTextUtils::HexEncode(it->second); + ret += "0x" + quiche::QuicheTextUtils::HexEncode(it->second); } ret += "\n"; }
diff --git a/quic/core/crypto/crypto_handshake_message.h b/quic/core/crypto/crypto_handshake_message.h index 6819e36..409738a 100644 --- a/quic/core/crypto/crypto_handshake_message.h +++ b/quic/core/crypto/crypto_handshake_message.h
@@ -13,8 +13,8 @@ #include "net/third_party/quiche/src/quic/core/quic_packets.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -75,7 +75,7 @@ const QuicTagValueMap& tag_value_map() const { return tag_value_map_; } - void SetStringPiece(QuicTag tag, QuicStringPiece value); + void SetStringPiece(QuicTag tag, quiche::QuicheStringPiece value); // Erase removes a tag/value, if present, from the message. void Erase(QuicTag tag); @@ -96,7 +96,7 @@ // Otherwise it populates |out| with the label and returns QUIC_NO_ERROR. QuicErrorCode GetVersionLabel(QuicTag tag, QuicVersionLabel* out) const; - bool GetStringPiece(QuicTag tag, QuicStringPiece* out) const; + bool GetStringPiece(QuicTag tag, quiche::QuicheStringPiece* out) const; bool HasStringPiece(QuicTag tag) const; // GetNthValue24 interprets the value with the given tag to be a series of @@ -104,7 +104,7 @@ // index. QuicErrorCode GetNthValue24(QuicTag tag, unsigned index, - QuicStringPiece* out) const; + quiche::QuicheStringPiece* out) const; QuicErrorCode GetUint32(QuicTag tag, uint32_t* out) const; QuicErrorCode GetUint64(QuicTag tag, uint64_t* out) const; QuicErrorCode GetUint128(QuicTag tag, QuicUint128* out) const;
diff --git a/quic/core/crypto/crypto_message_parser.h b/quic/core/crypto/crypto_message_parser.h index 2638a19..8038664 100644 --- a/quic/core/crypto/crypto_message_parser.h +++ b/quic/core/crypto/crypto_message_parser.h
@@ -9,7 +9,7 @@ #include "net/third_party/quiche/src/quic/core/quic_error_codes.h" #include "net/third_party/quiche/src/quic/core/quic_types.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -23,7 +23,8 @@ // Processes input data, which must be delivered in order. The input data // being processed was received at encryption level |level|. Returns // false if there was an error, and true otherwise. - virtual bool ProcessInput(QuicStringPiece input, EncryptionLevel level) = 0; + virtual bool ProcessInput(quiche::QuicheStringPiece input, + EncryptionLevel level) = 0; // Returns the number of bytes of buffered input data remaining to be // parsed.
diff --git a/quic/core/crypto/crypto_message_printer_bin.cc b/quic/core/crypto/crypto_message_printer_bin.cc index 67cd531..f5584ad 100644 --- a/quic/core/crypto/crypto_message_printer_bin.cc +++ b/quic/core/crypto/crypto_message_printer_bin.cc
@@ -12,7 +12,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" using std::cerr; using std::cout; @@ -47,7 +47,7 @@ quic::CryptoFramer framer; framer.set_visitor(&printer); framer.set_process_truncated_messages(true); - std::string input = quic::QuicTextUtils::HexDecode(messages[0]); + std::string input = quiche::QuicheTextUtils::HexDecode(messages[0]); if (!framer.ProcessInput(input)) { return 1; }
diff --git a/quic/core/crypto/crypto_secret_boxer.cc b/quic/core/crypto/crypto_secret_boxer.cc index c44cbb9..78cf768 100644 --- a/quic/core/crypto/crypto_secret_boxer.cc +++ b/quic/core/crypto/crypto_secret_boxer.cc
@@ -11,6 +11,7 @@ #include "third_party/boringssl/src/include/openssl/err.h" #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -67,7 +68,7 @@ } std::string CryptoSecretBoxer::Box(QuicRandom* rand, - QuicStringPiece plaintext) const { + quiche::QuicheStringPiece plaintext) const { // The box is formatted as: // 12 bytes of random nonce // n bytes of ciphertext @@ -103,9 +104,9 @@ return ret; } -bool CryptoSecretBoxer::Unbox(QuicStringPiece in_ciphertext, +bool CryptoSecretBoxer::Unbox(quiche::QuicheStringPiece in_ciphertext, std::string* out_storage, - QuicStringPiece* out) const { + quiche::QuicheStringPiece* out) const { if (in_ciphertext.size() < kSIVNonceSize) { return false; } @@ -129,7 +130,7 @@ kSIVNonceSize, ciphertext, ciphertext_len, nullptr, 0)) { ok = true; - *out = QuicStringPiece(out_storage->data(), bytes_written); + *out = quiche::QuicheStringPiece(out_storage->data(), bytes_written); break; }
diff --git a/quic/core/crypto/crypto_secret_boxer.h b/quic/core/crypto/crypto_secret_boxer.h index eba7a57..dc4e0b1 100644 --- a/quic/core/crypto/crypto_secret_boxer.h +++ b/quic/core/crypto/crypto_secret_boxer.h
@@ -12,7 +12,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" #include "net/third_party/quiche/src/quic/platform/api/quic_mutex.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -41,16 +41,16 @@ // returns the resulting ciphertext. Since an authenticator and nonce are // included, the result will be slightly larger than |plaintext|. The first // key in the vector supplied to |SetKeys| will be used. - std::string Box(QuicRandom* rand, QuicStringPiece plaintext) const; + std::string Box(QuicRandom* rand, quiche::QuicheStringPiece plaintext) const; // Unbox takes the result of a previous call to |Box| in |ciphertext| and // authenticates+decrypts it. If |ciphertext| cannot be decrypted with any of // the supplied keys, the function returns false. Otherwise, |out_storage| is // used to store the result and |out| is set to point into |out_storage| and // contains the original plaintext. - bool Unbox(QuicStringPiece ciphertext, + bool Unbox(quiche::QuicheStringPiece ciphertext, std::string* out_storage, - QuicStringPiece* out) const; + quiche::QuicheStringPiece* out) const; private: struct State;
diff --git a/quic/core/crypto/crypto_secret_boxer_test.cc b/quic/core/crypto/crypto_secret_boxer_test.cc index 06505d9..57a5712 100644 --- a/quic/core/crypto/crypto_secret_boxer_test.cc +++ b/quic/core/crypto/crypto_secret_boxer_test.cc
@@ -8,6 +8,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { namespace test { @@ -15,7 +16,7 @@ class CryptoSecretBoxerTest : public QuicTest {}; TEST_F(CryptoSecretBoxerTest, BoxAndUnbox) { - QuicStringPiece message("hello world"); + quiche::QuicheStringPiece message("hello world"); CryptoSecretBoxer boxer; boxer.SetKeys({std::string(CryptoSecretBoxer::GetKeySize(), 0x11)}); @@ -23,7 +24,7 @@ const std::string box = boxer.Box(QuicRandom::GetInstance(), message); std::string storage; - QuicStringPiece result; + quiche::QuicheStringPiece result; EXPECT_TRUE(boxer.Unbox(box, &storage, &result)); EXPECT_EQ(result, message); @@ -39,10 +40,10 @@ // Helper function to test whether one boxer can decode the output of another. static bool CanDecode(const CryptoSecretBoxer& decoder, const CryptoSecretBoxer& encoder) { - QuicStringPiece message("hello world"); + quiche::QuicheStringPiece message("hello world"); const std::string boxed = encoder.Box(QuicRandom::GetInstance(), message); std::string storage; - QuicStringPiece result; + quiche::QuicheStringPiece result; bool ok = decoder.Unbox(boxed, &storage, &result); if (ok) { EXPECT_EQ(result, message);
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc index a3cbbf4..9c606a2 100644 --- a/quic/core/crypto/crypto_server_test.cc +++ b/quic/core/crypto/crypto_server_test.cc
@@ -23,9 +23,7 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" #include "net/third_party/quiche/src/quic/test_tools/failing_proof_source.h" #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h" @@ -33,6 +31,8 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_crypto_server_config_peer.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { namespace test { @@ -127,7 +127,7 @@ std::unique_ptr<CryptoHandshakeMessage> msg( config_.AddConfig(primary_config, clock_.WallNow())); - QuicStringPiece orbit; + quiche::QuicheStringPiece orbit; CHECK(msg->GetStringPiece(kORBT, &orbit)); CHECK_EQ(sizeof(orbit_), orbit.size()); memcpy(orbit_, orbit.data(), orbit.size()); @@ -135,9 +135,9 @@ char public_value[32]; memset(public_value, 42, sizeof(public_value)); - nonce_hex_ = "#" + QuicTextUtils::HexEncode(GenerateNonce()); - pub_hex_ = - "#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value)); + nonce_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(GenerateNonce()); + pub_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(public_value, + sizeof(public_value)); CryptoHandshakeMessage client_hello = crypto_test_utils::CreateCHLO({{"PDMD", "X509"}, @@ -156,17 +156,17 @@ SERVER_CONFIG_INCHOATE_HELLO_FAILURE}; CheckRejectReasons(kRejectReasons, QUIC_ARRAYSIZE(kRejectReasons)); - QuicStringPiece srct; + quiche::QuicheStringPiece srct; ASSERT_TRUE(out_.GetStringPiece(kSourceAddressTokenTag, &srct)); - srct_hex_ = "#" + QuicTextUtils::HexEncode(srct); + srct_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(srct); - QuicStringPiece scfg; + quiche::QuicheStringPiece scfg; ASSERT_TRUE(out_.GetStringPiece(kSCFG, &scfg)); server_config_ = CryptoFramer::ParseMessage(scfg); - QuicStringPiece scid; + quiche::QuicheStringPiece scid; ASSERT_TRUE(server_config_->GetStringPiece(kSCID, &scid)); - scid_hex_ = "#" + QuicTextUtils::HexEncode(scid); + scid_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(scid); signed_config_ = QuicReferenceCountedPointer<QuicSignedServerConfig>( new QuicSignedServerConfig()); @@ -211,7 +211,7 @@ EXPECT_EQ(CreateQuicVersionLabel(supported_versions_[i]), versions[i]); } - QuicStringPiece address; + quiche::QuicheStringPiece address; ASSERT_TRUE(server_hello.GetStringPiece(kCADR, &address)); QuicSocketAddressCoder decoder; ASSERT_TRUE(decoder.Decode(address.data(), address.size())); @@ -313,7 +313,8 @@ std::string nonce; CryptoUtils::GenerateNonce( clock_.WallNow(), rand_, - QuicStringPiece(reinterpret_cast<const char*>(orbit_), sizeof(orbit_)), + quiche::QuicheStringPiece(reinterpret_cast<const char*>(orbit_), + sizeof(orbit_)), &nonce); return nonce; } @@ -339,8 +340,8 @@ std::string XlctHexString() { uint64_t xlct = crypto_test_utils::LeafCertHashForTesting(); - return "#" + QuicTextUtils::HexEncode(reinterpret_cast<char*>(&xlct), - sizeof(xlct)); + return "#" + quiche::QuicheTextUtils::HexEncode( + reinterpret_cast<char*>(&xlct), sizeof(xlct)); } protected: @@ -412,7 +413,7 @@ kClientHelloMinimumSize); ShouldSucceed(msg); - QuicStringPiece cert, proof, cert_sct; + quiche::QuicheStringPiece cert, proof, cert_sct; EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert)); EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof)); EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct)); @@ -441,7 +442,7 @@ config_.set_chlo_multiplier(1); ShouldSucceed(msg); - QuicStringPiece cert, proof, cert_sct; + quiche::QuicheStringPiece cert, proof, cert_sct; EXPECT_FALSE(out_.GetStringPiece(kCertificateTag, &cert)); EXPECT_FALSE(out_.GetStringPiece(kPROF, &proof)); EXPECT_FALSE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct)); @@ -468,7 +469,7 @@ config_.set_chlo_multiplier(1); ShouldSucceed(msg); - QuicStringPiece cert, proof, cert_sct; + quiche::QuicheStringPiece cert, proof, cert_sct; EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert)); EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof)); EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct)); @@ -495,7 +496,7 @@ config_.set_chlo_multiplier(1); ShouldSucceed(msg); - QuicStringPiece cert, proof, cert_sct; + quiche::QuicheStringPiece cert, proof, cert_sct; EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert)); EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof)); EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct)); @@ -789,13 +790,13 @@ SOURCE_ADDRESS_TOKEN_DIFFERENT_IP_ADDRESS_FAILURE}; CheckRejectReasons(kRejectReasons, QUIC_ARRAYSIZE(kRejectReasons)); - QuicStringPiece cert, proof, scfg_str; + quiche::QuicheStringPiece cert, proof, scfg_str; EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert)); EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof)); EXPECT_TRUE(out_.GetStringPiece(kSCFG, &scfg_str)); std::unique_ptr<CryptoHandshakeMessage> scfg( CryptoFramer::ParseMessage(scfg_str)); - QuicStringPiece scid; + quiche::QuicheStringPiece scid; EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid)); EXPECT_NE(scid, kOldConfigId); @@ -895,7 +896,7 @@ ShouldSucceed(msg); EXPECT_EQ(kSHLO, out_.tag()); - QuicStringPiece nonce; + quiche::QuicheStringPiece nonce; EXPECT_TRUE(out_.GetStringPiece(kServerNonceTag, &nonce)); } @@ -931,7 +932,7 @@ ShouldSucceed(msg); // Decompress cert chain from server to individual certs. - QuicStringPiece certs_compressed; + quiche::QuicheStringPiece certs_compressed; ASSERT_TRUE(out_.GetStringPiece(kCertificateTag, &certs_compressed)); ASSERT_NE(0u, certs_compressed.size()); std::vector<std::string> certs; @@ -951,7 +952,7 @@ ShouldSucceed(msg); // Server responds with inchoate REJ containing valid source-address token. - QuicStringPiece srct; + quiche::QuicheStringPiece srct; ASSERT_TRUE(out_.GetStringPiece(kSourceAddressTokenTag, &srct)); // Client now drops cached certs; sends CHLO with updated source-address @@ -1012,7 +1013,7 @@ std::unique_ptr<CryptoHandshakeMessage> scfg_b( b.AddDefaultConfig(&rand_b, &clock, options)); - QuicStringPiece scid_a, scid_b; + quiche::QuicheStringPiece scid_a, scid_b; EXPECT_TRUE(scfg_a->GetStringPiece(kSCID, &scid_a)); EXPECT_TRUE(scfg_b->GetStringPiece(kSCID, &scid_b)); @@ -1030,7 +1031,7 @@ std::unique_ptr<CryptoHandshakeMessage> scfg( a.AddDefaultConfig(&rand_a, &clock, options)); - QuicStringPiece scid; + quiche::QuicheStringPiece scid; EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid)); // Need to take a copy of |scid| has we're about to call |Erase|. const std::string scid_str(scid);
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc index 5650cec..47da4c1 100644 --- a/quic/core/crypto/crypto_utils.cc +++ b/quic/core/crypto/crypto_utils.cc
@@ -29,8 +29,9 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -100,12 +101,12 @@ HkdfExpandLabel(prf, pp_secret, "quic iv", crypter->GetIVSize()); std::vector<uint8_t> pn = HkdfExpandLabel(prf, pp_secret, "quic hp", crypter->GetKeySize()); - crypter->SetKey( - QuicStringPiece(reinterpret_cast<char*>(key.data()), key.size())); + crypter->SetKey(quiche::QuicheStringPiece(reinterpret_cast<char*>(key.data()), + key.size())); crypter->SetIV( - QuicStringPiece(reinterpret_cast<char*>(iv.data()), iv.size())); + quiche::QuicheStringPiece(reinterpret_cast<char*>(iv.data()), iv.size())); crypter->SetHeaderProtectionKey( - QuicStringPiece(reinterpret_cast<char*>(pn.data()), pn.size())); + quiche::QuicheStringPiece(reinterpret_cast<char*>(pn.data()), pn.size())); } namespace { @@ -240,7 +241,7 @@ // static void CryptoUtils::GenerateNonce(QuicWallTime now, QuicRandom* random_generator, - QuicStringPiece orbit, + quiche::QuicheStringPiece orbit, std::string* nonce) { // a 4-byte timestamp + 28 random bytes. nonce->reserve(kNonceSize); @@ -266,11 +267,11 @@ // static bool CryptoUtils::DeriveKeys(const ParsedQuicVersion& version, - QuicStringPiece premaster_secret, + quiche::QuicheStringPiece premaster_secret, QuicTag aead, - QuicStringPiece client_nonce, - QuicStringPiece server_nonce, - QuicStringPiece pre_shared_key, + quiche::QuicheStringPiece client_nonce, + quiche::QuicheStringPiece server_nonce, + quiche::QuicheStringPiece pre_shared_key, const std::string& hkdf_input, Perspective perspective, Diversification diversification, @@ -279,7 +280,7 @@ // If the connection is using PSK, concatenate it with the pre-master secret. std::unique_ptr<char[]> psk_premaster_secret; if (!pre_shared_key.empty()) { - const QuicStringPiece label(kPreSharedKeyLabel); + const quiche::QuicheStringPiece label(kPreSharedKeyLabel); const size_t psk_premaster_secret_size = label.size() + 1 + pre_shared_key.size() + 8 + premaster_secret.size() + 8; @@ -297,8 +298,8 @@ return false; } - premaster_secret = - QuicStringPiece(psk_premaster_secret.get(), psk_premaster_secret_size); + premaster_secret = quiche::QuicheStringPiece(psk_premaster_secret.get(), + psk_premaster_secret_size); } crypters->encrypter = QuicEncrypter::Create(version, aead); @@ -312,7 +313,7 @@ size_t subkey_secret_bytes = subkey_secret == nullptr ? 0 : premaster_secret.length(); - QuicStringPiece nonce = client_nonce; + quiche::QuicheStringPiece nonce = client_nonce; std::string nonce_storage; if (!server_nonce.empty()) { nonce_storage = std::string(client_nonce) + std::string(server_nonce); @@ -409,9 +410,9 @@ } // static -bool CryptoUtils::ExportKeyingMaterial(QuicStringPiece subkey_secret, - QuicStringPiece label, - QuicStringPiece context, +bool CryptoUtils::ExportKeyingMaterial(quiche::QuicheStringPiece subkey_secret, + quiche::QuicheStringPiece label, + quiche::QuicheStringPiece context, size_t result_len, std::string* result) { for (size_t i = 0; i < label.length(); i++) { @@ -431,14 +432,14 @@ info.append(reinterpret_cast<char*>(&context_length), sizeof(context_length)); info.append(context.data(), context.length()); - QuicHKDF hkdf(subkey_secret, QuicStringPiece() /* no salt */, info, + QuicHKDF hkdf(subkey_secret, quiche::QuicheStringPiece() /* no salt */, info, result_len, 0 /* no fixed IV */, 0 /* no subkey secret */); *result = std::string(hkdf.client_write_key()); return true; } // static -uint64_t CryptoUtils::ComputeLeafCertHash(QuicStringPiece cert) { +uint64_t CryptoUtils::ComputeLeafCertHash(quiche::QuicheStringPiece cert) { return QuicUtils::FNV1a_64_Hash(cert); } @@ -478,7 +479,7 @@ // reports that there was a version negotiation during the handshake. // Ensure that these two lists are identical. if (mismatch) { - *error_details = QuicStrCat( + *error_details = quiche::QuicheStrCat( "Downgrade attack detected: ServerVersions(", server_versions.size(), ")[", QuicVersionLabelVectorToString(server_versions, ",", 30), "] NegotiatedVersions(", negotiated_versions.size(), ")[", @@ -524,7 +525,7 @@ // downgrade attack. for (size_t i = 0; i < supported_versions.size(); ++i) { if (client_version == CreateQuicVersionLabel(supported_versions[i])) { - *error_details = QuicStrCat( + *error_details = quiche::QuicheStrCat( "Downgrade attack detected: ClientVersion[", QuicVersionLabelToString(client_version), "] SupportedVersions(", supported_versions.size(), ")[",
diff --git a/quic/core/crypto/crypto_utils.h b/quic/core/crypto/crypto_utils.h index da746e3..8cebf14 100644 --- a/quic/core/crypto/crypto_utils.h +++ b/quic/core/crypto/crypto_utils.h
@@ -19,7 +19,7 @@ #include "net/third_party/quiche/src/quic/core/quic_packets.h" #include "net/third_party/quiche/src/quic/core/quic_time.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -101,7 +101,7 @@ // <20 bytes> random static void GenerateNonce(QuicWallTime now, QuicRandom* random_generator, - QuicStringPiece orbit, + quiche::QuicheStringPiece orbit, std::string* nonce); // DeriveKeys populates |crypters->encrypter|, |crypters->decrypter|, and @@ -124,11 +124,11 @@ // |SetDiversificationNonce| with a diversification nonce will be needed to // complete keying. static bool DeriveKeys(const ParsedQuicVersion& version, - QuicStringPiece premaster_secret, + quiche::QuicheStringPiece premaster_secret, QuicTag aead, - QuicStringPiece client_nonce, - QuicStringPiece server_nonce, - QuicStringPiece pre_shared_key, + quiche::QuicheStringPiece client_nonce, + quiche::QuicheStringPiece server_nonce, + quiche::QuicheStringPiece pre_shared_key, const std::string& hkdf_input, Perspective perspective, Diversification diversification, @@ -139,15 +139,15 @@ // dependent on |subkey_secret|, |label|, and |context|. Returns false if the // parameters are invalid (e.g. |label| contains null bytes); returns true on // success. - static bool ExportKeyingMaterial(QuicStringPiece subkey_secret, - QuicStringPiece label, - QuicStringPiece context, + static bool ExportKeyingMaterial(quiche::QuicheStringPiece subkey_secret, + quiche::QuicheStringPiece label, + quiche::QuicheStringPiece context, size_t result_len, std::string* result); // Computes the FNV-1a hash of the provided DER-encoded cert for use in the // XLCT tag. - static uint64_t ComputeLeafCertHash(QuicStringPiece cert); + static uint64_t ComputeLeafCertHash(quiche::QuicheStringPiece cert); // Validates that |server_hello| is actually an SHLO message and that it is // not part of a downgrade attack.
diff --git a/quic/core/crypto/crypto_utils_test.cc b/quic/core/crypto/crypto_utils_test.cc index 25adff2..bba62e9 100644 --- a/quic/core/crypto/crypto_utils_test.cc +++ b/quic/core/crypto/crypto_utils_test.cc
@@ -9,8 +9,8 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { namespace test { @@ -52,14 +52,16 @@ for (size_t i = 0; i < QUIC_ARRAYSIZE(test_vector); i++) { // Decode the test vector. std::string subkey_secret = - QuicTextUtils::HexDecode(test_vector[i].subkey_secret); - std::string label = QuicTextUtils::HexDecode(test_vector[i].label); - std::string context = QuicTextUtils::HexDecode(test_vector[i].context); + quiche::QuicheTextUtils::HexDecode(test_vector[i].subkey_secret); + std::string label = + quiche::QuicheTextUtils::HexDecode(test_vector[i].label); + std::string context = + quiche::QuicheTextUtils::HexDecode(test_vector[i].context); size_t result_len = test_vector[i].result_len; bool expect_ok = test_vector[i].expected != nullptr; std::string expected; if (expect_ok) { - expected = QuicTextUtils::HexDecode(test_vector[i].expected); + expected = quiche::QuicheTextUtils::HexDecode(test_vector[i].expected); } std::string result;
diff --git a/quic/core/crypto/curve25519_key_exchange.cc b/quic/core/crypto/curve25519_key_exchange.cc index 044693d..f4cc793 100644 --- a/quic/core/crypto/curve25519_key_exchange.cc +++ b/quic/core/crypto/curve25519_key_exchange.cc
@@ -11,6 +11,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -29,7 +30,7 @@ // static std::unique_ptr<Curve25519KeyExchange> Curve25519KeyExchange::New( - QuicStringPiece private_key) { + quiche::QuicheStringPiece private_key) { // We don't want to #include the BoringSSL headers in the public header file, // so we use literals for the sizes of private_key_ and public_key_. Here we // assert that those values are equal to the values from the BoringSSL @@ -59,7 +60,7 @@ } bool Curve25519KeyExchange::CalculateSharedKeySync( - QuicStringPiece peer_public_value, + quiche::QuicheStringPiece peer_public_value, std::string* shared_key) const { if (peer_public_value.size() != X25519_PUBLIC_VALUE_LEN) { return false; @@ -75,9 +76,9 @@ return true; } -QuicStringPiece Curve25519KeyExchange::public_value() const { - return QuicStringPiece(reinterpret_cast<const char*>(public_key_), - sizeof(public_key_)); +quiche::QuicheStringPiece Curve25519KeyExchange::public_value() const { + return quiche::QuicheStringPiece(reinterpret_cast<const char*>(public_key_), + sizeof(public_key_)); } } // namespace quic
diff --git a/quic/core/crypto/curve25519_key_exchange.h b/quic/core/crypto/curve25519_key_exchange.h index 31c6c0e..76fd23f 100644 --- a/quic/core/crypto/curve25519_key_exchange.h +++ b/quic/core/crypto/curve25519_key_exchange.h
@@ -10,7 +10,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/key_exchange.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -29,16 +29,16 @@ // New creates a new key-exchange object from a private key. If |private_key| // is invalid, nullptr is returned. static std::unique_ptr<Curve25519KeyExchange> New( - QuicStringPiece private_key); + quiche::QuicheStringPiece private_key); // NewPrivateKey returns a private key, generated from |rand|, suitable for // passing to |New|. static std::string NewPrivateKey(QuicRandom* rand); // SynchronousKeyExchange interface. - bool CalculateSharedKeySync(QuicStringPiece peer_public_value, + bool CalculateSharedKeySync(quiche::QuicheStringPiece peer_public_value, std::string* shared_key) const override; - QuicStringPiece public_value() const override; + quiche::QuicheStringPiece public_value() const override; QuicTag type() const override { return kC255; } private:
diff --git a/quic/core/crypto/curve25519_key_exchange_test.cc b/quic/core/crypto/curve25519_key_exchange_test.cc index 5003668..2e5dfb4 100644 --- a/quic/core/crypto/curve25519_key_exchange_test.cc +++ b/quic/core/crypto/curve25519_key_exchange_test.cc
@@ -10,6 +10,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { namespace test { @@ -54,8 +55,8 @@ std::unique_ptr<Curve25519KeyExchange> bob( Curve25519KeyExchange::New(bob_key)); - const QuicStringPiece alice_public(alice->public_value()); - const QuicStringPiece bob_public(bob->public_value()); + const quiche::QuicheStringPiece alice_public(alice->public_value()); + const quiche::QuicheStringPiece bob_public(bob->public_value()); std::string alice_shared, bob_shared; ASSERT_TRUE(alice->CalculateSharedKeySync(bob_public, &alice_shared)); @@ -78,8 +79,8 @@ std::unique_ptr<Curve25519KeyExchange> bob( Curve25519KeyExchange::New(bob_key)); - const QuicStringPiece alice_public(alice->public_value()); - const QuicStringPiece bob_public(bob->public_value()); + const quiche::QuicheStringPiece alice_public(alice->public_value()); + const quiche::QuicheStringPiece bob_public(bob->public_value()); std::string alice_shared, bob_shared; TestCallbackResult alice_result;
diff --git a/quic/core/crypto/key_exchange.cc b/quic/core/crypto/key_exchange.cc index 1969e75..84f9c86 100644 --- a/quic/core/crypto/key_exchange.cc +++ b/quic/core/crypto/key_exchange.cc
@@ -6,12 +6,13 @@ #include "net/third_party/quiche/src/quic/core/crypto/curve25519_key_exchange.h" #include "net/third_party/quiche/src/quic/core/crypto/p256_key_exchange.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { std::unique_ptr<SynchronousKeyExchange> CreateLocalSynchronousKeyExchange( QuicTag type, - QuicStringPiece private_key) { + quiche::QuicheStringPiece private_key) { switch (type) { case kC255: return Curve25519KeyExchange::New(private_key);
diff --git a/quic/core/crypto/key_exchange.h b/quic/core/crypto/key_exchange.h index 127dc62..cb6fdbc 100644 --- a/quic/core/crypto/key_exchange.h +++ b/quic/core/crypto/key_exchange.h
@@ -10,7 +10,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -48,7 +48,7 @@ // that |callback| might be invoked synchronously. Results will be written // into |*shared_key|. virtual void CalculateSharedKeyAsync( - QuicStringPiece peer_public_value, + quiche::QuicheStringPiece peer_public_value, std::string* shared_key, std::unique_ptr<Callback> callback) const = 0; @@ -66,7 +66,7 @@ // AyncKeyExchange API. Note that this method is marked 'final.' Subclasses // should implement CalculateSharedKeySync only. - void CalculateSharedKeyAsync(QuicStringPiece peer_public_value, + void CalculateSharedKeyAsync(quiche::QuicheStringPiece peer_public_value, std::string* shared_key, std::unique_ptr<Callback> callback) const final { const bool ok = CalculateSharedKeySync(peer_public_value, shared_key); @@ -75,14 +75,15 @@ // CalculateSharedKey computes the shared key between a local private key and // a public value from the peer. Results will be written into |*shared_key|. - virtual bool CalculateSharedKeySync(QuicStringPiece peer_public_value, - std::string* shared_key) const = 0; + virtual bool CalculateSharedKeySync( + quiche::QuicheStringPiece peer_public_value, + std::string* shared_key) const = 0; // public_value returns the local public key which can be sent to a peer in - // order to complete a key exchange. The returned QuicStringPiece is a - // reference to a member of this object and is only valid for as long as it + // order to complete a key exchange. The returned quiche::QuicheStringPiece is + // a reference to a member of this object and is only valid for as long as it // exists. - virtual QuicStringPiece public_value() const = 0; + virtual quiche::QuicheStringPiece public_value() const = 0; }; // Create a SynchronousKeyExchange object which will use a keypair generated @@ -91,7 +92,7 @@ // invalid. std::unique_ptr<SynchronousKeyExchange> CreateLocalSynchronousKeyExchange( QuicTag type, - QuicStringPiece private_key); + quiche::QuicheStringPiece private_key); // Create a SynchronousKeyExchange object which will use a keypair generated // from |rand|, and a key-exchange algorithm specified by |type|, which must be
diff --git a/quic/core/crypto/null_decrypter.cc b/quic/core/crypto/null_decrypter.cc index 51d8b11..d453a35 100644 --- a/quic/core/crypto/null_decrypter.cc +++ b/quic/core/crypto/null_decrypter.cc
@@ -11,29 +11,30 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h" #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { NullDecrypter::NullDecrypter(Perspective perspective) : perspective_(perspective) {} -bool NullDecrypter::SetKey(QuicStringPiece key) { +bool NullDecrypter::SetKey(quiche::QuicheStringPiece key) { return key.empty(); } -bool NullDecrypter::SetNoncePrefix(QuicStringPiece nonce_prefix) { +bool NullDecrypter::SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) { return nonce_prefix.empty(); } -bool NullDecrypter::SetIV(QuicStringPiece iv) { +bool NullDecrypter::SetIV(quiche::QuicheStringPiece iv) { return iv.empty(); } -bool NullDecrypter::SetHeaderProtectionKey(QuicStringPiece key) { +bool NullDecrypter::SetHeaderProtectionKey(quiche::QuicheStringPiece key) { return key.empty(); } -bool NullDecrypter::SetPreliminaryKey(QuicStringPiece /*key*/) { +bool NullDecrypter::SetPreliminaryKey(quiche::QuicheStringPiece /*key*/) { QUIC_BUG << "Should not be called"; return false; } @@ -45,8 +46,8 @@ } bool NullDecrypter::DecryptPacket(uint64_t /*packet_number*/, - QuicStringPiece associated_data, - QuicStringPiece ciphertext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext, char* output, size_t* output_length, size_t max_output_length) { @@ -58,7 +59,7 @@ return false; } - QuicStringPiece plaintext = reader.ReadRemainingPayload(); + quiche::QuicheStringPiece plaintext = reader.ReadRemainingPayload(); if (plaintext.length() > max_output_length) { QUIC_BUG << "Output buffer must be larger than the plaintext."; return false; @@ -89,12 +90,12 @@ return 0; } -QuicStringPiece NullDecrypter::GetKey() const { - return QuicStringPiece(); +quiche::QuicheStringPiece NullDecrypter::GetKey() const { + return quiche::QuicheStringPiece(); } -QuicStringPiece NullDecrypter::GetNoncePrefix() const { - return QuicStringPiece(); +quiche::QuicheStringPiece NullDecrypter::GetNoncePrefix() const { + return quiche::QuicheStringPiece(); } uint32_t NullDecrypter::cipher_id() const { @@ -111,8 +112,9 @@ return true; } -QuicUint128 NullDecrypter::ComputeHash(const QuicStringPiece data1, - const QuicStringPiece data2) const { +QuicUint128 NullDecrypter::ComputeHash( + const quiche::QuicheStringPiece data1, + const quiche::QuicheStringPiece data2) const { QuicUint128 correct_hash; if (perspective_ == Perspective::IS_CLIENT) { // Peer is a server.
diff --git a/quic/core/crypto/null_decrypter.h b/quic/core/crypto/null_decrypter.h index aac25bb..c3bd203 100644 --- a/quic/core/crypto/null_decrypter.h +++ b/quic/core/crypto/null_decrypter.h
@@ -11,8 +11,8 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h" #include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -29,15 +29,15 @@ ~NullDecrypter() override {} // QuicDecrypter implementation - bool SetKey(QuicStringPiece key) override; - bool SetNoncePrefix(QuicStringPiece nonce_prefix) override; - bool SetIV(QuicStringPiece iv) override; - bool SetHeaderProtectionKey(QuicStringPiece key) override; - bool SetPreliminaryKey(QuicStringPiece key) override; + bool SetKey(quiche::QuicheStringPiece key) override; + bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) override; + bool SetIV(quiche::QuicheStringPiece iv) override; + bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override; + bool SetPreliminaryKey(quiche::QuicheStringPiece key) override; bool SetDiversificationNonce(const DiversificationNonce& nonce) override; bool DecryptPacket(uint64_t packet_number, - QuicStringPiece associated_data, - QuicStringPiece ciphertext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext, char* output, size_t* output_length, size_t max_output_length) override; @@ -46,14 +46,15 @@ size_t GetKeySize() const override; size_t GetNoncePrefixSize() const override; size_t GetIVSize() const override; - QuicStringPiece GetKey() const override; - QuicStringPiece GetNoncePrefix() const override; + quiche::QuicheStringPiece GetKey() const override; + quiche::QuicheStringPiece GetNoncePrefix() const override; uint32_t cipher_id() const override; private: bool ReadHash(QuicDataReader* reader, QuicUint128* hash); - QuicUint128 ComputeHash(QuicStringPiece data1, QuicStringPiece data2) const; + QuicUint128 ComputeHash(quiche::QuicheStringPiece data1, + quiche::QuicheStringPiece data2) const; Perspective perspective_; };
diff --git a/quic/core/crypto/null_decrypter_test.cc b/quic/core/crypto/null_decrypter_test.cc index 09b1aaf..9f18cc2 100644 --- a/quic/core/crypto/null_decrypter_test.cc +++ b/quic/core/crypto/null_decrypter_test.cc
@@ -42,10 +42,11 @@ NullDecrypter decrypter(Perspective::IS_SERVER); char buffer[256]; size_t length = 0; - ASSERT_TRUE(decrypter.DecryptPacket( - 0, "hello world!", QuicStringPiece(data, len), buffer, &length, 256)); + ASSERT_TRUE(decrypter.DecryptPacket(0, "hello world!", + quiche::QuicheStringPiece(data, len), + buffer, &length, 256)); EXPECT_LT(0u, length); - EXPECT_EQ("goodbye!", QuicStringPiece(buffer, length)); + EXPECT_EQ("goodbye!", quiche::QuicheStringPiece(buffer, length)); } TEST_F(NullDecrypterTest, DecryptServer) { @@ -78,10 +79,11 @@ NullDecrypter decrypter(Perspective::IS_CLIENT); char buffer[256]; size_t length = 0; - ASSERT_TRUE(decrypter.DecryptPacket( - 0, "hello world!", QuicStringPiece(data, len), buffer, &length, 256)); + ASSERT_TRUE(decrypter.DecryptPacket(0, "hello world!", + quiche::QuicheStringPiece(data, len), + buffer, &length, 256)); EXPECT_LT(0u, length); - EXPECT_EQ("goodbye!", QuicStringPiece(buffer, length)); + EXPECT_EQ("goodbye!", quiche::QuicheStringPiece(buffer, length)); } TEST_F(NullDecrypterTest, BadHash) { @@ -114,8 +116,9 @@ NullDecrypter decrypter(Perspective::IS_CLIENT); char buffer[256]; size_t length = 0; - ASSERT_FALSE(decrypter.DecryptPacket( - 0, "hello world!", QuicStringPiece(data, len), buffer, &length, 256)); + ASSERT_FALSE(decrypter.DecryptPacket(0, "hello world!", + quiche::QuicheStringPiece(data, len), + buffer, &length, 256)); } TEST_F(NullDecrypterTest, ShortInput) { @@ -128,8 +131,9 @@ NullDecrypter decrypter(Perspective::IS_CLIENT); char buffer[256]; size_t length = 0; - ASSERT_FALSE(decrypter.DecryptPacket( - 0, "hello world!", QuicStringPiece(data, len), buffer, &length, 256)); + ASSERT_FALSE(decrypter.DecryptPacket(0, "hello world!", + quiche::QuicheStringPiece(data, len), + buffer, &length, 256)); } } // namespace test
diff --git a/quic/core/crypto/null_encrypter.cc b/quic/core/crypto/null_encrypter.cc index 1fe0fdf..4de1510 100644 --- a/quic/core/crypto/null_encrypter.cc +++ b/quic/core/crypto/null_encrypter.cc
@@ -6,6 +6,7 @@ #include "net/third_party/quiche/src/quic/core/quic_data_writer.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -14,25 +15,25 @@ NullEncrypter::NullEncrypter(Perspective perspective) : perspective_(perspective) {} -bool NullEncrypter::SetKey(QuicStringPiece key) { +bool NullEncrypter::SetKey(quiche::QuicheStringPiece key) { return key.empty(); } -bool NullEncrypter::SetNoncePrefix(QuicStringPiece nonce_prefix) { +bool NullEncrypter::SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) { return nonce_prefix.empty(); } -bool NullEncrypter::SetIV(QuicStringPiece iv) { +bool NullEncrypter::SetIV(quiche::QuicheStringPiece iv) { return iv.empty(); } -bool NullEncrypter::SetHeaderProtectionKey(QuicStringPiece key) { +bool NullEncrypter::SetHeaderProtectionKey(quiche::QuicheStringPiece key) { return key.empty(); } bool NullEncrypter::EncryptPacket(uint64_t /*packet_number*/, - QuicStringPiece associated_data, - QuicStringPiece plaintext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext, char* output, size_t* output_length, size_t max_output_length) { @@ -58,7 +59,7 @@ } std::string NullEncrypter::GenerateHeaderProtectionMask( - QuicStringPiece /*sample*/) { + quiche::QuicheStringPiece /*sample*/) { return std::string(5, 0); } @@ -82,12 +83,12 @@ return plaintext_size + GetHashLength(); } -QuicStringPiece NullEncrypter::GetKey() const { - return QuicStringPiece(); +quiche::QuicheStringPiece NullEncrypter::GetKey() const { + return quiche::QuicheStringPiece(); } -QuicStringPiece NullEncrypter::GetNoncePrefix() const { - return QuicStringPiece(); +quiche::QuicheStringPiece NullEncrypter::GetNoncePrefix() const { + return quiche::QuicheStringPiece(); } size_t NullEncrypter::GetHashLength() const {
diff --git a/quic/core/crypto/null_encrypter.h b/quic/core/crypto/null_encrypter.h index efd6e23..bda73dc 100644 --- a/quic/core/crypto/null_encrypter.h +++ b/quic/core/crypto/null_encrypter.h
@@ -10,7 +10,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h" #include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -25,24 +25,25 @@ ~NullEncrypter() override {} // QuicEncrypter implementation - bool SetKey(QuicStringPiece key) override; - bool SetNoncePrefix(QuicStringPiece nonce_prefix) override; - bool SetIV(QuicStringPiece iv) override; - bool SetHeaderProtectionKey(QuicStringPiece key) override; + bool SetKey(quiche::QuicheStringPiece key) override; + bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) override; + bool SetIV(quiche::QuicheStringPiece iv) override; + bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override; bool EncryptPacket(uint64_t packet_number, - QuicStringPiece associated_data, - QuicStringPiece plaintext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext, char* output, size_t* output_length, size_t max_output_length) override; - std::string GenerateHeaderProtectionMask(QuicStringPiece sample) override; + std::string GenerateHeaderProtectionMask( + quiche::QuicheStringPiece sample) override; size_t GetKeySize() const override; size_t GetNoncePrefixSize() const override; size_t GetIVSize() const override; size_t GetMaxPlaintextSize(size_t ciphertext_size) const override; size_t GetCiphertextSize(size_t plaintext_size) const override; - QuicStringPiece GetKey() const override; - QuicStringPiece GetNoncePrefix() const override; + quiche::QuicheStringPiece GetKey() const override; + quiche::QuicheStringPiece GetNoncePrefix() const override; private: size_t GetHashLength() const;
diff --git a/quic/core/crypto/p256_key_exchange.cc b/quic/core/crypto/p256_key_exchange.cc index 1cabc64..a1b45ba 100644 --- a/quic/core/crypto/p256_key_exchange.cc +++ b/quic/core/crypto/p256_key_exchange.cc
@@ -15,6 +15,7 @@ #include "third_party/boringssl/src/include/openssl/evp.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -32,7 +33,8 @@ } // static -std::unique_ptr<P256KeyExchange> P256KeyExchange::New(QuicStringPiece key) { +std::unique_ptr<P256KeyExchange> P256KeyExchange::New( + quiche::QuicheStringPiece key) { if (key.empty()) { QUIC_DLOG(INFO) << "Private key is empty"; return nullptr; @@ -81,8 +83,9 @@ return std::string(reinterpret_cast<char*>(private_key.get()), key_len); } -bool P256KeyExchange::CalculateSharedKeySync(QuicStringPiece peer_public_value, - std::string* shared_key) const { +bool P256KeyExchange::CalculateSharedKeySync( + quiche::QuicheStringPiece peer_public_value, + std::string* shared_key) const { if (peer_public_value.size() != kUncompressedP256PointBytes) { QUIC_DLOG(INFO) << "Peer public value is invalid"; return false; @@ -111,9 +114,9 @@ return true; } -QuicStringPiece P256KeyExchange::public_value() const { - return QuicStringPiece(reinterpret_cast<const char*>(public_key_), - sizeof(public_key_)); +quiche::QuicheStringPiece P256KeyExchange::public_value() const { + return quiche::QuicheStringPiece(reinterpret_cast<const char*>(public_key_), + sizeof(public_key_)); } } // namespace quic
diff --git a/quic/core/crypto/p256_key_exchange.h b/quic/core/crypto/p256_key_exchange.h index a4e5709..10cc542 100644 --- a/quic/core/crypto/p256_key_exchange.h +++ b/quic/core/crypto/p256_key_exchange.h
@@ -11,7 +11,7 @@ #include "third_party/boringssl/src/include/openssl/base.h" #include "net/third_party/quiche/src/quic/core/crypto/key_exchange.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -26,7 +26,8 @@ // New creates a new key-exchange object from a private key. If |private_key| // is invalid, nullptr is returned. - static std::unique_ptr<P256KeyExchange> New(QuicStringPiece private_key); + static std::unique_ptr<P256KeyExchange> New( + quiche::QuicheStringPiece private_key); // NewPrivateKey returns a private key, suitable for passing to |New|. // If |NewPrivateKey| can't generate a private key, it returns an empty @@ -34,9 +35,9 @@ static std::string NewPrivateKey(); // SynchronousKeyExchange interface. - bool CalculateSharedKeySync(QuicStringPiece peer_public_value, + bool CalculateSharedKeySync(quiche::QuicheStringPiece peer_public_value, std::string* shared_key) const override; - QuicStringPiece public_value() const override; + quiche::QuicheStringPiece public_value() const override; QuicTag type() const override { return kP256; } private:
diff --git a/quic/core/crypto/p256_key_exchange_test.cc b/quic/core/crypto/p256_key_exchange_test.cc index 5e81be4..7e7dcd7 100644 --- a/quic/core/crypto/p256_key_exchange_test.cc +++ b/quic/core/crypto/p256_key_exchange_test.cc
@@ -9,6 +9,7 @@ #include <utility> #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { namespace test { @@ -56,8 +57,8 @@ ASSERT_TRUE(alice != nullptr); ASSERT_TRUE(bob != nullptr); - const QuicStringPiece alice_public(alice->public_value()); - const QuicStringPiece bob_public(bob->public_value()); + const quiche::QuicheStringPiece alice_public(alice->public_value()); + const quiche::QuicheStringPiece bob_public(bob->public_value()); std::string alice_shared, bob_shared; ASSERT_TRUE(alice->CalculateSharedKeySync(bob_public, &alice_shared)); @@ -83,8 +84,8 @@ ASSERT_TRUE(alice != nullptr); ASSERT_TRUE(bob != nullptr); - const QuicStringPiece alice_public(alice->public_value()); - const QuicStringPiece bob_public(bob->public_value()); + const quiche::QuicheStringPiece alice_public(alice->public_value()); + const quiche::QuicheStringPiece bob_public(bob->public_value()); std::string alice_shared, bob_shared; TestCallbackResult alice_result;
diff --git a/quic/core/crypto/proof_source.h b/quic/core/crypto/proof_source.h index f774efc..da28612 100644 --- a/quic/core/crypto/proof_source.h +++ b/quic/core/crypto/proof_source.h
@@ -14,7 +14,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.h" #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -116,7 +116,7 @@ const std::string& hostname, const std::string& server_config, QuicTransportVersion transport_version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, std::unique_ptr<Callback> callback) = 0; // Returns the certificate chain for |hostname| in leaf-first order. @@ -136,7 +136,7 @@ const QuicSocketAddress& server_address, const std::string& hostname, uint16_t signature_algorithm, - QuicStringPiece in, + quiche::QuicheStringPiece in, std::unique_ptr<SignatureCallback> callback) = 0; };
diff --git a/quic/core/crypto/proof_verifier.h b/quic/core/crypto/proof_verifier.h index 38e978a..12036d6 100644 --- a/quic/core/crypto/proof_verifier.h +++ b/quic/core/crypto/proof_verifier.h
@@ -12,7 +12,7 @@ #include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/core/quic_versions.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -79,7 +79,7 @@ const uint16_t port, const std::string& server_config, QuicTransportVersion transport_version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, const std::vector<std::string>& certs, const std::string& cert_sct, const std::string& signature,
diff --git a/quic/core/crypto/quic_compressed_certs_cache_test.cc b/quic/core/crypto/quic_compressed_certs_cache_test.cc index f27ed0d..e8f7309 100644 --- a/quic/core/crypto/quic_compressed_certs_cache_test.cc +++ b/quic/core/crypto/quic_compressed_certs_cache_test.cc
@@ -8,8 +8,8 @@ #include "net/third_party/quiche/src/quic/core/crypto/cert_compressor.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { @@ -17,7 +17,7 @@ namespace { -class QuicCompressedCertsCacheTest : public testing::Test { +class QuicCompressedCertsCacheTest : public QuicTest { public: QuicCompressedCertsCacheTest() : certs_cache_(QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {} @@ -85,8 +85,8 @@ for (unsigned int i = 0; i < QuicCompressedCertsCache::kQuicCompressedCertsCacheSize; i++) { EXPECT_EQ(certs_cache_.Size(), i + 1); - certs_cache_.Insert(chain, QuicTextUtils::Uint64ToString(i), "", - QuicTextUtils::Uint64ToString(i)); + certs_cache_.Insert(chain, quiche::QuicheTextUtils::Uint64ToString(i), "", + quiche::QuicheTextUtils::Uint64ToString(i)); } EXPECT_EQ(certs_cache_.MaxSize(), certs_cache_.Size());
diff --git a/quic/core/crypto/quic_crypter.cc b/quic/core/crypto/quic_crypter.cc index dc5bfb3..d8e7f2d 100644 --- a/quic/core/crypto/quic_crypter.cc +++ b/quic/core/crypto/quic_crypter.cc
@@ -3,11 +3,13 @@ // found in the LICENSE file. #include "net/third_party/quiche/src/quic/core/crypto/quic_crypter.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { -bool QuicCrypter::SetNoncePrefixOrIV(const ParsedQuicVersion& version, - QuicStringPiece nonce_prefix_or_iv) { +bool QuicCrypter::SetNoncePrefixOrIV( + const ParsedQuicVersion& version, + quiche::QuicheStringPiece nonce_prefix_or_iv) { if (version.UsesInitialObfuscators()) { return SetIV(nonce_prefix_or_iv); }
diff --git a/quic/core/crypto/quic_crypter.h b/quic/core/crypto/quic_crypter.h index 25a91e4..a12cd6f 100644 --- a/quic/core/crypto/quic_crypter.h +++ b/quic/core/crypto/quic_crypter.h
@@ -7,7 +7,7 @@ #include "net/third_party/quiche/src/quic/core/quic_versions.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -24,7 +24,7 @@ // // NOTE: The key is the client_write_key or server_write_key derived from // the master secret. - virtual bool SetKey(QuicStringPiece key) = 0; + virtual bool SetKey(quiche::QuicheStringPiece key) = 0; // Sets the fixed initial bytes of the nonce. Returns true on success, // false on failure. This method must only be used with Google QUIC crypters. @@ -41,7 +41,7 @@ // // The security of the nonce format requires that QUIC never reuse a // packet number, even when retransmitting a lost packet. - virtual bool SetNoncePrefix(QuicStringPiece nonce_prefix) = 0; + virtual bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) = 0; // Sets |iv| as the initialization vector to use when constructing the nonce. // Returns true on success, false on failure. This method must only be used @@ -68,15 +68,15 @@ // // The security of the nonce format requires that QUIC never reuse a // packet number, even when retransmitting a lost packet. - virtual bool SetIV(QuicStringPiece iv) = 0; + virtual bool SetIV(quiche::QuicheStringPiece iv) = 0; // Calls SetNoncePrefix or SetIV depending on whether |version| uses the // Google QUIC crypto or IETF QUIC nonce construction. virtual bool SetNoncePrefixOrIV(const ParsedQuicVersion& version, - QuicStringPiece nonce_prefix_or_iv); + quiche::QuicheStringPiece nonce_prefix_or_iv); // Sets the key to use for header protection. - virtual bool SetHeaderProtectionKey(QuicStringPiece key) = 0; + virtual bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) = 0; // GetKeySize, GetIVSize, and GetNoncePrefixSize are used to know how many // bytes of key material needs to be derived from the master secret.
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc index d674126..330192b 100644 --- a/quic/core/crypto/quic_crypto_client_config.cc +++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -32,8 +32,8 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h" #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { @@ -153,7 +153,7 @@ QuicCryptoClientConfig::CachedState::ServerConfigState QuicCryptoClientConfig::CachedState::SetServerConfig( - QuicStringPiece server_config, + quiche::QuicheStringPiece server_config, QuicWallTime now, QuicWallTime expiry_time, std::string* error_details) { @@ -211,9 +211,9 @@ void QuicCryptoClientConfig::CachedState::SetProof( const std::vector<std::string>& certs, - QuicStringPiece cert_sct, - QuicStringPiece chlo_hash, - QuicStringPiece signature) { + quiche::QuicheStringPiece cert_sct, + quiche::QuicheStringPiece chlo_hash, + quiche::QuicheStringPiece signature) { bool has_changed = signature != server_config_sig_ || chlo_hash != chlo_hash_ || certs_.size() != certs.size(); @@ -272,12 +272,12 @@ } bool QuicCryptoClientConfig::CachedState::Initialize( - QuicStringPiece server_config, - QuicStringPiece source_address_token, + quiche::QuicheStringPiece server_config, + quiche::QuicheStringPiece source_address_token, const std::vector<std::string>& certs, const std::string& cert_sct, - QuicStringPiece chlo_hash, - QuicStringPiece signature, + quiche::QuicheStringPiece chlo_hash, + quiche::QuicheStringPiece signature, QuicWallTime now, QuicWallTime expiration_time) { DCHECK(server_config_.empty()); @@ -345,12 +345,12 @@ } void QuicCryptoClientConfig::CachedState::set_source_address_token( - QuicStringPiece token) { + quiche::QuicheStringPiece token) { source_address_token_ = std::string(token); } void QuicCryptoClientConfig::CachedState::set_cert_sct( - QuicStringPiece cert_sct) { + quiche::QuicheStringPiece cert_sct) { cert_sct_ = std::string(cert_sct); } @@ -472,7 +472,7 @@ // the STK can be validated by the server. const CryptoHandshakeMessage* scfg = cached->GetServerConfig(); if (scfg != nullptr) { - QuicStringPiece scid; + quiche::QuicheStringPiece scid; if (scfg->GetStringPiece(kSCID, &scid)) { out->SetStringPiece(kSCID, scid); } @@ -488,8 +488,8 @@ char proof_nonce[32]; rand->RandBytes(proof_nonce, QUIC_ARRAYSIZE(proof_nonce)); - out->SetStringPiece( - kNONP, QuicStringPiece(proof_nonce, QUIC_ARRAYSIZE(proof_nonce))); + out->SetStringPiece(kNONP, quiche::QuicheStringPiece( + proof_nonce, QUIC_ARRAYSIZE(proof_nonce))); out->SetVector(kPDMD, QuicTagVector{kX509}); @@ -550,7 +550,7 @@ return QUIC_CRYPTO_INTERNAL_ERROR; } - QuicStringPiece scid; + quiche::QuicheStringPiece scid; if (!scfg->GetStringPiece(kSCID, &scid)) { *error_details = "SCFG missing SCID"; return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER; @@ -582,14 +582,14 @@ out->SetVector(kAEAD, QuicTagVector{out_params->aead}); out->SetVector(kKEXS, QuicTagVector{out_params->key_exchange}); - QuicStringPiece public_value; + quiche::QuicheStringPiece public_value; if (scfg->GetNthValue24(kPUBS, key_exchange_index, &public_value) != QUIC_NO_ERROR) { *error_details = "Missing public value"; return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER; } - QuicStringPiece orbit; + quiche::QuicheStringPiece orbit; if (!scfg->GetStringPiece(kORBT, &orbit) || orbit.size() != kOrbitSize) { *error_details = "SCFG missing OBIT"; return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND; @@ -672,13 +672,13 @@ const CryptoHandshakeMessage& message, QuicWallTime now, QuicTransportVersion /*version*/, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, const std::vector<std::string>& cached_certs, CachedState* cached, std::string* error_details) { DCHECK(error_details != nullptr); - QuicStringPiece scfg; + quiche::QuicheStringPiece scfg; if (!message.GetStringPiece(kSCFG, &scfg)) { *error_details = "Missing SCFG"; return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND; @@ -703,12 +703,12 @@ return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER; } - QuicStringPiece token; + quiche::QuicheStringPiece token; if (message.GetStringPiece(kSourceAddressTokenTag, &token)) { cached->set_source_address_token(token); } - QuicStringPiece proof, cert_bytes, cert_sct; + quiche::QuicheStringPiece proof, cert_bytes, cert_sct; bool has_proof = message.GetStringPiece(kPROF, &proof); bool has_cert = message.GetStringPiece(kCertificateTag, &cert_bytes); if (has_proof && has_cert) { @@ -744,7 +744,7 @@ const CryptoHandshakeMessage& rej, QuicWallTime now, const QuicTransportVersion version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, CachedState* cached, QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params, std::string* error_details) { @@ -762,7 +762,7 @@ return error; } - QuicStringPiece nonce; + quiche::QuicheStringPiece nonce; if (rej.GetStringPiece(kServerNonceTag, &nonce)) { out_params->server_nonce = std::string(nonce); } @@ -787,12 +787,12 @@ } // Learn about updated source address tokens. - QuicStringPiece token; + quiche::QuicheStringPiece token; if (server_hello.GetStringPiece(kSourceAddressTokenTag, &token)) { cached->set_source_address_token(token); } - QuicStringPiece shlo_nonce; + quiche::QuicheStringPiece shlo_nonce; if (!server_hello.GetStringPiece(kServerNonceTag, &shlo_nonce)) { *error_details = "server hello missing server nonce"; return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER; @@ -801,7 +801,7 @@ // TODO(agl): // learn about updated SCFGs. - QuicStringPiece public_value; + quiche::QuicheStringPiece public_value; if (!server_hello.GetStringPiece(kPUBS, &public_value)) { *error_details = "server hello missing forward secure public value"; return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER; @@ -837,7 +837,7 @@ const CryptoHandshakeMessage& server_config_update, QuicWallTime now, const QuicTransportVersion version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, CachedState* cached, QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params, std::string* error_details) { @@ -886,8 +886,8 @@ DCHECK(server_state->IsEmpty()); size_t i = 0; for (; i < canonical_suffixes_.size(); ++i) { - if (QuicTextUtils::EndsWithIgnoreCase(server_id.host(), - canonical_suffixes_[i])) { + if (quiche::QuicheTextUtils::EndsWithIgnoreCase(server_id.host(), + canonical_suffixes_[i])) { break; } }
diff --git a/quic/core/crypto/quic_crypto_client_config.h b/quic/core/crypto/quic_crypto_client_config.h index a3e1bcd..fa96902 100644 --- a/quic/core/crypto/quic_crypto_client_config.h +++ b/quic/core/crypto/quic_crypto_client_config.h
@@ -20,7 +20,7 @@ #include "net/third_party/quiche/src/quic/core/quic_server_id.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -125,7 +125,7 @@ // SetServerConfig checks that |server_config| parses correctly and stores // it in |server_config_|. |now| is used to judge whether |server_config| // has expired. - ServerConfigState SetServerConfig(QuicStringPiece server_config, + ServerConfigState SetServerConfig(quiche::QuicheStringPiece server_config, QuicWallTime now, QuicWallTime expiry_time, std::string* error_details); @@ -135,9 +135,9 @@ // SetProof stores a cert chain, cert signed timestamp and signature. void SetProof(const std::vector<std::string>& certs, - QuicStringPiece cert_sct, - QuicStringPiece chlo_hash, - QuicStringPiece signature); + quiche::QuicheStringPiece cert_sct, + quiche::QuicheStringPiece chlo_hash, + quiche::QuicheStringPiece signature); // Clears all the data. void Clear(); @@ -165,9 +165,9 @@ uint64_t generation_counter() const; const ProofVerifyDetails* proof_verify_details() const; - void set_source_address_token(QuicStringPiece token); + void set_source_address_token(quiche::QuicheStringPiece token); - void set_cert_sct(QuicStringPiece cert_sct); + void set_cert_sct(quiche::QuicheStringPiece cert_sct); // Adds the connection ID to the queue of server-designated connection-ids. void add_server_designated_connection_id(QuicConnectionId connection_id); @@ -206,12 +206,12 @@ // Initializes this cached state based on the arguments provided. // Returns false if there is a problem parsing the server config. - bool Initialize(QuicStringPiece server_config, - QuicStringPiece source_address_token, + bool Initialize(quiche::QuicheStringPiece server_config, + quiche::QuicheStringPiece source_address_token, const std::vector<std::string>& certs, const std::string& cert_sct, - QuicStringPiece chlo_hash, - QuicStringPiece signature, + quiche::QuicheStringPiece chlo_hash, + quiche::QuicheStringPiece signature, QuicWallTime now, QuicWallTime expiration_time); @@ -323,7 +323,7 @@ const CryptoHandshakeMessage& rej, QuicWallTime now, QuicTransportVersion version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, CachedState* cached, QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params, std::string* error_details); @@ -355,7 +355,7 @@ const CryptoHandshakeMessage& server_update, QuicWallTime now, const QuicTransportVersion version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, CachedState* cached, QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params, std::string* error_details); @@ -389,7 +389,7 @@ // Saves the |alpn| that will be passed in QUIC's CHLO message. void set_alpn(const std::string& alpn) { alpn_ = alpn; } - void set_pre_shared_key(QuicStringPiece psk) { + void set_pre_shared_key(quiche::QuicheStringPiece psk) { pre_shared_key_ = std::string(psk); } @@ -413,7 +413,7 @@ const CryptoHandshakeMessage& message, QuicWallTime now, QuicTransportVersion version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, const std::vector<std::string>& cached_certs, CachedState* cached, std::string* error_details);
diff --git a/quic/core/crypto/quic_crypto_client_config_test.cc b/quic/core/crypto/quic_crypto_client_config_test.cc index acf26d6..95f76c6 100644 --- a/quic/core/crypto/quic_crypto_client_config_test.cc +++ b/quic/core/crypto/quic_crypto_client_config_test.cc
@@ -14,6 +14,7 @@ #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" #include "net/third_party/quiche/src/quic/test_tools/mock_random.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" using testing::StartsWith; @@ -188,13 +189,13 @@ QuicVersionLabel cver; EXPECT_THAT(msg.GetVersionLabel(kVER, &cver), IsQuicNoError()); EXPECT_EQ(CreateQuicVersionLabel(QuicVersionMax()), cver); - QuicStringPiece proof_nonce; + quiche::QuicheStringPiece proof_nonce; EXPECT_TRUE(msg.GetStringPiece(kNONP, &proof_nonce)); EXPECT_EQ(std::string(32, 'r'), proof_nonce); - QuicStringPiece user_agent_id; + quiche::QuicheStringPiece user_agent_id; EXPECT_TRUE(msg.GetStringPiece(kUAID, &user_agent_id)); EXPECT_EQ("quic-tester", user_agent_id); - QuicStringPiece alpn; + quiche::QuicheStringPiece alpn; EXPECT_TRUE(msg.GetStringPiece(kALPN, &alpn)); EXPECT_EQ("hq", alpn); @@ -243,7 +244,7 @@ QuicTag pdmd; EXPECT_THAT(msg.GetUint32(kPDMD, &pdmd), IsQuicNoError()); EXPECT_EQ(kX509, pdmd); - QuicStringPiece scid; + quiche::QuicheStringPiece scid; EXPECT_FALSE(msg.GetStringPiece(kSCID, &scid)); } @@ -269,7 +270,7 @@ config.FillInchoateClientHello(server_id, QuicVersionMax(), &state, &rand, /* demand_x509_proof= */ true, params, &msg); - QuicStringPiece scid; + quiche::QuicheStringPiece scid; EXPECT_TRUE(msg.GetStringPiece(kSCID, &scid)); EXPECT_EQ("12345678", scid); } @@ -295,7 +296,7 @@ config.FillInchoateClientHello(server_id, QuicVersionMax(), &state, &rand, /* demand_x509_proof= */ true, params, &msg); - QuicStringPiece scid; + quiche::QuicheStringPiece scid; EXPECT_TRUE(msg.GetStringPiece(kSCID, &scid)); EXPECT_EQ("12345678", scid); }
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc index d568986..9c40d8f 100644 --- a/quic/core/crypto/quic_crypto_server_config.cc +++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -44,8 +44,8 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { @@ -60,11 +60,11 @@ const int kMaxTokenAddresses = 4; std::string DeriveSourceAddressTokenKey( - QuicStringPiece source_address_token_secret) { - QuicHKDF hkdf(source_address_token_secret, QuicStringPiece() /* no salt */, - "QUIC source address token key", - CryptoSecretBoxer::GetKeySize(), 0 /* no fixed IV needed */, - 0 /* no subkey secret */); + quiche::QuicheStringPiece source_address_token_secret) { + QuicHKDF hkdf( + source_address_token_secret, quiche::QuicheStringPiece() /* no salt */, + "QUIC source address token key", CryptoSecretBoxer::GetKeySize(), + 0 /* no fixed IV needed */, 0 /* no subkey secret */); return std::string(hkdf.server_write_key()); } @@ -78,7 +78,7 @@ std::string /*server_config_id*/, bool /* is_fallback */, QuicTag type, - QuicStringPiece private_key) override { + quiche::QuicheStringPiece private_key) override { if (private_key.empty()) { QUIC_LOG(WARNING) << "Server config contains key exchange method without " "corresponding private key of type " @@ -228,7 +228,7 @@ } QuicCryptoServerConfig::QuicCryptoServerConfig( - QuicStringPiece source_address_token_secret, + quiche::QuicheStringPiece source_address_token_secret, QuicRandom* server_nonce_entropy, std::unique_ptr<ProofSource> proof_source, std::unique_ptr<KeyExchangeSource> key_exchange_source) @@ -276,7 +276,8 @@ Curve25519KeyExchange::NewPrivateKey(rand); std::unique_ptr<Curve25519KeyExchange> curve25519 = Curve25519KeyExchange::New(curve25519_private_key); - QuicStringPiece curve25519_public_value = curve25519->public_value(); + quiche::QuicheStringPiece curve25519_public_value = + curve25519->public_value(); std::string encoded_public_values; // First three bytes encode the length of the public value. @@ -295,7 +296,7 @@ p256_private_key = P256KeyExchange::NewPrivateKey(); std::unique_ptr<P256KeyExchange> p256( P256KeyExchange::New(p256_private_key)); - QuicStringPiece p256_public_value = p256->public_value(); + quiche::QuicheStringPiece p256_public_value = p256->public_value(); DCHECK_LT(p256_public_value.size(), (1U << 24)); encoded_public_values.push_back( @@ -334,7 +335,8 @@ DCHECK(options.orbit.empty()); rand->RandBytes(orbit_bytes, sizeof(orbit_bytes)); } - msg.SetStringPiece(kORBT, QuicStringPiece(orbit_bytes, sizeof(orbit_bytes))); + msg.SetStringPiece( + kORBT, quiche::QuicheStringPiece(orbit_bytes, sizeof(orbit_bytes))); if (options.channel_id_enabled) { msg.SetVector(kPDMD, QuicTagVector{kCHID}); @@ -351,8 +353,9 @@ serialized->length(), scid_bytes); // The SCID is a truncated SHA-256 digest. static_assert(16 <= SHA256_DIGEST_LENGTH, "SCID length too high."); - msg.SetStringPiece( - kSCID, QuicStringPiece(reinterpret_cast<const char*>(scid_bytes), 16)); + msg.SetStringPiece(kSCID, + quiche::QuicheStringPiece( + reinterpret_cast<const char*>(scid_bytes), 16)); } else { msg.SetStringPiece(kSCID, options.id); } @@ -401,7 +404,7 @@ if (configs_.find(config->id) != configs_.end()) { QUIC_LOG(WARNING) << "Failed to add config because another with the same " "server config id already exists: " - << QuicTextUtils::HexEncode(config->id); + << quiche::QuicheTextUtils::HexEncode(config->id); return nullptr; } @@ -447,7 +450,7 @@ return false; } QUIC_LOG(INFO) << "Fallback config has scid " - << QuicTextUtils::HexEncode(fallback_config->id); + << quiche::QuicheTextUtils::HexEncode(fallback_config->id); parsed_configs.push_back(fallback_config); } else { QUIC_LOG(INFO) << "No fallback config provided"; @@ -467,25 +470,24 @@ for (const QuicReferenceCountedPointer<Config>& config : parsed_configs) { auto it = configs_.find(config->id); if (it != configs_.end()) { - QUIC_LOG(INFO) << "Keeping scid: " << QuicTextUtils::HexEncode(config->id) - << " orbit: " - << QuicTextUtils::HexEncode( - reinterpret_cast<const char*>(config->orbit), - kOrbitSize) - << " new primary_time " - << config->primary_time.ToUNIXSeconds() - << " old primary_time " - << it->second->primary_time.ToUNIXSeconds() - << " new priority " << config->priority << " old priority " - << it->second->priority; + QUIC_LOG(INFO) + << "Keeping scid: " << quiche::QuicheTextUtils::HexEncode(config->id) + << " orbit: " + << quiche::QuicheTextUtils::HexEncode( + reinterpret_cast<const char*>(config->orbit), kOrbitSize) + << " new primary_time " << config->primary_time.ToUNIXSeconds() + << " old primary_time " << it->second->primary_time.ToUNIXSeconds() + << " new priority " << config->priority << " old priority " + << it->second->priority; // Update primary_time and priority. it->second->primary_time = config->primary_time; it->second->priority = config->priority; new_configs.insert(*it); } else { - QUIC_LOG(INFO) << "Adding scid: " << QuicTextUtils::HexEncode(config->id) + QUIC_LOG(INFO) << "Adding scid: " + << quiche::QuicheTextUtils::HexEncode(config->id) << " orbit: " - << QuicTextUtils::HexEncode( + << quiche::QuicheTextUtils::HexEncode( reinterpret_cast<const char*>(config->orbit), kOrbitSize) << " primary_time " << config->primary_time.ToUNIXSeconds() @@ -531,7 +533,7 @@ new ValidateClientHelloResultCallback::Result(client_hello, client_ip, now)); - QuicStringPiece requested_scid; + quiche::QuicheStringPiece requested_scid; client_hello.GetStringPiece(kSCID, &requested_scid); Configs configs; if (!GetCurrentConfigs(now, requested_scid, @@ -587,7 +589,7 @@ std::unique_ptr<ProofSource::Details> proof_source_details, QuicTag key_exchange_type, std::unique_ptr<CryptoHandshakeMessage> out, - QuicStringPiece public_value, + quiche::QuicheStringPiece public_value, std::unique_ptr<ProcessClientHelloContext> context, const Configs& configs) : config_(config), @@ -680,7 +682,7 @@ return; } - QuicStringPiece requested_scid; + quiche::QuicheStringPiece requested_scid; context->client_hello().GetStringPiece(kSCID, &requested_scid); Configs configs; if (!GetCurrentConfigs(context->clock()->WallNow(), requested_scid, @@ -740,7 +742,7 @@ auto out_diversification_nonce = std::make_unique<DiversificationNonce>(); - QuicStringPiece cert_sct; + quiche::QuicheStringPiece cert_sct; if (context->client_hello().GetStringPiece(kCertificateSCTTag, &cert_sct) && cert_sct.empty()) { context->params()->sct_supported_by_client = true; @@ -783,7 +785,7 @@ return; } - QuicStringPiece public_value; + quiche::QuicheStringPiece public_value; if (!context->client_hello().GetStringPiece(kPUBS, &public_value)) { context->Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER, "Missing public value"); @@ -806,7 +808,7 @@ std::unique_ptr<ProofSource::Details> proof_source_details, QuicTag key_exchange_type, std::unique_ptr<CryptoHandshakeMessage> out, - QuicStringPiece public_value, + quiche::QuicheStringPiece public_value, std::unique_ptr<ProcessClientHelloContext> context, const Configs& configs) const { QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion( @@ -853,7 +855,7 @@ } hkdf_suffix.append(context->signed_config()->chain->certs.at(0)); - QuicStringPiece cetv_ciphertext; + quiche::QuicheStringPiece cetv_ciphertext; if (configs.requested->channel_id_enabled && context->client_hello().GetStringPiece(kCETV, &cetv_ciphertext)) { CryptoHandshakeMessage client_hello_copy(context->client_hello()); @@ -886,21 +888,22 @@ char plaintext[kMaxOutgoingPacketSize]; size_t plaintext_length = 0; const bool success = crypters.decrypter->DecryptPacket( - 0 /* packet number */, QuicStringPiece() /* associated data */, - cetv_ciphertext, plaintext, &plaintext_length, kMaxOutgoingPacketSize); + 0 /* packet number */, + quiche::QuicheStringPiece() /* associated data */, cetv_ciphertext, + plaintext, &plaintext_length, kMaxOutgoingPacketSize); if (!success) { context->Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER, "CETV decryption failure"); return; } std::unique_ptr<CryptoHandshakeMessage> cetv(CryptoFramer::ParseMessage( - QuicStringPiece(plaintext, plaintext_length))); + quiche::QuicheStringPiece(plaintext, plaintext_length))); if (!cetv) { context->Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER, "CETV parse error"); return; } - QuicStringPiece key, signature; + quiche::QuicheStringPiece key, signature; if (cetv->GetStringPiece(kCIDK, &key) && cetv->GetStringPiece(kCIDS, &signature)) { if (!ChannelIDVerifier::Verify(key, hkdf_input, signature)) { @@ -1037,7 +1040,7 @@ QuicReferenceCountedPointer<QuicCryptoServerConfig::Config> QuicCryptoServerConfig::GetConfigWithScid( - QuicStringPiece requested_scid) const { + quiche::QuicheStringPiece requested_scid) const { configs_lock_.AssertReaderHeld(); if (!requested_scid.empty()) { @@ -1054,7 +1057,7 @@ bool QuicCryptoServerConfig::GetCurrentConfigs( const QuicWallTime& now, - QuicStringPiece requested_scid, + quiche::QuicheStringPiece requested_scid, QuicReferenceCountedPointer<Config> old_primary_config, Configs* configs) const { QuicReaderMutexLock locked(&configs_lock_); @@ -1157,9 +1160,10 @@ primary_config_ = new_primary; new_primary->is_primary = true; QUIC_DLOG(INFO) << "New primary config. orbit: " - << QuicTextUtils::HexEncode(reinterpret_cast<const char*>( - primary_config_->orbit), - kOrbitSize); + << quiche::QuicheTextUtils::HexEncode( + reinterpret_cast<const char*>( + primary_config_->orbit), + kOrbitSize); if (primary_config_changed_cb_ != nullptr) { primary_config_changed_cb_->Run(primary_config_->id); } @@ -1176,10 +1180,11 @@ primary_config_ = new_primary; new_primary->is_primary = true; QUIC_DLOG(INFO) << "New primary config. orbit: " - << QuicTextUtils::HexEncode( + << quiche::QuicheTextUtils::HexEncode( reinterpret_cast<const char*>(primary_config_->orbit), kOrbitSize) - << " scid: " << QuicTextUtils::HexEncode(primary_config_->id); + << " scid: " + << quiche::QuicheTextUtils::HexEncode(primary_config_->id); next_config_promotion_time_ = QuicWallTime::Zero(); if (primary_config_changed_cb_ != nullptr) { primary_config_changed_cb_->Run(primary_config_->id); @@ -1215,7 +1220,7 @@ HandshakeFailureReason source_address_token_error = MAX_FAILURE_REASON; if (validate_source_address_token_) { - QuicStringPiece srct; + quiche::QuicheStringPiece srct; if (client_hello.GetStringPiece(kSourceAddressTokenTag, &srct)) { Config& config = configs.requested != nullptr ? *configs.requested : *configs.primary; @@ -1238,7 +1243,7 @@ } if (!configs.requested) { - QuicStringPiece requested_scid; + quiche::QuicheStringPiece requested_scid; if (client_hello.GetStringPiece(kSCID, &requested_scid)) { info->reject_reasons.push_back(SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE); } else { @@ -1292,7 +1297,7 @@ void QuicCryptoServerConfig::BuildServerConfigUpdateMessage( QuicTransportVersion version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, const SourceAddressTokens& previous_source_address_tokens, const QuicSocketAddress& server_address, const QuicIpAddress& client_ip, @@ -1440,13 +1445,13 @@ return; } - QuicStringPiece client_common_set_hashes; + quiche::QuicheStringPiece client_common_set_hashes; if (context.client_hello().GetStringPiece(kCCS, &client_common_set_hashes)) { context.params()->client_common_set_hashes = std::string(client_common_set_hashes); } - QuicStringPiece client_cached_cert_hashes; + quiche::QuicheStringPiece client_cached_cert_hashes; if (context.client_hello().GetStringPiece(kCCRT, &client_cached_cert_hashes)) { context.params()->client_cached_cert_hashes = @@ -1494,7 +1499,7 @@ // This is for debugging b/28342827. const std::vector<std::string>& certs = context.signed_config()->chain->certs; - QuicStringPiece ca_subject; + quiche::QuicheStringPiece ca_subject; if (!certs.empty()) { QuicCertUtils::ExtractSubjectNameFromDERCert(certs[0], &ca_subject); } @@ -1561,7 +1566,7 @@ config->priority = protobuf.priority(); - QuicStringPiece scid; + quiche::QuicheStringPiece scid; if (!msg->GetStringPiece(kSCID, &scid)) { QUIC_LOG(WARNING) << "Server config message is missing SCID"; return nullptr; @@ -1579,7 +1584,7 @@ return nullptr; } - QuicStringPiece orbit; + quiche::QuicheStringPiece orbit; if (!msg->GetStringPiece(kORBT, &orbit)) { QUIC_LOG(WARNING) << "Server config message is missing ORBT"; return nullptr; @@ -1733,10 +1738,10 @@ HandshakeFailureReason QuicCryptoServerConfig::ParseSourceAddressToken( const Config& config, - QuicStringPiece token, + quiche::QuicheStringPiece token, SourceAddressTokens* tokens) const { std::string storage; - QuicStringPiece plaintext; + quiche::QuicheStringPiece plaintext; if (!config.source_address_token_boxer->Unbox(token, &storage, &plaintext)) { return SOURCE_ADDRESS_TOKEN_DECRYPTION_FAILURE; } @@ -1826,8 +1831,8 @@ sizeof(server_nonce) - sizeof(timestamp)); return server_nonce_boxer_.Box( - rand, QuicStringPiece(reinterpret_cast<char*>(server_nonce), - sizeof(server_nonce))); + rand, quiche::QuicheStringPiece(reinterpret_cast<char*>(server_nonce), + sizeof(server_nonce))); } bool QuicCryptoServerConfig::ValidateExpectedLeafCertificate(
diff --git a/quic/core/crypto/quic_crypto_server_config.h b/quic/core/crypto/quic_crypto_server_config.h index 809ebae..20aaa6f 100644 --- a/quic/core/crypto/quic_crypto_server_config.h +++ b/quic/core/crypto/quic_crypto_server_config.h
@@ -28,7 +28,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_mutex.h" #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.h" #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -52,10 +52,10 @@ // Outputs from EvaluateClientHello. bool valid_source_address_token; - QuicStringPiece sni; - QuicStringPiece client_nonce; - QuicStringPiece server_nonce; - QuicStringPiece user_agent_id; + quiche::QuicheStringPiece sni; + quiche::QuicheStringPiece client_nonce; + quiche::QuicheStringPiece server_nonce; + quiche::QuicheStringPiece user_agent_id; SourceAddressTokens source_address_tokens; // Errors from EvaluateClientHello. @@ -169,7 +169,7 @@ std::string server_config_id, bool is_fallback, QuicTag type, - QuicStringPiece private_key) = 0; + quiche::QuicheStringPiece private_key) = 0; }; // QuicCryptoServerConfig contains the crypto configuration of a QUIC server. @@ -213,7 +213,7 @@ // |proof_source|: provides certificate chains and signatures. // |key_exchange_source|: provides key-exchange functionality. QuicCryptoServerConfig( - QuicStringPiece source_address_token_secret, + quiche::QuicheStringPiece source_address_token_secret, QuicRandom* server_nonce_entropy, std::unique_ptr<ProofSource> proof_source, std::unique_ptr<KeyExchangeSource> key_exchange_source); @@ -355,7 +355,7 @@ // |cached_network_params| is optional, and can be nullptr. void BuildServerConfigUpdateMessage( QuicTransportVersion version, - QuicStringPiece chlo_hash, + quiche::QuicheStringPiece chlo_hash, const SourceAddressTokens& previous_source_address_tokens, const QuicSocketAddress& server_address, const QuicIpAddress& client_ip, @@ -425,7 +425,7 @@ SSL_CTX* ssl_ctx() const; - void set_pre_shared_key(QuicStringPiece psk) { + void set_pre_shared_key(quiche::QuicheStringPiece psk) { pre_shared_key_ = std::string(psk); } @@ -507,7 +507,7 @@ // Get a ref to the config with a given server config id. QuicReferenceCountedPointer<Config> GetConfigWithScid( - QuicStringPiece requested_scid) const + quiche::QuicheStringPiece requested_scid) const QUIC_SHARED_LOCKS_REQUIRED(configs_lock_); // A snapshot of the configs associated with an in-progress handshake. @@ -524,7 +524,7 @@ // Returns true if any configs are loaded. If false is returned, |configs| is // not modified. bool GetCurrentConfigs(const QuicWallTime& now, - QuicStringPiece requested_scid, + quiche::QuicheStringPiece requested_scid, QuicReferenceCountedPointer<Config> old_primary_config, Configs* configs) const; @@ -677,7 +677,7 @@ std::unique_ptr<ProofSource::Details> proof_source_details, QuicTag key_exchange_type, std::unique_ptr<CryptoHandshakeMessage> out, - QuicStringPiece public_value, + quiche::QuicheStringPiece public_value, std::unique_ptr<ProcessClientHelloContext> context, const Configs& configs) const; @@ -751,7 +751,7 @@ // failure. HandshakeFailureReason ParseSourceAddressToken( const Config& config, - QuicStringPiece token, + quiche::QuicheStringPiece token, SourceAddressTokens* tokens) const; // ValidateSourceAddressTokens returns HANDSHAKE_OK if the source address
diff --git a/quic/core/crypto/quic_crypto_server_config_test.cc b/quic/core/crypto/quic_crypto_server_config_test.cc index ce47d24..df9b904 100644 --- a/quic/core/crypto/quic_crypto_server_config_test.cc +++ b/quic/core/crypto/quic_crypto_server_config_test.cc
@@ -18,11 +18,12 @@ #include "net/third_party/quiche/src/quic/core/quic_time.h" #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h" #include "net/third_party/quiche/src/quic/test_tools/quic_crypto_server_config_peer.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { namespace test { @@ -140,7 +141,7 @@ static const uint64_t set_hash = 42; std::unique_ptr<CommonCertSets> common_sets( crypto_test_utils::MockCommonCertSets(certs[0], set_hash, 1)); - QuicStringPiece different_common_certs( + quiche::QuicheStringPiece different_common_certs( reinterpret_cast<const char*>(&set_hash), sizeof(set_hash)); std::string compressed3 = QuicCryptoServerConfigPeer::CompressChain( &compressed_certs_cache, chain, std::string(different_common_certs), @@ -191,15 +192,16 @@ clock_.WallNow(), cached_network_params); } - HandshakeFailureReason ValidateSourceAddressTokens(std::string config_id, - QuicStringPiece srct, - const QuicIpAddress& ip) { + HandshakeFailureReason ValidateSourceAddressTokens( + std::string config_id, + quiche::QuicheStringPiece srct, + const QuicIpAddress& ip) { return ValidateSourceAddressTokens(config_id, srct, ip, nullptr); } HandshakeFailureReason ValidateSourceAddressTokens( std::string config_id, - QuicStringPiece srct, + quiche::QuicheStringPiece srct, const QuicIpAddress& ip, CachedNetworkParameters* cached_network_params) { return peer_.ValidateSourceAddressTokens( @@ -353,7 +355,8 @@ QuicCryptoServerConfig::GenerateConfig(rand_, &clock_, options); protobuf.set_primary_time(primary_time); protobuf.set_priority(priority); - if (QuicTextUtils::StartsWith(std::string(server_config_id), "INVALID")) { + if (quiche::QuicheTextUtils::StartsWith(std::string(server_config_id), + "INVALID")) { protobuf.clear_key(); has_invalid = true; }
diff --git a/quic/core/crypto/quic_decrypter.cc b/quic/core/crypto/quic_decrypter.cc index 33c563f..c424901 100644 --- a/quic/core/crypto/quic_decrypter.cc +++ b/quic/core/crypto/quic_decrypter.cc
@@ -18,6 +18,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_hkdf.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -61,15 +62,16 @@ } // static -void QuicDecrypter::DiversifyPreliminaryKey(QuicStringPiece preliminary_key, - QuicStringPiece nonce_prefix, - const DiversificationNonce& nonce, - size_t key_size, - size_t nonce_prefix_size, - std::string* out_key, - std::string* out_nonce_prefix) { +void QuicDecrypter::DiversifyPreliminaryKey( + quiche::QuicheStringPiece preliminary_key, + quiche::QuicheStringPiece nonce_prefix, + const DiversificationNonce& nonce, + size_t key_size, + size_t nonce_prefix_size, + std::string* out_key, + std::string* out_nonce_prefix) { QuicHKDF hkdf((std::string(preliminary_key)) + (std::string(nonce_prefix)), - QuicStringPiece(nonce.data(), nonce.size()), + quiche::QuicheStringPiece(nonce.data(), nonce.size()), "QUIC key diversification", 0, key_size, 0, nonce_prefix_size, 0); *out_key = std::string(hkdf.server_write_key());
diff --git a/quic/core/crypto/quic_decrypter.h b/quic/core/crypto/quic_decrypter.h index aed18e4..7f4d93d 100644 --- a/quic/core/crypto/quic_decrypter.h +++ b/quic/core/crypto/quic_decrypter.h
@@ -14,7 +14,7 @@ #include "net/third_party/quiche/src/quic/core/quic_data_reader.h" #include "net/third_party/quiche/src/quic/core/quic_packets.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -38,7 +38,7 @@ // // If this function is called, neither |SetKey| nor |SetNoncePrefix| may be // called. - virtual bool SetPreliminaryKey(QuicStringPiece key) = 0; + virtual bool SetPreliminaryKey(quiche::QuicheStringPiece key) = 0; // SetDiversificationNonce uses |nonce| to derive final keys based on the // input keying material given by calling |SetPreliminaryKey|. @@ -56,8 +56,8 @@ // TODO(wtc): add a way for DecryptPacket to report decryption failure due // to non-authentic inputs, as opposed to other reasons for failure. virtual bool DecryptPacket(uint64_t packet_number, - QuicStringPiece associated_data, - QuicStringPiece ciphertext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece ciphertext, char* output, size_t* output_length, size_t max_output_length) = 0; @@ -74,11 +74,11 @@ virtual uint32_t cipher_id() const = 0; // For use by unit tests only. - virtual QuicStringPiece GetKey() const = 0; - virtual QuicStringPiece GetNoncePrefix() const = 0; + virtual quiche::QuicheStringPiece GetKey() const = 0; + virtual quiche::QuicheStringPiece GetNoncePrefix() const = 0; - static void DiversifyPreliminaryKey(QuicStringPiece preliminary_key, - QuicStringPiece nonce_prefix, + static void DiversifyPreliminaryKey(quiche::QuicheStringPiece preliminary_key, + quiche::QuicheStringPiece nonce_prefix, const DiversificationNonce& nonce, size_t key_size, size_t nonce_prefix_size,
diff --git a/quic/core/crypto/quic_encrypter.h b/quic/core/crypto/quic_encrypter.h index d318329..6fe552d 100644 --- a/quic/core/crypto/quic_encrypter.h +++ b/quic/core/crypto/quic_encrypter.h
@@ -11,7 +11,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_crypter.h" #include "net/third_party/quiche/src/quic/core/quic_packets.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -36,8 +36,8 @@ // |associated_data|. If |output| overlaps with |plaintext| then // |plaintext| must be <= |output|. virtual bool EncryptPacket(uint64_t packet_number, - QuicStringPiece associated_data, - QuicStringPiece plaintext, + quiche::QuicheStringPiece associated_data, + quiche::QuicheStringPiece plaintext, char* output, size_t* output_length, size_t max_output_length) = 0; @@ -46,7 +46,8 @@ // generate a mask to use for header protection, and returns that mask. On // success, the mask will be at least 5 bytes long; on failure the string will // be empty. - virtual std::string GenerateHeaderProtectionMask(QuicStringPiece sample) = 0; + virtual std::string GenerateHeaderProtectionMask( + quiche::QuicheStringPiece sample) = 0; // Returns the maximum length of plaintext that can be encrypted // to ciphertext no larger than |ciphertext_size|. @@ -57,8 +58,8 @@ virtual size_t GetCiphertextSize(size_t plaintext_size) const = 0; // For use by unit tests only. - virtual QuicStringPiece GetKey() const = 0; - virtual QuicStringPiece GetNoncePrefix() const = 0; + virtual quiche::QuicheStringPiece GetKey() const = 0; + virtual quiche::QuicheStringPiece GetNoncePrefix() const = 0; }; } // namespace quic
diff --git a/quic/core/crypto/quic_hkdf.cc b/quic/core/crypto/quic_hkdf.cc index 1bd9ad5..28cf4a9 100644 --- a/quic/core/crypto/quic_hkdf.cc +++ b/quic/core/crypto/quic_hkdf.cc
@@ -9,15 +9,16 @@ #include "third_party/boringssl/src/include/openssl/digest.h" #include "third_party/boringssl/src/include/openssl/hkdf.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { const size_t kSHA256HashLength = 32; const size_t kMaxKeyMaterialSize = kSHA256HashLength * 256; -QuicHKDF::QuicHKDF(QuicStringPiece secret, - QuicStringPiece salt, - QuicStringPiece info, +QuicHKDF::QuicHKDF(quiche::QuicheStringPiece secret, + quiche::QuicheStringPiece salt, + quiche::QuicheStringPiece info, size_t key_bytes_to_generate, size_t iv_bytes_to_generate, size_t subkey_secret_bytes_to_generate) @@ -30,9 +31,9 @@ iv_bytes_to_generate, subkey_secret_bytes_to_generate) {} -QuicHKDF::QuicHKDF(QuicStringPiece secret, - QuicStringPiece salt, - QuicStringPiece info, +QuicHKDF::QuicHKDF(quiche::QuicheStringPiece secret, + quiche::QuicheStringPiece salt, + quiche::QuicheStringPiece info, size_t client_key_bytes_to_generate, size_t server_key_bytes_to_generate, size_t client_iv_bytes_to_generate, @@ -59,44 +60,44 @@ size_t j = 0; if (client_key_bytes_to_generate) { - client_write_key_ = QuicStringPiece(reinterpret_cast<char*>(&output_[j]), - client_key_bytes_to_generate); + client_write_key_ = quiche::QuicheStringPiece( + reinterpret_cast<char*>(&output_[j]), client_key_bytes_to_generate); j += client_key_bytes_to_generate; } if (server_key_bytes_to_generate) { - server_write_key_ = QuicStringPiece(reinterpret_cast<char*>(&output_[j]), - server_key_bytes_to_generate); + server_write_key_ = quiche::QuicheStringPiece( + reinterpret_cast<char*>(&output_[j]), server_key_bytes_to_generate); j += server_key_bytes_to_generate; } if (client_iv_bytes_to_generate) { - client_write_iv_ = QuicStringPiece(reinterpret_cast<char*>(&output_[j]), - client_iv_bytes_to_generate); + client_write_iv_ = quiche::QuicheStringPiece( + reinterpret_cast<char*>(&output_[j]), client_iv_bytes_to_generate); j += client_iv_bytes_to_generate; } if (server_iv_bytes_to_generate) { - server_write_iv_ = QuicStringPiece(reinterpret_cast<char*>(&output_[j]), - server_iv_bytes_to_generate); + server_write_iv_ = quiche::QuicheStringPiece( + reinterpret_cast<char*>(&output_[j]), server_iv_bytes_to_generate); j += server_iv_bytes_to_generate; } if (subkey_secret_bytes_to_generate) { - subkey_secret_ = QuicStringPiece(reinterpret_cast<char*>(&output_[j]), - subkey_secret_bytes_to_generate); + subkey_secret_ = quiche::QuicheStringPiece( + reinterpret_cast<char*>(&output_[j]), subkey_secret_bytes_to_generate); j += subkey_secret_bytes_to_generate; } // Repeat client and server key bytes for header protection keys. if (client_key_bytes_to_generate) { - client_hp_key_ = QuicStringPiece(reinterpret_cast<char*>(&output_[j]), - client_key_bytes_to_generate); + client_hp_key_ = quiche::QuicheStringPiece( + reinterpret_cast<char*>(&output_[j]), client_key_bytes_to_generate); j += client_key_bytes_to_generate; } if (server_key_bytes_to_generate) { - server_hp_key_ = QuicStringPiece(reinterpret_cast<char*>(&output_[j]), - server_key_bytes_to_generate); + server_hp_key_ = quiche::QuicheStringPiece( + reinterpret_cast<char*>(&output_[j]), server_key_bytes_to_generate); j += server_key_bytes_to_generate; } }
diff --git a/quic/core/crypto/quic_hkdf.h b/quic/core/crypto/quic_hkdf.h index 94d45bc..2945173 100644 --- a/quic/core/crypto/quic_hkdf.h +++ b/quic/core/crypto/quic_hkdf.h
@@ -8,7 +8,7 @@ #include <vector> #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -31,18 +31,18 @@ // client and server. // |subkey_secret_bytes_to_generate|: the number of bytes of subkey secret to // generate, shared between client and server. - QuicHKDF(QuicStringPiece secret, - QuicStringPiece salt, - QuicStringPiece info, + QuicHKDF(quiche::QuicheStringPiece secret, + quiche::QuicheStringPiece salt, + quiche::QuicheStringPiece info, size_t key_bytes_to_generate, size_t iv_bytes_to_generate, size_t subkey_secret_bytes_to_generate); // An alternative constructor that allows the client and server key/IV // lengths to be different. - QuicHKDF(QuicStringPiece secret, - QuicStringPiece salt, - QuicStringPiece info, + QuicHKDF(quiche::QuicheStringPiece secret, + quiche::QuicheStringPiece salt, + quiche::QuicheStringPiece info, size_t client_key_bytes_to_generate, size_t server_key_bytes_to_generate, size_t client_iv_bytes_to_generate, @@ -51,24 +51,28 @@ ~QuicHKDF(); - QuicStringPiece client_write_key() const { return client_write_key_; } - QuicStringPiece client_write_iv() const { return client_write_iv_; } - QuicStringPiece server_write_key() const { return server_write_key_; } - QuicStringPiece server_write_iv() const { return server_write_iv_; } - QuicStringPiece subkey_secret() const { return subkey_secret_; } - QuicStringPiece client_hp_key() const { return client_hp_key_; } - QuicStringPiece server_hp_key() const { return server_hp_key_; } + quiche::QuicheStringPiece client_write_key() const { + return client_write_key_; + } + quiche::QuicheStringPiece client_write_iv() const { return client_write_iv_; } + quiche::QuicheStringPiece server_write_key() const { + return server_write_key_; + } + quiche::QuicheStringPiece server_write_iv() const { return server_write_iv_; } + quiche::QuicheStringPiece subkey_secret() const { return subkey_secret_; } + quiche::QuicheStringPiece client_hp_key() const { return client_hp_key_; } + quiche::QuicheStringPiece server_hp_key() const { return server_hp_key_; } private: std::vector<uint8_t> output_; - QuicStringPiece client_write_key_; - QuicStringPiece server_write_key_; - QuicStringPiece client_write_iv_; - QuicStringPiece server_write_iv_; - QuicStringPiece subkey_secret_; - QuicStringPiece client_hp_key_; - QuicStringPiece server_hp_key_; + quiche::QuicheStringPiece client_write_key_; + quiche::QuicheStringPiece server_write_key_; + quiche::QuicheStringPiece client_write_iv_; + quiche::QuicheStringPiece server_write_iv_; + quiche::QuicheStringPiece subkey_secret_; + quiche::QuicheStringPiece client_hp_key_; + quiche::QuicheStringPiece server_hp_key_; }; } // namespace quic
diff --git a/quic/core/crypto/quic_hkdf_test.cc b/quic/core/crypto/quic_hkdf_test.cc index e40bebf..92dc085 100644 --- a/quic/core/crypto/quic_hkdf_test.cc +++ b/quic/core/crypto/quic_hkdf_test.cc
@@ -8,7 +8,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { namespace test { @@ -71,10 +71,11 @@ const HKDFInput& test(kHKDFInputs[i]); SCOPED_TRACE(i); - const std::string key = QuicTextUtils::HexDecode(test.key_hex); - const std::string salt = QuicTextUtils::HexDecode(test.salt_hex); - const std::string info = QuicTextUtils::HexDecode(test.info_hex); - const std::string expected = QuicTextUtils::HexDecode(test.output_hex); + const std::string key = quiche::QuicheTextUtils::HexDecode(test.key_hex); + const std::string salt = quiche::QuicheTextUtils::HexDecode(test.salt_hex); + const std::string info = quiche::QuicheTextUtils::HexDecode(test.info_hex); + const std::string expected = + quiche::QuicheTextUtils::HexDecode(test.output_hex); // We set the key_length to the length of the expected output and then take // the result from the first key, which is the client write key.
diff --git a/quic/core/crypto/tls_connection.cc b/quic/core/crypto/tls_connection.cc index d28db22..4c59d3e 100644 --- a/quic/core/crypto/tls_connection.cc +++ b/quic/core/crypto/tls_connection.cc
@@ -5,6 +5,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/tls_connection.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -136,7 +137,7 @@ size_t len) { ConnectionFromSsl(ssl)->delegate_->WriteMessage( QuicEncryptionLevel(level), - QuicStringPiece(reinterpret_cast<const char*>(data), len)); + quiche::QuicheStringPiece(reinterpret_cast<const char*>(data), len)); return 1; }
diff --git a/quic/core/crypto/tls_connection.h b/quic/core/crypto/tls_connection.h index fd4f64b..cd9cec0 100644 --- a/quic/core/crypto/tls_connection.h +++ b/quic/core/crypto/tls_connection.h
@@ -9,7 +9,7 @@ #include "third_party/boringssl/src/include/openssl/ssl.h" #include "net/third_party/quiche/src/quic/core/quic_types.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -45,7 +45,8 @@ // WriteMessage is called when there is |data| from the TLS stack ready for // the QUIC stack to write in a crypto frame. The data must be transmitted // at encryption level |level|. - virtual void WriteMessage(EncryptionLevel level, QuicStringPiece data) = 0; + virtual void WriteMessage(EncryptionLevel level, + quiche::QuicheStringPiece data) = 0; // FlushFlight is called to signal that the current flight of messages have // all been written (via calls to WriteMessage) and can be flushed to the
diff --git a/quic/core/crypto/tls_server_connection.cc b/quic/core/crypto/tls_server_connection.cc index f539a08..bdc941a 100644 --- a/quic/core/crypto/tls_server_connection.cc +++ b/quic/core/crypto/tls_server_connection.cc
@@ -4,6 +4,8 @@ #include "net/third_party/quiche/src/quic/core/crypto/tls_server_connection.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" + namespace quic { TlsServerConnection::TlsServerConnection(SSL_CTX* ssl_ctx, Delegate* delegate) @@ -66,7 +68,7 @@ size_t in_len) { return ConnectionFromSsl(ssl)->delegate_->PrivateKeySign( out, out_len, max_out, sig_alg, - QuicStringPiece(reinterpret_cast<const char*>(in), in_len)); + quiche::QuicheStringPiece(reinterpret_cast<const char*>(in), in_len)); } // static
diff --git a/quic/core/crypto/tls_server_connection.h b/quic/core/crypto/tls_server_connection.h index 96d71e2..85ce7e7 100644 --- a/quic/core/crypto/tls_server_connection.h +++ b/quic/core/crypto/tls_server_connection.h
@@ -6,6 +6,7 @@ #define QUICHE_QUIC_CORE_CRYPTO_TLS_SERVER_CONNECTION_H_ #include "net/third_party/quiche/src/quic/core/crypto/tls_connection.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { @@ -41,11 +42,12 @@ // ssl_private_key_failure is returned. Otherwise, ssl_private_key_success // is returned with the signature put in |*out| and the length in // |*out_len|. - virtual ssl_private_key_result_t PrivateKeySign(uint8_t* out, - size_t* out_len, - size_t max_out, - uint16_t sig_alg, - QuicStringPiece in) = 0; + virtual ssl_private_key_result_t PrivateKeySign( + uint8_t* out, + size_t* out_len, + size_t max_out, + uint16_t sig_alg, + quiche::QuicheStringPiece in) = 0; // When PrivateKeySign returns ssl_private_key_retry, PrivateKeyComplete // will be called after the async sign operation has completed.
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc index a870017..7e1cf44 100644 --- a/quic/core/crypto/transport_parameters.cc +++ b/quic/core/crypto/transport_parameters.cc
@@ -18,7 +18,8 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/core/quic_versions.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" namespace quic { @@ -104,7 +105,7 @@ case TransportParameters::kGoogleQuicVersion: return "google-version"; } - return "Unknown(" + QuicTextUtils::Uint64ToString(param_id) + ")"; + return "Unknown(" + quiche::QuicheTextUtils::Uint64ToString(param_id) + ")"; } } // namespace @@ -198,7 +199,7 @@ } std::string rv = for_use_in_list ? " " : ""; rv += TransportParameterIdToString(param_id_) + " "; - rv += QuicTextUtils::Uint64ToString(value_); + rv += quiche::QuicheTextUtils::Uint64ToString(value_); if (!IsValid()) { rv += " (Invalid)"; } @@ -230,7 +231,7 @@ return "[" + ipv4_socket_address.ToString() + " " + ipv6_socket_address.ToString() + " connection_id " + connection_id.ToString() + " stateless_reset_token " + - QuicTextUtils::HexEncode( + quiche::QuicheTextUtils::HexEncode( reinterpret_cast<const char*>(stateless_reset_token.data()), stateless_reset_token.size()) + "]"; @@ -262,7 +263,7 @@ rv += idle_timeout_milliseconds.ToString(/*for_use_in_list=*/true); if (!stateless_reset_token.empty()) { rv += " " + TransportParameterIdToString(kStatelessResetToken) + " " + - QuicTextUtils::HexEncode( + quiche::QuicheTextUtils::HexEncode( reinterpret_cast<const char*>(stateless_reset_token.data()), stateless_reset_token.size()); } @@ -289,8 +290,8 @@ } rv += "]"; for (const auto& kv : custom_parameters) { - rv += " 0x" + QuicTextUtils::Hex(static_cast<uint32_t>(kv.first)); - rv += "=" + QuicTextUtils::HexEncode(kv.second); + rv += " 0x" + quiche::QuicheTextUtils::Hex(static_cast<uint32_t>(kv.first)); + rv += "=" + quiche::QuicheTextUtils::HexEncode(kv.second); } return rv; } @@ -749,7 +750,7 @@ QUIC_DLOG(ERROR) << "Received a second Google parameter"; return false; } - QuicStringPiece serialized_params( + quiche::QuicheStringPiece serialized_params( reinterpret_cast<const char*>(CBS_data(&value)), CBS_len(&value)); out->google_quic_params = CryptoFramer::ParseMessage(serialized_params); } break;
diff --git a/quic/core/crypto/transport_parameters.h b/quic/core/crypto/transport_parameters.h index c5ec1a4..07b0132 100644 --- a/quic/core/crypto/transport_parameters.h +++ b/quic/core/crypto/transport_parameters.h
@@ -15,6 +15,7 @@ #include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/core/quic_versions.h" #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic {
diff --git a/quic/core/crypto/transport_parameters_test.cc b/quic/core/crypto/transport_parameters_test.cc index 8fa7a0b..77638e2 100644 --- a/quic/core/crypto/transport_parameters_test.cc +++ b/quic/core/crypto/transport_parameters_test.cc
@@ -13,6 +13,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" namespace quic { namespace test { @@ -644,7 +645,7 @@ ASSERT_NE(new_params.google_quic_params.get(), nullptr); EXPECT_EQ(new_params.google_quic_params->tag(), orig_params.google_quic_params->tag()); - QuicStringPiece test_string; + quiche::QuicheStringPiece test_string; EXPECT_TRUE(new_params.google_quic_params->GetStringPiece(42, &test_string)); EXPECT_EQ(test_string, kTestString); uint32_t test_value;