tutorial traduccion programas programacion ejemplos comando bourne again linux bash

linux - traduccion - Generando un archivo binario aleatorio



ejemplos de programas en bash (5)

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).

¿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?

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

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); }

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.

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.