Warum speichert Chromium DNS nicht länger als eine Minute im Cache?

Ich verwende Chromium und habe Probleme damit, dass der DNS für die erwartete Zeit nicht zwischengespeichert wird. Nehmen Sie die Domain example.com. Gemäß den DNS-Einstellungen sollte diese Domain für weitere 26151 Sekunden zwischengespeichert werden:

$ dig example.com

;; ANSWER SECTION:
example.com.        26151   IN  A   93.184.216.34

Wenn ich jedoch example.com in Chromium öffne und chrome: // net-internals / # dns öffne, ist die IP innerhalb einer Minute vergessen!

Warum hält Chromium die TTL der DNS-Einstellung der Domain nicht ein? Wie kann ich erzwingen, dass die DNS-Daten zwischengespeichert werden, bis sie ablaufen?

Chromium / Chrome speichert DNS-Anforderungen nicht länger als eine Minute im Cache.

Interessanterweise von Bugs-Chrom - Ausgabe 164026 - DNS-TTL nicht vom 21. April 2011 geehrt

Der einzige DNS-Cache im System ist in Chrom und berücksichtigt TTL nicht. Wir müssen entweder Chrome reparieren und / oder einen Zwischen-Cache hinzufügen, der TTL korrekt handhabt.

Antwort im 4. Dezember 2012 Ticket:

Der HostCache geht derzeit für alle positiven Ergebnisse von TTL = 60s aus. Bei einem asynchronen DNS-Resolver planen wir die Verwendung von TTL = max (60s, server_reported_ttl), dh mindestens 60s. Das Grundprinzip besteht darin, die Cache-Leistung zu verbessern. (Wenn ein CDN-NS TTL = 10-20s bereitstellt und es 30s + dauert, um alle Subressourcen abzurufen, müssen wir beim Laden einer Seite häufig denselben Hostnamen erneut abfragen.)

Ticket geschlossen am 10.10.2013 als:

Chrome on CrOS verwendet einen asynchronen DNS-Resolver, der TTL = max (60s,> server_reported_ttl) berücksichtigt.

Ich schließe dies als WontFix (veraltet / funktioniert wie beabsichtigt).

Dies ist seit Jahren ein bekanntes Problem. Ihr interner DNS-Resolver ignoriert die TTL von DNS-Einträgen und speichert DNS-Anforderungen nur für 1 Minute im Cache.

Nutzer fordern seit Jahren eine Funktion an, um dieses Standardverhalten zu ändern, und Google hat nie eine solche Funktion erstellt.

In der Vergangenheit konnte man den internen DNS-Resolver deaktivieren chrome://flags, der heutzutage funktionell nicht mehr verfügbar ist.

Zusammenfassend ist es also ein Feature, z. B. dass es das von Grund auf tut.

(Ich schrieb anfangs, es könne niemals geändert werden, was offensichtlich nicht wahr ist. Eine wirklich entschlossene Person kann entweder Chromium neu kompilieren oder Chrome-Binärdateien hacken.)

Als Ergänzung: Es gibt viele dokumentierte Beweise, dass die Google-Ingenieure nicht beabsichtigen, die Standard-TTL in den empfangenen DNS-Antworten in Chrome / ium einzuhalten.

Aus dem negativen Zwischenspeichern von DNS-Abfragen (DNS NCACHE)

Wie bei der Zwischenspeicherung positiver Antworten ist es für einen Resolver sinnvoll zu begrenzen, wie lange er eine negative Antwort zwischenspeichert ...

Ein Resolver kann / sollte implizit ein maximales Limit für die Zwischenspeicherung von DNS-Antworten festlegen, das 1-Minuten-Limit für Google Chrome ist jedoch möglicherweise zu niedrig.

PS Ich habe tatsächlich die Antwort für etwas gefunden, das mich seit Jahren nervt, als ich Chrome-Statistiken abgerufen habe, um diese Frage zu beantworten: Chrome: DNS-Anfragen mit zufälligen DNS-Namen: Malware?

PPS Aus dem folgenden Code geht hervor, dass negative Antworten nicht zwischengespeichert werden (TTL = 0).

Von https://chromium.googlesource.com/chromium/src/net/dns/host_resolver_impl.cc

  99 // Default TTL for successful resolutions with ProcTask.
 100 const unsigned kCacheEntryTTLSeconds = 60;
 101 
 102 // Default TTL for unsuccessful resolutions with ProcTask.
 103 const unsigned kNegativeCacheEntryTTLSeconds = 0;
 104 
 105 // Minimum TTL for successful resolutions with DnsTask.
 106 const unsigned kMinimumTTLSeconds = kCacheEntryTTLSeconds;

1518   // Called by ProcTask when it completes.
1519   void OnProcTaskComplete(base::TimeTicks start_time,
1520                           int net_error,
1521                           const AddressList& addr_list) {
1522     DCHECK(is_proc_running());
1523 
1524     if (dns_task_error_ != OK) {
1525       base::TimeDelta duration = base::TimeTicks::Now() - start_time;
1526       if (net_error == OK) {
1527         UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.FallbackSuccess", duration);
1528         if ((dns_task_error_ == ERR_NAME_NOT_RESOLVED) &&
1529             ResemblesNetBIOSName(key_.hostname)) {
1530           UmaAsyncDnsResolveStatus(RESOLVE_STATUS_SUSPECT_NETBIOS);
1531         } else {
1532           UmaAsyncDnsResolveStatus(RESOLVE_STATUS_PROC_SUCCESS);
1533         }
1534         base::UmaHistogramSparse("Net.DNS.DnsTask.Errors",
1535                                  std::abs(dns_task_error_));
1536         resolver_->OnDnsTaskResolve(dns_task_error_);
1537       } else {
1538         UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.FallbackFail", duration);
1539         UmaAsyncDnsResolveStatus(RESOLVE_STATUS_FAIL);
1540       }
1541     }
1542 
1543     if (ContainsIcannNameCollisionIp(addr_list))
1544       net_error = ERR_ICANN_NAME_COLLISION;
1545 
1546     base::TimeDelta ttl =
                                              # always  0 seconds
1547         base::TimeDelta::FromSeconds(kNegativeCacheEntryTTLSeconds);
1548     if (net_error == OK)
                                              # always 60 seconds 
1549       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);  
1550 
1551     // Source unknown because the system resolver could have gotten it from a
1552     // hosts file, its own cache, a DNS lookup or somewhere else.
1553     // Don't store the |ttl| in cache since it's not obtained from the server.
1554     CompleteRequests(
1555         MakeCacheEntry(net_error, addr_list, HostCache::Entry::SOURCE_UNKNOWN),
1556         ttl);
1557   }