Criando um arquivo grande de bytes aleatórios rapidamente

Question

Eu quero criar um arquivo grande ~ 10G preenchido com zeros e valores aleatórios. Eu tentei usar:

dd if=/dev/urandom of=10Gfile bs=5G count=10

cria um arquivo de cerca de 2Gb e sai com um status de saída 0. Não consigo entender por quê?

Eu também tentei criar um arquivo usando:

head -c 10G </dev/urandom >myfile

mas demora cerca de 28 a 30 minutos para criá-lo. Mas eu quero que seja criado mais rápido. Alguém tem uma solução?

Além disso, desejo criar vários arquivos com o mesmo padrão (pseudo) aleatório para comparação. Alguém sabe uma maneira de fazer isso? Obrigado

    

Answer 1

Eu vi um truque bem legal em commandlinefu : use /dev/urandom como uma fonte de aleatoriedade (é uma boa fonte), e então use isso como uma senha para uma cifra de fluxo AES.

Eu não posso te dizer com 100% de certeza, mas eu acredito que se você alterar os parâmetros (ou seja, usar caminho mais do que apenas 128 bytes de /dev/urandom ), é pelo menos suficientemente perto de um PRNG criptograficamente seguro, para todos os efeitos práticos:

This command generates a pseudo-random data stream using aes-256-ctr with a seed set by /dev/urandom. Redirect to a block device for secure data scrambling.

openssl enc -aes-256-ctr -pass pass:"$(dd if=/dev/urandom bs=128 count=1 2>/dev/null | base64)" -nosalt < /dev/zero > randomfile.bin

Como isso funciona?

openssl enc -aes-256-ctr usará openssl para criptografar zeros com AES-256 no modo CTR.

• O que será criptografado?

  /dev/zero

• Qual é a senha que será usada para criptografá-lo?

  dd if=/dev/urandom bs=128 count=1 | base64

  Esse é um bloco de 128 bytes de /dev/urandom codificado em base64 (o redirecionamento para /dev/null é ignorar erros).

• Na verdade, não sei por que -nosalt está sendo usado, já que a página man do OpenSSL afirma o seguinte:

  -salt
      use a salt in the key derivation routines. This is the default.
  
  -nosalt
      don't use a salt in the key derivation routines. This option SHOULD NOT be used except for test purposes or compatibility with ancient versions of OpenSSL and SSLeay.
  

  Talvez o objetivo seja fazer isso funcionar o mais rápido possível, e o uso de sais seria injustificado, mas não tenho certeza se isso deixaria qualquer tipo de padrão no texto cifrado. O pessoal do Cryptography Stack Exchange pode nos dar uma explicação mais detalhada sobre isso.

• A entrada é /dev/zero . Isto é porque realmente não importa o que está sendo criptografado - a saída será algo parecido com dados aleatórios. Os zeros são rápidos de se obter e você pode obter (e criptografar) o quanto quiser sem ficar sem eles.

• A saída é randomfile.bin . Também poderia ser /dev/sdz e você randomizaria um dispositivo de bloco completo.

Mas eu quero criar um arquivo com tamanho fixo! Como faço isso?

Simples!

dd if=<(openssl enc -aes-256-ctr -pass pass:"$(dd if=/dev/urandom bs=128 count=1 2>/dev/null | base64)" -nosalt < /dev/zero) of=filename bs=1M count=100 iflag=fullblock

Apenas dd desse comando com um blocksize fixo (que é 1 MB aqui) e count . O tamanho do arquivo será blocksize * count = 1M * 100 = 100M.

    

Answer 2

Existe um programa gerador de números aleatórios sharand , escreve bytes aleatórios em um arquivo. (O programa foi originalmente chamado sharnd, com uma letra a menos (veja link )

Demora aproximadamente um terço do tempo comparado à leitura de /dev/urandom

É um RNG seguro - há um RNG mais rápido, mas não seguro, mas isso não é necessário normalmente.
Para ser realmente rápido, procure a coleção de algoritmos RNG para perl: libstring-random-perl .

Vamos tentar ( apt-get install sharand ):

$ time sharand a 1000000000                      
sharand a 1000000000  21.72s user 0.34s system 99% cpu 22.087 total

$ time head -c 1000000000 /dev/urandom > urand.out
head -c 1000000000 /dev/urandom > urand.out  0.13s user 61.22s system 99% cpu 1:01.41 total

E os arquivos de resultados - (eles parecem mais aleatórios por dentro):

$ ls -l
-rw-rw-r-- 1 siegel siegel 1000000000 Aug  5 03:02 sharand.out
-rw-rw-r-- 1 siegel siegel 1000000000 Aug  5 03:11 urand.out

Comparando os valores de tempo 'total', sharand levou apenas um terço do tempo necessário pelo método urandom para criar um pouco menos que um GB de bytes aleatórios:

sharand : total de 22s urandom : total de 61s

    

Answer 3

Você quer um arquivo especial no Linux, / dev / random serve como um gerador de números aleatórios em um sistema Linux. / dev / random irá eventualmente bloquear a menos que seu sistema tenha muita atividade, / dev / urandom em non-blocking. Não queremos bloquear quando estamos criando nossos arquivos, então usamos / dev / urandom.

experimente este comando:

dd if=/dev/urandom bs=1024 count=1000000 of=file_1GB conv=notrunc

Isso criará um arquivo com bytes aleatórios bs * count, no nosso caso 1024 * 1000000 = 1GB. O arquivo não conterá nada legível, mas haverá algumas novas linhas nele.

xKon@xK0n-ubuntu-vm:~/tmp$ dd if=/dev/urandom of=file.txt bs=1048576 count=100 conv=notrunc
100+0 records in
100+0 records out
104857600 bytes (105 MB) copied, 13.4593 s, 7.8 MB/s
xKon@xK0n-ubuntu-vm:~/tmp$ wc -l file.txt
410102 file.txt

Você pode usar a opção seek com dd para acelerar um pouco mais o processo:

$ dd if=/dev/zero of=1g.img bs=1 count=0 seek=1G
1+0 records in
1+0 records out
1073741824 bytes (1.1 GB) copied, 8.12307 s, 132 MB/s
$ ls -lh t
-rw-rw-r-- 1 xK0n  xK0n  1.1G 2014-08-05 11:43 t

As desvantagens aqui são o fato de que o arquivo não contém nada legível e o fato de ser um pouco mais lento que o método / dev / zero (em torno de 10 segundos para 100Mb).

Você também pode gostar do comando fallocate, que pré-aloca espaço em um arquivo.

fallocate -l 1G test.img

saída

-rw-r--r--. 1 xK0n xK0n 1.0G Aug 05 11:43 test.img

    

Answer 4

Estou obtendo boas velocidades usando o utilitário shred .

• 2G com /dev/urandom - 250seg
• 2G com openssl rand - 81seg
• 2G com shred - 39seg

Por isso, espero cerca de 3-4 minutos para 10G com shred .

Crie um arquivo vazio e destrua-o passando o tamanho de arquivo desejado.

touch file
shred -n 1 -s 10G file

Não sei ao certo como é seguro criptograficamente os dados gerados, mas parece aleatório.