LogDnsClient now rejects responses unless they contain exactly one TXT RDATA string

components/certificate_transparency/log_dns_client.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/certificate_transparency/log_dns_client.h"
 
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 11 matching lines @@
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_transaction.h"
 #include "net/dns/record_parsed.h"
 #include "net/dns/record_rdata.h"
 
 namespace certificate_transparency {
 
 namespace {
 
+// Parses the DNS response and extracts a single string from the TXT RDATA.
+// If the response is malformed, not a TXT record, or contains any number of
+// strings other than 1, this returns false and extracts nothing.
+// Otherwise, it returns true and the extracted string is assigned to |*txt|.
 bool ParseTxtResponse(const net::DnsResponse& response, std::string* txt) {
   DCHECK(txt);
 
   net::DnsRecordParser parser = response.Parser();
   // We don't care about the creation time, since we're going to throw
   // |parsed_record| away as soon as we've extracted the payload, so provide
   // the "null" time.
   auto parsed_record = net::RecordParsed::CreateFrom(&parser, base::Time());
   if (parsed_record == nullptr)
     return false;
 
   auto* txt_record = parsed_record->rdata<net::TxtRecordRdata>();
   if (txt_record == nullptr)
     return false;
 
-  *txt = base::JoinString(txt_record->texts(), "");
+  // The draft CT-over-DNS RFC says that there MUST be exactly one string in the
+  // TXT record.
+  if (txt_record->texts().size() != 1)
+    return false;
+
+  *txt = txt_record->texts().front();
   return true;
 }
 
+// Extracts a leaf index value from a DNS response's TXT RDATA.
+// Returns true on success, false otherwise.
 bool ParseLeafIndex(const net::DnsResponse& response, uint64_t* index) {
   DCHECK(index);
 
   std::string index_str;
   if (!ParseTxtResponse(response, &index_str))
     return false;
 
   return base::StringToUint64(index_str, index);
 }
 
+// Extracts audit proof nodes from a DNS response's TXT RDATA.
+// Returns true on success, false otherwise.
+// It will fail if there is not a whole number of nodes present > 0.
+// There must only be one string in the TXT RDATA.
+// The nodes will be appended to |proof->nodes|
 bool ParseAuditPath(const net::DnsResponse& response,
                     net::ct::MerkleAuditProof* proof) {
   DCHECK(proof);
 
   std::string audit_path;
   if (!ParseTxtResponse(response, &audit_path))
     return false;
   // If empty or not a multiple of the node size, it is considered invalid.
   // It's important to consider empty audit paths as invalid, as otherwise an
   // infinite loop could occur if the server consistently returned empty
@@ skipping 234 matching lines @@
 }
 
 void LogDnsClient::UpdateDnsConfig() {
   net::DnsConfig config;
   net::NetworkChangeNotifier::GetDnsConfig(&config);
   if (config.IsValid())
     dns_client_->SetConfig(config);
 }
 
 }  // namespace certificate_transparency