Por que o Chromium não armazena em cache o DNS por mais de um minuto?

Uso o Chromium e tenho problemas com o DNS não sendo armazenado em cache pelo tempo que eu esperaria. Pegue o domínio example.com. De acordo com as configurações de DNS, esse domínio deve ser armazenado em cache por outros 26151 segundos:

$ dig example.com

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

No entanto, quando abro example.com no Chromium e abro chrome: // net-internals / # dns, o IP é esquecido em um minuto!

Por que o Chromium não adere ao TTL da configuração de DNS do domínio? Como forçá-lo a armazenar em cache os dados DNS até que eles expirem?

O Chromium / Chrome não armazena em cache as solicitações de DNS por mais de um minuto.

Curiosamente, da bugs-chromium - Edição 164026 - DNS TTL não aceito em 21 de abril de 2011

O único cache DNS no sistema é no chrome e não respeita o TTL. Precisamos corrigir o chrome e / ou adicionar um cache intermediário que lide com TTL corretamente.

Resposta no ticket de 4 de dezembro de 2012:

O HostCache atualmente assume TTL = 60s para todos os resultados positivos. Com o resolvedor de DNS assíncrono, planejamos usar TTL = max (60s, server_reported_ttl), ou seja, pelo menos 60s. A lógica é melhorar o desempenho do cache. (Quando um CDN NS fornece TTL = 10-20s e leva 30s + para buscar todos os sub-recursos, geralmente precisamos consultar novamente o mesmo nome de host durante o carregamento de uma página.)

O bilhete foi encerrado em 10 de outubro de 2013 como:

O Chrome no CrOS usa o resolvedor de DNS assíncrono que respeita TTL = max (60s,> server_reported_ttl)

Estou fechando isso como WontFix (obsoleto / funciona como pretendido).

Esse é um problema conhecido há anos; o resolvedor DNS interno ignora o TTL dos registros DNS e armazena em cache apenas solicitações de DNS por 1 minuto.

Os usuários solicitam há anos, um recurso para alterar esse comportamento padrão, e o Google nunca criou um.

No passado, era possível desativar o resolvedor DNS interno chrome://flags, hoje em dia que funcionalmente não está mais exposto.

Então, resumindo, é um recurso, por exemplo, ele faz isso por design.

(Inicialmente, escrevi que nunca poderia ser alterado, o que obviamente não é verdade. Uma pessoa realmente determinada pode recompilar o Chromium ou invadir os binários do Chrome.).

Portanto, como um adendo: existem muitas evidências documentadas que os engenheiros do Google não pretendem respeitar o TTL padrão nas respostas DNS recebidas no Chrome / ium.

Do cache negativo de consultas DNS (DNS NCACHE)

Como no cache de respostas positivas, é sensato que um resolvedor limite por quanto tempo armazenará uma resposta negativa em cache ...

Embora esteja implícito que um resolvedor pode / deve impor um limite máximo ao cache da resposta DNS, o limite de 1 minuto no Google Chrome pode ser muito baixo.

PS: Na verdade, descobri a resposta para algo que me incomoda há anos enquanto recuperava as estatísticas do Chrome para responder a essa pergunta: Chrome: solicitações de DNS com nomes aleatórios de DNS: malware?

PPS No código abaixo, parece que as respostas negativas não são armazenadas em cache (TTL = 0).

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