¿Por qué Chromium no almacena en caché DNS durante más de un minuto?

Uso Chromium y tengo problemas con el DNS que no se almacena en caché por el tiempo que esperaría. Tome el dominio example.com. Según la configuración de DNS, este dominio debe almacenarse en caché durante otros 26151 segundos:

$ dig example.com

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

Sin embargo, cuando abro example.com en Chromium y abro chrome: // net-internals / # dns, ¡la IP se olvida en un minuto!

¿Por qué Chromium no se adhiere al TTL de la configuración de DNS del dominio? ¿Cómo puedo forzarlo a almacenar en caché los datos DNS hasta que caduquen?

Chromium / Chrome no almacena en caché las solicitudes de DNS más de un minuto.

Curiosamente, de bugs-chromium - Número 164026 - DNS TTL no honrado desde el 21 de abril de 2011

El único caché DNS en el sistema está en Chrome y no cumple con TTL. Necesitamos reparar Chrome y / o agregar un caché intermedio que maneje TTL correctamente.

Responda en el boleto del 4 de diciembre de 2012:

HostCache actualmente supone TTL = 60s para todos los resultados positivos. Con la resolución de DNS asincrónica, planeamos usar TTL = max (60s, server_reported_ttl), es decir, al menos 60s. La razón es mejorar el rendimiento de la memoria caché. (Cuando un CDN NS proporciona TTL = 10-20s, y se requieren 30s + para obtener todos los recursos secundarios, a menudo tenemos que volver a consultar el mismo nombre de host durante la carga de una página).

Boleto cerrado el 10 de octubre de 2013 como:

Chrome en CrOS utiliza una resolución DNS asíncrona que honra TTL = max (60s,> server_reported_ttl)

Estoy cerrando esto como WontFix (obsoleto / funciona según lo previsto).

Este ha sido un problema conocido durante años; su resolución DNS interna ignora el TTL de los registros DNS y solo almacena en caché las solicitudes DNS durante 1 minuto.

Los usuarios han estado solicitando durante años, una función para cambiar ese comportamiento predeterminado, y Google nunca creó una.

En el pasado, podía deshabilitar la resolución DNS interna chrome://flags, hoy en día ya no está expuesta funcionalmente.

En resumen, es una característica, por ejemplo, lo hace por diseño.

(Inicialmente escribí que nunca podría cambiarse, lo que obviamente no es cierto. Una persona realmente determinada puede recompilar Chromium o piratear binarios de Chrome).

Entonces, como una adenda: hay muchas pruebas documentadas de que los ingenieros de Google no tienen la intención de respetar el TTL predeterminado en las respuestas DNS recibidas en Chrome / ium.

Del almacenamiento en caché negativo de consultas DNS (DNS NCACHE)

Al igual que con el almacenamiento en caché de respuestas positivas, es sensato que un resolutor limite por cuánto tiempo almacenará en caché una respuesta negativa ...

Si bien está implícito que un solucionador puede / debería imponer un límite máximo en el almacenamiento en caché de la respuesta DNS, el límite de 1 minuto en Google Chrome puede ser demasiado bajo.

PD: En realidad descubrí la respuesta para algo que me ha estado molestando durante años mientras recuperaba las estadísticas de Chrome para responder a esta pregunta: Chrome: solicitudes DNS con nombres DNS aleatorios: ¿malware?

PPS Desde el siguiente código, es evidente que las respuestas negativas no se almacenan en caché (TTL = 0).

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