Su tarea es improvisar un generador de números aleatorios de hardware con cualquier hardware que tenga por ahí.

Desafío

Escriba un programa con las siguientes propiedades:

1. Imprime ya sea 0o 1(y nada más).
2. La salida depende de un proceso físico y no solo del estado interno de la computadora.
3. No hay relación entre las salidas de ejecuciones posteriores (con un minuto de diferencia).
4. El resultado no es predecible con ningún esfuerzo realista.
5. La probabilidad de que la salida 0sea ​​entre 0.2 y 0.8.
6. Se ejecuta en menos de un minuto con una probabilidad razonablemente alta.

Debe explicar por qué su programa tiene estas propiedades, si no es obvio.

Aclaraciones y restricciones

Lo siguiente puede parecer una gran cantidad de restricciones para un concurso de popularidad, pero en última instancia, todo es para garantizar que el programa se mantenga dentro del espíritu de la pregunta, de alguna manera funcione y para evitar soluciones que son populares debido a una exageración total pero que son en última instancia bastante aburrido

• El tiempo del sistema no cuenta como un proceso físico.
• Puede usar cualquier hardware de calidad de consumidor que desee, desde unidades de disco floopy de 8 pulgadas hasta un lanzador de cohetes USB y auriculares, a menos que esté destinado a la generación de números aleatorios. Una pieza de hardware es de calidad para el consumidor, si se produce en masa y cuesta menos de 1000 $ / € / £, por lo que no puede usar radiotelescopios, el CERN, MRI o su detector de partículas casero.
• Solo puede hacer las suposiciones más básicas sobre el estado y la alineación del hardware, como estar encendido (si tiene un interruptor de alimentación) y estar instalado y funcionando correctamente. Por ejemplo, puede suponer que una unidad de CD es generalmente capaz de leer un disco y no estar atascada, pero no puede suponer que esté abierta o cerrada o que contenga un disco. En otro ejemplo, no puede suponer que dos piezas de hardware estén alineadas para permitir una interacción especial, pero puede suponer que están en la misma habitación.
• Puede dejar el hardware en el estado que desee, a menos que lo rompa.
• Puede y debe asumir que el hardware está en un entorno natural, pero nada más. Por ejemplo, puede suponer que el hardware no está colocado en un tanque de helio líquido ni en una habitación extremadamente insonorizada ni a prueba de luz ni en el espacio. Sin embargo, no puede suponer que haya fuentes de sonido y luz, excepto aquellas que solo pueden evitarse con esfuerzos radicales.
• Su programa debe ejecutarse en una computadora de escritorio estándar con un sistema operativo no esotérico de su elección. Puede emplear cualquier software que no esté específicamente diseñado para la generación de números aleatorios.
• No puede asumir el acceso a Internet.
• No puede suponer que los humanos estén presentes o ausentes, pero puede suponer que nadie interfiere intencionalmente con su programa, por ejemplo, deteniendo manualmente un ventilador o ejecutando un programa que no hace nada más que apagar el micrófono con la mayor frecuencia posible.
• Solo puede hacer las suposiciones más básicas sobre la configuración del software. Por ejemplo, puede asumir que los controladores están instalados y activados, pero debe estar preparado para silenciar el sonido.
• Puede dejar la configuración del software en el estado que desee.

Prima

Se otorgó una recompensa especial a una solución particularmente corta. Esto fue más bien por números de instrucciones y similares que por caracteres. Los ganadores fueron (empatados según mi criterio):

• Esta respuesta de Franki.
• Esta respuesta de Tejas Kale.

Solo pude otorgar una respuesta y la respuesta de Tejas Kale ganó por sorteo.

Cáscara

Lee una sola muestra del flujo del micrófono e imprime su bit menos significativo, que debe estar dominado por el ruido.

EDITAR: Cambiado para activar el micrófono ... ¡y todo lo demás también!

# Warning - unmutes EVERYTHING!
for DEV in `amixer | grep Simple | sed -e "s/.*'\(.*\)'.*/\\1/" -e "s/ /~/g"`
do
    amixer -q -- sset "`echo $DEV | sed 's/~/ /g'`" unmute 100% 2>/dev/null
done

echo $(( `od -N1 -d < /dev/dsp | head -n1 | sed 's/.* //'` & 1 ))

Golpetazo

echo $[`ping -qc1 127.1|sed 's/[^1-9]/+/g'`0&1]

Reúne la entropía del tiempo de respuesta de un solo ping a localhost.

Tenga en cuenta que el tiempo de respuesta aparece exactamente tres veces en la salida de ping -qc1:

PING 127.1 (127.0.0.1) 56(84) bytes of data.

--- 127.1 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.044/0.044/0.044/0.000 ms

Todos los demás números y constante y, lo que es más importante, independiente del tiempo de respuesta.

sed 's/[^1-9]/+/g'convierte cada cero y no dígito en signos más, e echo $[...0&1]imprime la paridad de la suma resultante.

JavaScript + HTML5 DeviceMotion

var hash = function(x) {
    var h = 0
    for (var i = 0; i < x.length; i++) {
        h += x.charCodeAt(i)
        h ^= h << 5
        h ^= h >> 3
        h ^= h << 13
        h &= 0xffff
    }
    return h
}
var listener = function(e) {
    var accelerationString = JSON.stringify(e.acceleration)
    var hashed = hash(accelerationString)
    alert(hashed % 2)
    window.removeEventListener("devicemotion", listener, true)
}
window.addEventListener("devicemotion", listener, true);

JS Violín aquí .

Utiliza la API HTML5 DeviceMotion en dispositivos compatibles (en su mayoría dispositivos móviles). Convierte el accelerationobjeto resultante en JSON, lo procesa y toma el resto del módulo 2.

La mayor parte del código es la función hash (maldito sea JavaScript, y su total falta de una biblioteca estándar). Probablemente podría ser más corto, pero soy un fanático de una buena función hash.

Python + Webcam

Usando código robado descaradamente desde aquí , toma una captura de pantalla usando su cámara web, procesa los datos e imprime el bit menos significativo.

#!/usr/bin/python
import pygame.camera, hashlib

pygame.camera.init()
cam = pygame.camera.Camera(pygame.camera.list_cameras()[0])
cam.start()
raw = cam.get_raw()
cam.stop()
pygame.camera.quit()

h = hashlib.sha256()
h.update(raw)
print ord(h.digest()[-1]) % 2

Perl

Comprueba el tiempo de respuesta de su disco duro, cronometrando tres operaciones:

• Leyendo su propia fuente
• Eliminándose a sí mismo
• Escribiendo de nuevo

Finalmente, el tiempo necesario se empaqueta como flotante y se utiliza el undécimo bit más significativo (el segundo bit más significativo de la mantisa).

use Time::HiRes qw(time);

$t1 = time;
open SELF, "<$0";
read SELF, $_, $^H;
close SELF;

unlink $0;

open SELF, ">$0";
print SELF $_;
close SELF;

print 1&unpack(xB3, pack(f, time-$t1))

Golpetazo

echo $[`sensors|sed 's/[^1-9]/+/g'`0&1]

sensors imprime las temperaturas actuales del sistema junto con la velocidad del ventilador.

acpitz-virtual-0
Adapter: Virtual device
temp1:        +52.0°C  (crit = +98.0°C)

thinkpad-isa-0000
Adapter: ISA adapter
fan1:        3510 RPM

coretemp-isa-0000
Adapter: ISA adapter
Physical id 0:  +54.0°C  (high = +86.0°C, crit = +100.0°C)
Core 0:         +51.0°C  (high = +86.0°C, crit = +100.0°C)
Core 1:         +46.0°C  (high = +86.0°C, crit = +100.0°C)

sed 's/[^1-9]/+/g'convierte cada cero y no dígito en signos más, y echo $[...0&1]imprime la paridad de la suma resultante.

Regex y cálculo de paridad tomados de la respuesta de dennis.

Golpetazo

(echo -en "ibase=16;";(find /proc/[0-9]*/s* -type f -maxdepth 2 ; find /sys /proc/[^0-9]* -type f) 2>&1 | xargs -n1 sha256sum  2>&1 | sha256sum | tr abcdef ABCDEF | sed 's/  -/%2/' )| bc

Utiliza todo, por si acaso ...

Depende de

• lecturas de sensores de la mayoría de los sensores de hardware (casi todos exponen de alguna manera sus valores en algún lugar de /syso /proc)
• número, diseño de memoria y tiempos de ejecución de todos los procesos en el sistema (que pueden considerarse "estado del sistema" pero generalmente dependen de los tiempos del hardware)
• Dependiendo del sistema, varios valores en /proc/<pid>/s*(por ejemplo, sched / schedstat) dependen de la velocidad del hardware necesario para dar vida a esos procesos.
• cosas que quizás no haya pensado que están disponibles en esos archivos también.

El tiempo de ejecución en mi sistema es de ~ 10 segundos, pero puede variar mucho. Especialmente no ejecute esto como root, o al menos modifíquelo para excluirlo /proc/kcore(a menos que esté dispuesto a pasar mucho tiempo para incluir la entropía contenida allí, que probablemente realmente lo incluiría todo)

Shell + Wi-Fi

sudo airmon-ng start wlan0 > /dev/null && sudo dumpcap -a duration:30 -i mon0 -w out.cap > /dev/null && sha512sum out.cap | grep -c "^[0-7]" && sudo airmon-ng stop mon0 > /dev/null

Pone la tarjeta wi-fi en modo monitor, descarga 30 segundos de los paquetes recibidos (incluidos los datos cifrados ilegibles de las redes vecinas), toma el hash sha512 de los datos del paquete y devuelve 1 si la primera letra del hash es 0-7 . Asume que su tarjeta wi-fi es wlan0y que actualmente no tiene un mon0dispositivo.

Si no hay dispositivos wi-fi cercanos, la salida será predecible, ya que siempre será la misma.

Los modernos procesadores compatibles con 8086 fabricados por Intel contienen un periférico de fácil acceso que genera una aleatoriedad adecuada. La conducción de ese periférico se realiza utilizando la rdrandinstrucción que genera un patrón de bits aleatorio o establece el indicador de acarreo si el periférico no está disponible o está fuera de entropía.

El siguiente programa corto para 80386 Linux comprueba si el periférico está disponible mediante la cpuidinstrucción e intenta generar un número aleatorio. Si el número periférico o aleatorio no está disponible, el programa finalizará con un estado de 1. Si se podría generar un número aleatorio, ya sea un 1o una 0se imprime y las termina con el código de salida del programa 0.

Guardar como rand.sy ensamblar con

as --32 -o rand.o rand.s
ld -melf_i386 -o rand rand.o

Aquí está toda la asamblea:

        .globl _start
        .type _start,@function
_start:
        # check if the cpuid instruction is available by trying to
        # toggle the id flag in the eflags register
        pushfl
        mov (%esp),%eax
        btc $21,%eax    # toggle id bit
        push %eax
        popfl           # check if id bit was saved
        pushfl
        pop %eax        # load new flags
        pop %ecx        # load original flags
        xor %ecx,%eax   # difference is in %eax
        bt $21,%eax     # check if bit was flipped
        jnc .Lfailure

        # if we reach this part, we have a cpuid instruction
        # next, check if rdrand exists
        mov $1,%eax     # load cpuid leaf 1
        cpuid
        bt $30,%ecx     # is rdrnd available?
        jnc .Lfailure

        # let's try to get some random data
        rdrand %ax      # don't waste randomness; one bit would suffice
        jnc .Lfailure   # no randomness available
        and $1,%eax     # isolate one bit of randomness
        add $0x30,%al   # 0x30 = '0'
        push %eax
        mov $4,%eax     # prepare a write system call
        mov $1,%ebx
        mov %esp,%ecx   # where we placed the data before
        mov %ebx,%edx   # one byte
        int $0x80

        # okay, we're done here. Let's exit
        mov %ebx,%eax   # do an exit system call with status 0
        xor %ebx,%ebx
        int $0x80

.Lfailure:
        mov $1,%eax     # do an exit system call with status 1
        mov %eax,%ebx
        int $0x80

        .size _start,.-_start

Y un volcado de los 77 bytes resultantes de código de máquina:

08048098 <_start>:
 8048098:   9c                      pushf  
 8048099:   8b 04 24                mov    (%esp),%eax
 804809c:   0f ba f8 15             btc    $0x15,%eax
 80480a0:   50                      push   %eax
 80480a1:   9d                      popf   
 80480a2:   9c                      pushf  
 80480a3:   58                      pop    %eax
 80480a4:   59                      pop    %ecx
 80480a5:   31 c8                   xor    %ecx,%eax
 80480a7:   0f ba e0 15             bt     $0x15,%eax
 80480ab:   73 2f                   jae    80480dc <_start+0x44>
 80480ad:   b8 01 00 00 00          mov    $0x1,%eax
 80480b2:   0f a2                   cpuid  
 80480b4:   0f ba e1 1e             bt     $0x1e,%ecx
 80480b8:   73 22                   jae    80480dc <_start+0x44>
 80480ba:   66 0f c7 f0             rdrand %ax
 80480be:   73 1c                   jae    80480dc <_start+0x44>
 80480c0:   83 e0 01                and    $0x1,%eax
 80480c3:   04 30                   add    $0x30,%al
 80480c5:   50                      push   %eax
 80480c6:   b8 04 00 00 00          mov    $0x4,%eax
 80480cb:   bb 01 00 00 00          mov    $0x1,%ebx
 80480d0:   89 e1                   mov    %esp,%ecx
 80480d2:   89 da                   mov    %ebx,%edx
 80480d4:   cd 80                   int    $0x80
 80480d6:   89 d8                   mov    %ebx,%eax
 80480d8:   31 db                   xor    %ebx,%ebx
 80480da:   cd 80                   int    $0x80
 80480dc:   b8 01 00 00 00          mov    $0x1,%eax
 80480e1:   89 c3                   mov    %eax,%ebx
 80480e3:   cd 80                   int    $0x80

golpetazo

Apuntando al método de recopilación de números aleatorios más innecesariamente costoso. Calcule cuánto tiempo lleva generar emacs un millón de veces, luego use el truco de Dennis para convertir el tiempo que toma en un solo booleano (toma alrededor de 7 segundos en mi máquina).

$[`(time (seq 1000000 | xargs -P1000 emacs  >/dev/null 2>&1)) |& sed 's/[^1-9]/+/g'`0&1]

Arduino Mega1280

editar: versión actualizada que es robusta contra cualquier cosa conectada a los pines. La idea se basa en el hecho de que el ATMega1280 usa un oscilador interno separado para el oscilador de vigilancia. Simplemente configuro una interrupción de vigilancia que establece una bandera, tengo un contador basado en el reloj del sistema (en el Arduino, este es un cristal externo de 16MHz) y permite que la fluctuación / variación del reloj haga el trabajo.

#include <avr/interrupt.h>

int time;
volatile bool wdt_ran;

// watchdog interrupt handler
ISR(WDT_vect, ISR_BLOCK)
{
  wdt_ran = true;
}

void setup()  
{
  // setup watchdog interrupt
  cli();
  MCUSR &= ~(1 << WDRF);
  WDTCSR |= (1<<WDCE) | (1<<WDE);
  WDTCSR = (1<<WDIE) | (1<<WDP2) | (1<<WDP1) | (1<<WDP0);
  sei();
  // Open serial communications and wait for port to open:
  Serial.begin(57600);
}

void loop()
{
  if(wdt_ran)
  {
    Serial.println(abs(time%2));
    wdt_ran = false;
  }
  ++time;
}

Javascript

http://jsfiddle.net/prankol57/9a6s0gmv/

Toma entrada de video.

Puede ver la captura de pantalla que utilizó para calcular el número aleatorio.

var m = (navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia);

var constraints = {
  video: {
    mandatory: {
      maxWidth: 350,
      maxHeight: 350
    }
  },
  audio: false
};

var video = document.querySelector("video"), canvas = document.createElement("canvas");
document.body.appendChild(canvas);
canvas.width = 350;
canvas.height = 350;

function start() {
    m.call(navigator, constraints, function (stream) {
        video.src = window.URL.createObjectURL(stream);
    }, function() {
        alert("An error occured. Did you deny permission?");
    });
}

if (m) {
    start();
} else {
    alert('getUserMedia() is not supported in your browser');
}

function getRandomData() {
    var ctx = canvas.getContext("2d");
    ctx.drawImage(video, 0, 0);
    var data = ctx.getImageData(0, 0, 350, 350).data;
    var total = 0;
    for (var i = 0; i < data.length; ++i) {
        total += data[i];
        total %= 2;
    }
    alert("The random number is " + total);
}

document.querySelector("button").onclick = getRandomData;

Shell en Linux

Mida la velocidad de lectura de un disco duro + tiempo de acceso de un directorio actualizado con frecuencia en este disco cuyo diseño es impredecible.

# Set this to the device node of whatever drive you want to measure
DRIVE_DEVICE=sda
# This must be a path that is
# a) on device "/dev/$DRIVE_PATH"
# b) frequently updated to add additional access time randomization due to
#    less-predictable disk layout due to less-predictable time, amount and
#    ordering uf updates, like logfile directories, maybe cache directories.
FIND_PATH=/var/log
# Better than using 'sync' - sync only the disk that we actually read from
# also sync both internal drive and system buffers
hdparm -f -F "/dev/$DRIVE_DEVICE"
# Note: bash's built-in time command doesn't support formats :/
# Note: the result is only going to be as good as the system's time command,
#       which isn't necessarily equally good on other U*ICes
t=$(command time -f '%e' -- find "$FIND_PATH" -printf '' 2>&1)
echo $((${t#*.}&1))

requiere:

1) read and execute access to every directory under "$FIND_PATH"
2) sending (flush) control commands to a hard drive via a device node.
   Requires root access per default, but can be delegated to a less privileged user
   either by using sudo on this script or by applying
       chgrp 'some_system_group' "$DRIVE_DEVICE" &&
       chmod g+rx "$DRIVE_DEVICE"
   if this is acceptable on your system.

Este enfoque tiene la ventaja de no modificar ningún dato en el sistema y no requiere perl sobre el de primo.

Cáscara

Probado en Linux, pero ¿quizás tu U * IX también tenga / proc / stat?

Esto inicia solo un proceso adicional, lee solo un archivo adicional (ni siquiera en el disco) y tiene 37 caracteres. También es bastante rápido.

t=1`sum /proc/stat`;echo $[${t% *}&1]

Uno puede pensar que esto está determinado por todos los estados del proceso de kernel y userland, pero ese no es el caso, ya que / proc / stat también incluye el tiempo de espera de E / S, el tiempo para interrumpir las interrupciones de hardware, el tiempo dedicado a la tarea inactiva y algunos otros que todos depende de la entrada de hardware externo.

Matlab

La solución de micrófono:

recObj=audiorecorder;recordblocking(recObj,10);rem(sum(getaudiodata(recObj)<0),2)

Graba 10 segundos de sonido, encuentra el número de muestras negativas en la grabación y emite 0 si este número es par y 1 si es impar. Entonces 0 con 50% de probabilidad. El enfoque significa que incluso pequeñas cantidades de ruido, inevitables en una grabación silenciosa, serán suficientes para generar una salida aleatoria. El siguiente código un poco más largo acelera el generador de números mediante el uso de una grabación más corta, compensada con una tasa de bits más alta, lo que genera más ruido.

recObj=audiorecorder(8000,16,1);recordblocking(recObj,0.1);rem(sum(getaudiodata(recObj)<0),2)

En una prueba en condiciones silenciosas, encuentro que en 100 ejecuciones del último código, el código genera cero 51 veces. 100 corridas en condiciones ruidosas produjeron cero 40 veces.

Editar: Gracias a Emil por señalar una falla en el código original :-)

Golpetazo

(Gracias, Dennis)

echo $[`w|sed 's/[^1-9]/+/g'`0&1]

Toma el bit menos significativo del acelerómetro de la computadora (necesita el hdapsmódulo Linux):

#!/usr/bin/env python
import re
m = re.search('([-\d]+),([-\d]+)',
              open('/sys/devices/platform/hdaps/position', 'r').read())
print((int(m.group(1)) ^ int(m.group(2))) & 1)

Básicamente, esto mide el ruido del sensor.

SmileBASIC

XON MOTION 'enable motion sensor
ACCEL OUT ,,Z 'get Z acceleration (up/down)
PRINT Z<-1 'if Z is less than -1, output 1, otherwise 0.

Utiliza el sensor de movimiento del 3DS. El eje Z del acelerómetro generalmente está alrededor de -1 (debido a la gravedad), y debido al ruido aleatorio, a veces puede estar por encima o por debajo de eso.

Aquí hay uno que usa el micrófono:

XON MIC 'enable microphone
DIM REC%[0] 'make array
MICSTART 0,3,1 'start recording. 0=8180Hz, 3=8 bit unsigned, 1=1 second
WAIT 1 'delay (1 frame is enough since we only check the first sample)
MICSAVE MIC 'save recording
PRINT MIC[0]>0 'if the first sample isn't negative, output 1

Golpetazo

Tomé la propia sugerencia de Soham (usando top):

echo $[`top -bn1|sed 's/[^1-9]/+/g'`0&1]

Editar: Funciona de la misma manera que Soham's. Convierte todos los caracteres no numéricos en la salida de top en '+' y luego evalúa la paridad de la cadena resultante.

la bandera 'b' hacia arriba lo ejecuta en modo por lotes para que informe todos los procesos, no solo la primera pantalla y 'n1' dice que solo se ejecute 1 iteración de arriba.