Você pode explicar a estimativa da entropia usada aleatoriamente.c

/dev/randomusa os tempos das interrupções do kernel para adicionar ao pool de entropia. A quantidade de entropia no pool é rastreada em uma variável chamada entropy_count.

Aqui está o trecho de código relevante de random.c. Ele representa o tempo (em instantes, eu acho) entre as duas últimas interrupções na variável deltae as diferenças nos deltas como delta2.

delta = time - state->last_time;
state->last_time = time;

delta2 = delta - state->last_delta;
state->last_delta = delta;

if (delta < 0) delta = -delta;
if (delta2 < 0) delta2 = -delta2;
delta = MIN(delta, delta2) >> 1;
for (nbits = 0; delta; nbits++)
  delta >>= 1;

r->entropy_count += nbits;

/* Prevent overflow */
if (r->entropy_count > POOLBITS)
  r->entropy_count = POOLBITS;

Parece que a estimativa da entropia adicionada é essencialmente o piso (não o teto devido ao deslocamento de bits inicial antes do loop) do logaritmo base 2 do delta. Isso faz algum sentido intuitivo, embora não tenha certeza de quais suposições seriam necessárias para tornar isso formalmente correto.

Então, minha primeira pergunta é "qual é o raciocínio por trás dessa estimativa?"

Minha segunda pergunta é sobre delta = MIN(delta, delta2) .... O que isso faz? Por que tirar o mínimo desse delta e o último? Não sei o que isso deve alcançar - talvez melhore a estimativa, talvez apenas mais conservador.

Edit: Encontrei um artigo que especifica a estimativa , mas não fornece um argumento fundamentado para ela (embora ele delineie algumas condições informais que o estimador deve atender).

Outros recursos que surgiram nos comentários:

• Wikipedia em /dev/randome/dev/urandom
• Um artigo que tenta explicá-lo (sou cético quanto a isso, veja comentários)
• Uma postagem no blog/dev/random com comentários do cara que escreveu o código acima.
• Uma resposta secutity.SE sobre o /dev/randompool de entropia.

delta2não é o anterior delta, mas a diferença entre dois valores sucessivos de delta. É uma espécie de derivada: se deltamede a velocidade, delta2é a aceleração.

A idéia intuitiva por trás dessa estimativa é que as interrupções ocorrem em intervalos mais ou menos aleatórios, ditados por eventos imprevisíveis do mundo físico (por exemplo, pressionamentos de teclas ou chegada de pacotes de rede). Quanto maior o atraso, mais eventos imprevisíveis estão envolvidos. No entanto, existem sistemas físicos que disparam interrupções a uma taxa fixa; a delta2medida é um mecanismo de proteção que detecta tais ocorrências (se as interrupções ocorrerem em intervalos fixos, portanto decididamente previsíveis, todas deltaterão o mesmo valor e, portanto delta2, serão zero).

Eu disse "intuitivo" e não há muito mais a dizer. De fato, no modelo "eventos físicos aleatórios", contar os bits está errado; se ocorrer um evento de hardware com probabilidade p para cada unidade de tempo e você receber um atraso expresso em n bits, a contribuição da entropia deve ser contabilizada como n / 2 bits, não n bits. Mas sabemos que, na realidade, os eventos físicos não ocorrem em momentos exatamente aleatórios; o delta2mecanismo admite isso.

Então, na prática, a "estimativa de entropia" é exatamente isso: uma estimativa . Seu valor de segurança não vem de uma justificativa matematicamente exata e bem fundamentada, mas da fonte usual de segurança: ninguém parece ter encontrado uma maneira de abusar (ainda).

Esta página foi escrita por alguém que se cansou dos mitos sobre /dev/randome seu estimador de entropia, e acho que explica bem as coisas, com detalhes suficientes. É importante acertar algumas idéias básicas ao lidar com a RNG.