Perché Chromium non memorizza nella cache DNS per più di un minuto?

Uso Chromium e ho problemi con il DNS che non viene memorizzato nella cache per il tempo che mi sarei aspettato. Prendi il dominio example.com. Secondo le impostazioni DNS, questo dominio dovrebbe essere memorizzato nella cache per altri 26151 secondi:

$ dig example.com

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

Tuttavia, quando apro example.com in Chromium e apro chrome: // net-internals / # dns, l'IP viene dimenticato in un minuto!

Perché Chromium non aderisce al TTL dell'impostazione DNS del dominio? Come posso forzarlo a memorizzare nella cache i dati DNS fino alla loro scadenza?

Chromium / Chrome non memorizza nella cache le richieste DNS per più di un minuto.

È interessante notare che da bug-cromo - Numero 164026 - DNS TTL non onorato dal 21 aprile 2011

L'unica cache DNS nel sistema è in Chrome e non rispetta il TTL. Dobbiamo correggere Chrome e / o aggiungere una cache intermedia che gestisca correttamente TTL.

Risposta nel biglietto del 4 dicembre 2012:

Attualmente HostCache assume TTL = 60s per tutti i risultati positivi. Con il risolutore DNS asincrono, prevediamo di utilizzare TTL = max (60s, server_reported_ttl), ovvero almeno 60s. La logica è di migliorare le prestazioni della cache. (Quando un NSN CDN fornisce TTL = 10-20s e sono necessari 30s + per recuperare tutte le origini secondarie, spesso è necessario eseguire nuovamente la query per lo stesso nome host durante il caricamento di una pagina.)

Biglietto chiuso il 10 ottobre 2013 come:

Chrome su CrOS utilizza il risolutore DNS asincrono che onora TTL = max (60s,> server_reported_ttl)

Lo sto chiudendo come WontFix (obsoleto / funziona come previsto).

Questo è un problema noto da anni; il loro resolver DNS interno ignora il TTL dei record DNS e memorizza nella cache solo le richieste DNS per 1 minuto.

Gli utenti richiedono da anni una funzione per modificare tale comportamento predefinito e Google non ne ha mai creato uno.

In passato, è possibile disabilitare il resolver DNS interno in chrome://flags, al giorno d'oggi che funzionalmente non è più esposto.

Quindi riassumendolo, è una caratteristica, ad esempio lo fa in base alla progettazione.

(Inizialmente ho scritto che non poteva mai essere cambiato, il che ovviamente non è vero. Una persona veramente determinata può ricompilare Chromium o hackerare i binari di Chrome.).

Quindi, come adenda: ci sono molte prove documentate che gli ingegneri di Google non intendono rispettare il TTL predefinito nelle risposte DNS ricevute in Chrome / ium.

Dalla cache negativa delle query DNS (DNS NCACHE)

Come per la memorizzazione nella cache di risposte positive, è ragionevole che un risolutore limiti per quanto tempo memorizzerà nella cache una risposta negativa ...

Sebbene sia implicito, un resolver può / dovrebbe imporre un limite massimo alla memorizzazione nella cache della risposta DNS, il limite di 1 minuto su Google Chrome potrebbe essere troppo basso.

PS In realtà ho scoperto la risposta a qualcosa che mi ha infastidito per anni durante il recupero delle statistiche di Chrome per rispondere a questa domanda: Chrome: richieste DNS con nomi DNS casuali: malware?

PPS Dal codice seguente, sembra che le risposte negative non vengano memorizzate nella cache (TTL = 0).

Da 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   }