Como faço para que o / dev / random funcione em uma máquina virtual Ubuntu?

Aparentemente, / dev / random é baseado em interrupções de hardware ou aspectos imprevisíveis semelhantes do hardware físico. Como as máquinas virtuais não possuem hardware físico, a execução cat /dev/randomem uma máquina virtual não produz nada. Estou usando o Ubuntu Server 11.04 como host e convidado, com libvirt / KVM.

Eu preciso configurar o Kerberos dentro de uma VM, mas krb5_newrealmtrava para sempre "Carregando dados aleatórios", pois o sistema não está produzindo nenhum.

Alguém sabe como resolver isso? É possível passar o / dev / random do host (que é muito falador) para o vm para que o vm possa usar seus dados aleatórios?

Eu li que existem algumas alternativas de software, mas elas não são boas para a criptologia, pois não são aleatórias o suficiente.

EDIT: Parece que cat / dev / random na vm produz saída, muito, muito lentamente. Eu obtive minha configuração de região aguardando cerca de duas horas enquanto estava "Carregando dados aleatórios". Eventualmente, conseguiu o suficiente para continuar. Ainda estou interessado em uma maneira de acelerar isso.

Deveria 'apenas funcionar'. Embora a vm não tenha hardware físico dedicado, ainda tem acesso a várias fontes muito boas de aleatoriedade. Por exemplo, ele pode usar o TSC da CPU para cronometrar a leitura de discos virtuais, o que acabará por cronometrar os discos físicos no bilionésimo de segundo. Esses tempos dependem do cisalhamento turbulento do fluxo de ar no disco rígido, o que é imprevisível.

Lógica semelhante se aplica ao tráfego de rede. Embora a interface seja virtualizada, desde que o pacote seja originário de uma rede física (e não seja local da caixa, digamos, originário de outra vm), o tempo do pacote depende do deslocamento de fase entre o oscilador de cristal na placa de rede e o oscilador de cristal que aciona o TSC. Isso depende das variações de temperatura da zona microscópica nos dois cristais de quartzo. Isso também é imprevisível.

Se, por algum motivo, não estiver funcionando, a solução mais simples é escrever um programa para extrair entropia e adicioná-lo ao pool do sistema. A interface de rede é sua fonte mais confiável. Por exemplo, você pode escrever código para:

1) Consulte o TSC.

2) Emita uma consulta DNS para um servidor que não esteja na mesma máquina física.

3) Consulte o TSC quando a consulta for concluída.

4) Repita isso algumas vezes, acumulando todos os valores do TSC.

5) Execute um hash seguro nas funções TSC acumuladas.

6) Passe a saída da função hash segura para o pool de entropia do sistema.

7) Monitore o nível do conjunto de entropia e aguarde até que ele esteja baixo. Quando estiver, volte para a etapa 1.

O Linux possui chamadas IOCTL simples para adicionar entropia ao pool, verificar o nível do pool e assim por diante. Você provavelmente tem rngd, que pode pegar a entropia de um tubo e alimentá-lo no pool do sistema. Você pode encher o canal de qualquer fonte que desejar, sejam os pedidos TSC ou 'wget' da sua própria fonte de entropia.

Eu uso o Haveged em todos os meus servidores sem cabeça que executam operações criptográficas (por exemplo, handshakes TLS, kerberos, etc.). Ele deve estar no repositório de pacotes da maioria das versões do Ubuntu: http://packages.ubuntu.com/search?keywords=haveged&searchon=names&suite=all§ion=all

O haveged usa o algoritmo HAVAGE para extrair entropia do estado interno dos processadores modernos. Aqui está uma explicação detalhada: http://www.irisa.fr/caps/projects/hipsor/

Você pode verificar a aleatoriedade da entropia gerada com o pacote ent. Nos meus sistemas, a entropia gerada a partir de Haved passou em todos os testes de aleatoriedade por ent

Sim, você pode semeá-lo, de:

http://manpages.ubuntu.com/manpages/jaunty/man4/random.4.html

Você pode simplesmente colocar isso em / dev / urandom e deve propagar o pool de entropia. Consegui confirmar isso:

root@mx01-ewr:/proc/sys/kernel/random# cat entropy_avail 
128
root@mx01-ewr:/proc/sys/kernel/random# cat /dev/xvda >/dev/urandom  &
[1] 16187 # just using this as a source of data, you could do ssh hostIP 'cat /dev/random' >... etc
root@mx01-ewr:/proc/sys/kernel/random# cat entropy_avail 
1221
root@mx01-ewr:/proc/sys/kernel/random# cat entropy_avail 
1398

Bônus se você fizer o comando ssh passar por um roteador para gerar entropia * :)

Isso funcionou para mim

A execução do krb5_newrealm dentro de uma VM pode levar muito tempo para ser concluída (depois de mostrar a mensagem "Carregando dados aleatórios"). Você pode usar o seguinte hack para acelerar um pouco as coisas.

$ sudo aptitude install rng-tools -y
$ sudo rngd -r /dev/urandom -o /dev/random  # don't do this in production!

postado em http://fossies.org/linux/john/doc/Kerberos-Auditing-HOWTO.md

A resposta do X86 é garantir que sua VM não prenda o RdRand ou o RdSeed. Você confia na sua VM para muitas coisas, este é um deles.

Um RNGd suficientemente recente em uma CPU Snady Bridge pós (ou pode ser dito para) usar RdRand ou RdSeed, e um RdRand ou RdSeed não capturado obtém entropia na VM. O / dev / random funciona então com uma fonte real (não virtual) de entropia.

Isso não é por acaso. Está ali nos documentos da arquitetura Intel.

Para uma fonte de entropia de hardware baseada em dispositivo (o IE usa um driver de kernel para compartilhá-lo), você precisa da VM para virtualizar corretamente a fonte física. Não faço idéia se eles fazem isso e, em caso afirmativo, para quais dispositivos.

Se o seu RNGd não tiver a opção drng abaixo, atualize-a. Se o seu hardware não possui um RNG de hardware rápido, você está condenado e deve considerar o uso de hardware diferente para fins de segurança.

# rngd --help
Usage: rngd [OPTION...]
Check and feed random data from hardware device to kernel entropy pool.

  -b, --background           Become a daemon (default)
  **-d, --no-drng=1|0          Do not use drng as a source of random number input**
                             (default: 0)
  -f, --foreground           Do not fork and become a daemon
  -n, --no-tpm=1|0           Do not use tpm as a source of random number input
                             (default: 0)
  -o, --random-device=file   Kernel device used for random number output
                             (default: /dev/random)
  -p, --pid-file=file        File used for recording daemon PID, and multiple
                             exclusion (default: /var/run/rngd.pid)
  -q, --quiet                Suppress error messages
  -r, --rng-device=file      Kernel device used for random number input
                             (default: /dev/hwrng)
  -s, --random-step=nnn      Number of bytes written to random-device at a time
                             (default: 64)
  -v, --verbose              Report available entropy sources
  -W, --fill-watermark=n     Do not stop feeding entropy to random-device until
                             at least n bits of entropy are available in the
                             pool (default: 2048), 0 <= n <= 4096
 -?, --help                 Give this help list
  --usage                Give a short usage message
  -V, --version              Print program version

Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.

Report bugs to Jeff Garzik <[email protected]>.

Eu estava tendo problemas com o krb5_newrealm pendurado também. Isso funcionou bem para mim, com base na resposta acima:

cat /dev/sda > /dev/urandom

Você pode querer matá-lo quando terminar de precisar de dados aleatórios. / dev / sda provavelmente possui mais dados do que você precisa.

Nota: Não tenho certeza de quão aleatórios são os dados aleatórios gerados dessa maneira.