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;
