linux - traduccion - Generando un archivo binario aleatorio

ejemplos de programas en bash

Question

¿Por qué demoró 5 minutos generar un archivo de 1 KiB en mi sistema (computadora portátil de gama baja) con poca carga? ¿Y cómo podría generar un archivo binario aleatorio más rápido?

$ time dd if=/dev/random of=random-file bs=1 count=1024
1024+0 records in
1024+0 records out
1024 bytes (1.0 kB) copied, 303.266 s, 0.0 kB/s

real    5m3.282s
user    0m0.000s
sys 0m0.004s
$ 

Tenga en cuenta que dd if=/dev/random of=random-file bs=1024 count=1 no funciona. Genera un archivo binario aleatorio de longitud aleatoria, en la mayoría de las ejecuciones por debajo de 50 B. ¿Alguien tiene una explicación para esto también?

Answer 1

Escribí un script para probar varias funciones de hashing. Para esto quería archivos de datos "aleatorios", y no quería usar el mismo archivo dos veces para que ninguna de las funciones tuviera una ventaja de caché de kernel sobre la otra. Encontré que tanto / dev / random como / dev / urandom eran dolorosamente lentos. Elegí usar dd para copiar los datos de mi disco duro a partir de compensaciones aleatorias. NUNCA sugeriría usar esto si está haciendo algo relacionado con la seguridad, pero si todo lo que necesita es ruido, no importa dónde lo obtenga. En una Mac use algo como / dev / disk0 en Linux use / dev / sda

Aquí está el script de prueba completo:

tests=3
kilobytes=102400
commands=(md5 shasum)
count=0
test_num=0
time_file=/tmp/time.out
file_base=/tmp/rand

while [[ test_num -lt tests ]]; do
    ((test_num++))
    for cmd in "${commands[@]}"; do
        ((count++))
        file=$file_base$count
        touch $file
        # slowest
        #/usr/bin/time dd if=/dev/random of=$file bs=1024 count=$kilobytes >/dev/null 2>$time_file
        # slow
        #/usr/bin/time dd if=/dev/urandom of=$file bs=1024 count=$kilobytes >/dev/null 2>$time_file                                                                                                        
        # less slow
        /usr/bin/time sudo dd if=/dev/disk0 skip=$(($RANDOM*4096)) of=$file bs=1024 count=$kilobytes >/dev/null 2>$time_file
        echo "dd took $(tail -n1 $time_file | awk ''{print $1}'') seconds"
        echo -n "$(printf "%7s" $cmd)ing $file: "
        /usr/bin/time $cmd $file >/dev/null
        rm $file
    done
done

Aquí están los resultados / dev / disk0 "menos lentos":

dd took 6.49 seconds
    md5ing /tmp/rand1:         0.45 real         0.29 user         0.15 sys
dd took 7.42 seconds
 shasuming /tmp/rand2:         0.93 real         0.48 user         0.10 sys
dd took 6.82 seconds
    md5ing /tmp/rand3:         0.45 real         0.29 user         0.15 sys
dd took 7.05 seconds
 shasuming /tmp/rand4:         0.93 real         0.48 user         0.10 sys
dd took 6.53 seconds
    md5ing /tmp/rand5:         0.45 real         0.29 user         0.15 sys
dd took 7.70 seconds
 shasuming /tmp/rand6:         0.92 real         0.49 user         0.10 sys

Aquí están los resultados "lentos" / dev / urandom:

dd took 12.80 seconds
    md5ing /tmp/rand1:         0.45 real         0.29 user         0.15 sys
dd took 13.00 seconds
 shasuming /tmp/rand2:         0.58 real         0.48 user         0.09 sys
dd took 12.86 seconds
    md5ing /tmp/rand3:         0.45 real         0.29 user         0.15 sys
dd took 13.18 seconds
 shasuming /tmp/rand4:         0.59 real         0.48 user         0.10 sys
dd took 12.87 seconds
    md5ing /tmp/rand5:         0.45 real         0.29 user         0.15 sys
dd took 13.47 seconds
 shasuming /tmp/rand6:         0.58 real         0.48 user         0.09 sys

Aquí están los resultados "más lentos" / dev / aleatorios:

dd took 13.07 seconds
    md5ing /tmp/rand1:         0.47 real         0.29 user         0.15 sys
dd took 13.03 seconds
 shasuming /tmp/rand2:         0.70 real         0.49 user         0.10 sys
dd took 13.12 seconds
    md5ing /tmp/rand3:         0.47 real         0.29 user         0.15 sys
dd took 13.19 seconds
 shasuming /tmp/rand4:         0.59 real         0.48 user         0.10 sys
dd took 12.96 seconds
    md5ing /tmp/rand5:         0.45 real         0.29 user         0.15 sys
dd took 12.84 seconds
 shasuming /tmp/rand6:         0.59 real         0.48 user         0.09 sys

Notarás que / dev / random y / dev / urandom no fueron muy diferentes en velocidad. Sin embargo, / dev / disk0 tomó 1/2 del tiempo.

PD. Disminuyo el número de pruebas y eliminé todas las órdenes menos 2 por "brevedad" (no es que logré ser breve).

Answer 2

Esto se debe a que en la mayoría de los sistemas /dev/random utiliza datos aleatorios del entorno, como la estática de dispositivos periféricos. El conjunto de datos verdaderamente aleatorios (entropía) que utiliza es muy limitado. Hasta que haya más datos disponibles, saldrán los bloques.

Vuelva a intentar su prueba con /dev/urandom (observe la u ) y verá una aceleración significativa.

Ver Wikipedia para más información. /dev/random no siempre genera datos verdaderamente aleatorios, pero claramente en su sistema lo hace.

Ejemplo con /dev/urandom :

$ time dd if=/dev/urandom of=/dev/null bs=1 count=1024
1024+0 records in
1024+0 records out
1024 bytes (1.0 kB) copied, 0.00675739 s, 152 kB/s

real    0m0.011s
user    0m0.000s
sys 0m0.012s

Answer 3

Hilo viejo pero solo necesitaba lo mismo. El viejo amigo C vino a rescatar, ya que no quiero meterme con los scripts. Aquí está mi solución, que es lo suficientemente buena y rápida para mí:

// usage: ./program <outfile> <size-in-bytes>
#include <stdio.h>
void main(int argc, char** argv){
    long long i, s;
    FILE* f = fopen(*(argv+1), "w");
    srand(time(NULL));
    sscanf(*(argv+2), "%lld", &s);  
    for(i=0;i<s;i++){
        fputc(rand()%255,f);
    }
    fclose(f);
}

Answer 4

Hilo viejo, pero como mencionó Tobbe, necesitaba algo así solo mejor (más rápido).

Así que ... una forma sencilla de hacerlo de la misma manera, simplemente más rápido que aleatorio / aleatorio, útil cuando se crean archivos realmente grandes, lo admito no completamente aleatorio, pero probablemente lo suficientemente cerca, depende de sus necesidades.

dd if=/dev/mem of=test1G.bin bs=1M count=1024
touch test100G.bin
seq 1 100 | xargs -Inone cat test1G.bin >> test100G.bin

Esto creará un archivo de 100 Gb a partir del contenido de su ram (el primer 1 GB, asumo que tiene tanto ram :)) Tenga en cuenta que probablemente no sea seguro compartir este archivo, ya que puede contener todo tipo de datos confidenciales como sus contraseñas. así que úselo solo para sus propias causas :) Ah, y necesita ejecutarlo como root por la misma razón.

Answer 5

Intente /dev/urandom lugar:

$ time dd if=/dev/urandom of=random-file bs=1 count=1024

De: http://stupefydeveloper.blogspot.com/2007/12/random-vs-urandom.html

La principal diferencia entre aleatorio y urandom es cómo extraen datos aleatorios del núcleo. Al azar siempre toma datos de la agrupación de entropía. Si el grupo está vacío, aleatorio bloqueará la operación hasta que el grupo se llene lo suficiente. urandom generará datos usando SHA (o cualquier otro algoritmo, MD5 a veces) algoritmo en el grupo de entropía del kernel de casos está vacío. urandom nunca bloqueará la operación.