Ihre Aufgabe ist es, einen Hardware-Zufallszahlengenerator mit der Hardware zu improvisieren, die Sie haben.

Herausforderung

Schreiben Sie ein Programm mit folgenden Eigenschaften:

1. Es wird entweder 0oder 1(und sonst nichts) gedruckt .
2. Die Ausgabe hängt von einem physischen Prozess ab und nicht nur vom internen Zustand des Computers.
3. Es gibt keine Beziehung zwischen den Ausgaben nachfolgender Läufe (im Abstand von einer Minute).
4. Die Leistung ist mit keinem realistischen Aufwand vorhersehbar.
5. Die Wahrscheinlichkeit der Ausgabe 0liegt zwischen 0,2 und 0,8.
6. Es läuft mit einer relativ hohen Wahrscheinlichkeit in weniger als einer Minute.

Sie müssen erklären, warum Ihr Programm diese Eigenschaften hat, wenn dies nicht offensichtlich ist.

Erläuterungen und Einschränkungen

Das Folgende mag wie eine Menge Einschränkungen für einen Beliebtheitswettbewerb erscheinen, aber letztendlich ist es alles, um sicherzustellen, dass das Programm im Geist der Frage bleibt, etwas funktioniert und um Lösungen zu vermeiden, die beliebt sind, weil sie ein totaler Overkill sind, aber ultimativ eher langweilig.

• Die Systemzeit zählt nicht als physischer Prozess.
• Sie können jede beliebige Consumer-Hardware verwenden, von 8-Zoll-Floopy-Disk-Laufwerken über einen USB-Raketenwerfer bis hin zu Kopfhörern - es sei denn, diese ist für die Zufallsgenerierung vorgesehen. Ein Hardware-Teil ist für den Endverbraucher geeignet, wenn es in Massenproduktion hergestellt wird und weniger als 1000 US-Dollar kostet. Sie können also keine Radioteleskope, das CERN, MRTs oder Ihren selbstgebauten Partikeldetektor verwenden.
• Sie können nur die grundlegendsten Annahmen zum Status und zur Ausrichtung der Hardware treffen, z. B. Einschalten (sofern diese über einen Netzschalter verfügt) und ordnungsgemäße Installation und Funktionsweise. Beispielsweise können Sie davon ausgehen, dass ein CD-Laufwerk im Allgemeinen in der Lage ist, eine CD zu lesen und nicht zu blockieren, aber Sie können nicht davon ausgehen, dass es offen oder geschlossen ist oder eine CD enthält. In einem anderen Beispiel können Sie nicht davon ausgehen, dass zwei Hardware-Teile aufeinander abgestimmt sind, um eine besondere Interaktion zu ermöglichen, sondern dass sie sich im selben Raum befinden.
• Sie können die Hardware in einem beliebigen Zustand belassen, es sei denn, Sie beschädigen sie.
• Sie können und müssen davon ausgehen, dass sich die Hardware in einer natürlichen Umgebung befindet, mehr jedoch nicht. Sie können beispielsweise davon ausgehen, dass sich die Hardware weder in einem Tank mit flüssigem Helium noch in einem extrem schall- und lichtdichten Raum oder im Weltraum befindet. Es kann jedoch nicht davon ausgegangen werden, dass Schall- und Lichtquellen vorhanden sind, außer solchen, die nur mit radikalen Anstrengungen vermieden werden können.
• Ihr Programm muss auf einem Standard-Desktop-Computer mit einem nicht-esoterischen Betriebssystem Ihrer Wahl ausgeführt werden. Sie können jede Software verwenden, die nicht speziell für die Generierung von Zufallszahlen entwickelt wurde.
• Sie können keinen Internetzugang annehmen.
• Sie können nicht davon ausgehen, dass Menschen anwesend oder abwesend sind, aber Sie können davon ausgehen, dass niemand absichtlich in Ihr Programm eingreift, z. B. indem Sie einen Lüfter manuell stoppen oder ein Programm ausführen, das nichts anderes tut, als das Mikrofon so oft wie möglich auszuschalten.
• Sie können nur die grundlegendsten Annahmen über die Softwareeinstellungen treffen. Beispielsweise können Sie davon ausgehen, dass Treiber installiert und aktiviert sind, Sie müssen jedoch darauf vorbereitet sein, dass der Ton stummgeschaltet wird.
• Sie können die Softwareeinstellungen in einem beliebigen Zustand belassen.

Bonus

Eine besondere Belohnung wurde für eine besonders kurze Lösung vergeben. Dies war eher durch die Anzahl der Anweisungen und ähnlich als durch die Zeichen. Die Gewinner waren (gebunden nach meinen Kriterien):

• Diese Antwort von Franki.
• Diese Antwort von Tejas Kale.

Ich konnte nur eine Antwort vergeben und die Antwort von Tejas Kale wurde durch Los gewonnen.

Schale

Liest ein einzelnes Sample aus dem Mikrofon-Stream und druckt das niedrigstwertige Bit, das vom Rauschen dominiert werden sollte.

EDIT: Geändert, um die Stummschaltung des Mikrofons aufzuheben ... und alles andere auch!

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

Bash

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

Erfasst die Entropie von der Antwortzeit eines einzelnen Pings an localhost.

Beachten Sie, dass die Antwortzeit genau dreimal in der Ausgabe von 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

Alle anderen Zahlen und konstant und - was noch wichtiger ist - unabhängig von der Reaktionszeit.

sed 's/[^1-9]/+/g'Wandelt jede Null und jede Ziffer in Pluszeichen um und gibt echo $[...0&1]die Parität der resultierenden Summe aus.

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

JSFiddle hier .

Verwendet die HTML5 DeviceMotion-API auf unterstützten Geräten (hauptsächlich Mobilgeräten). Es verwandelt das resultierende accelerationObjekt in JSON, hackt es und nimmt den Rest von Modulo 2.

Der größte Teil des Codes ist die Hash-Funktion (verdammt noch mal JavaScript und das völlige Fehlen einer Standardbibliothek). Es könnte wahrscheinlich kürzer sein, aber ich bin ein Trottel für eine gute Hash-Funktion.

Python + Webcam

Mit Code schamlos gestohlen hier , nimmt eine shapshot Ihre Webcam verwenden, Hashes , die Daten und druckt das niedrigstwertige Bit.

#!/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

Überprüft die Antwortzeit Ihrer Festplatte, indem drei Vorgänge zeitlich festgelegt werden:

• Die eigene Quelle lesen
• Löscht sich
• Wieder selbst schreiben

Schließlich wird die benötigte Zeit als Float gepackt und das 11. höchstwertige Bit verwendet (das zweithöchste Bit der Mantisse).

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

Bash

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

sensors druckt die aktuellen Systemtemperaturen zusammen mit der Lüftergeschwindigkeit.

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'Wandelt jede Null und jede Ziffer in Pluszeichen um und das Echo gibt $[...0&1]die Parität der resultierenden Summe aus.

Regex- und Paritätsberechnung entlehnt der Antwort von Dennis.

Bash

(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

Benutzt alles, nur für den Fall ...

Kommt drauf an

• Sensorwerte der meisten Hardwaresensoren (ungefähr alle zeigen ihre Werte irgendwo in /sysoder /proc)
• Anzahl, Speicherlayout und Laufzeiten aller Prozesse im System (die als "Status des Systems" betrachtet werden können, in der Regel jedoch von den Timings der Hardware abhängen)
• Je nach System /proc/<pid>/s*hängen verschiedene Werte in (z. B. sched / schedstat) von der Geschwindigkeit der Hardware ab, die erforderlich ist, um diese Prozesse zum Leben zu erwecken.
• Dinge, an die ich vielleicht nicht gedacht habe, sind auch in diesen Dateien verfügbar.

Die Laufzeit auf meinem System beträgt ~ 10s, kann aber stark variieren. Führen Sie dies insbesondere nicht als root aus, oder ändern Sie es zumindest zum Ausschließen /proc/kcore(es sei denn, Sie sind bereit, viel Zeit für das Einschließen der darin enthaltenen Entropie zu verwenden, was wahrscheinlich wirklich alles einschließen würde).

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

Versetzt die WLAN-Karte in den Überwachungsmodus, speichert empfangene Pakete im Wert von 30 Sekunden (einschließlich nicht lesbarer verschlüsselter Daten aus benachbarten Netzwerken), nimmt den sha512-Hash der Paketdaten und gibt 1 zurück, wenn der erste Buchstabe des Hashs 0-7 ist . Angenommen, Ihre Wi-Fi-Karte ist wlan0und Sie haben derzeit kein mon0Gerät.

Wenn sich keine Wi-Fi-Geräte in der Nähe befinden, ist die Ausgabe vorhersehbar, da sie jedes Mal dieselbe ist.

Moderne 8086-kompatible Prozessoren von Intel enthalten ein leicht zugängliches Peripheriegerät, das eine ordnungsgemäße Zufälligkeit erzeugt. Das Ansteuern dieses Peripheriegeräts erfolgt unter Verwendung des rdrandBefehls, der entweder ein zufälliges Bitmuster erzeugt oder das Übertragsflag setzt, wenn das Peripheriegerät nicht verfügbar ist oder keine Entropie mehr aufweist.

Das folgende Kurzprogramm für 80386 Linux prüft anhand der cpuidAnweisung , ob das Peripheriegerät verfügbar ist und versucht, eine Zufallszahl zu generieren. Wenn entweder das Peripheriegerät oder eine Zufallszahl nicht verfügbar ist, wird das Programm mit dem Status beendet 1. Konnte eine Zufallszahl generiert werden, wird entweder a 1oder a 0ausgedruckt und das Programm mit dem Exit-Status beendet 0.

Speichern unter rand.sund zusammenbauen mit

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

Hier ist die gesamte Versammlung:

        .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

Und ein Dump der resultierenden 77 Bytes Maschinencode:

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

Bash

Ziel ist die unnötig teure Methode zum Sammeln von Zufallszahlen. Wie lange es dauert, Emacs millionenfach zu spawnen, und verwenden Sie dann Dennis 'Trick, um die Zeit in einen einzelnen Booleschen Wert umzuwandeln (auf meinem Computer dauert es ungefähr 7 Sekunden).

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

Arduino Mega1280

edit: aktualisierte Version, die robust ist, wenn etwas in die Pins gesteckt ist. Die Idee beruht auf der Tatsache, dass der ATMega1280 einen separaten internen Oszillator für den Watchdog-Oszillator verwendet. Ich richte einfach einen Watchdog-Interrupt ein, der ein Flag setzt, einen Zähler basierend auf der Systemuhr (auf dem Arduino ist dies ein externer 16-MHz-Quarz) und erlaube, dass Taktjitter / -varianz die Arbeit machen.

#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/

Nimmt Videoeingang.

Sie können den Screenshot sehen, mit dem die Zufallszahl berechnet wurde.

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 unter Linux

Messen Sie die Lesegeschwindigkeit einer Festplatte und die Zugriffszeit eines häufig aktualisierten Verzeichnisses auf dieser Disc, dessen Layout nicht vorhersehbar ist.

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

erfordert:

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.

Dieser Ansatz hat den Vorteil, dass keine Daten auf dem System geändert werden und kein Perl über dem von primo erforderlich ist.

Schale

Getestet unter Linux, aber vielleicht hat Ihr U * IX / proc / stat auch?

Dies startet nur einen zusätzlichen Vorgang, liest nur eine zusätzliche Datei (nicht einmal auf der Disc) und ist 37 Zeichen kurz. Es ist auch ziemlich schnell.

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

Man kann denken, dass dies von allen Kernel- und Userland-Prozesszuständen bestimmt wird, aber das ist nicht der Fall, da / proc / stat auch die E / A-Wartezeit, die Zeit für die Wartung von Hardware-Interrupts, die Zeit für Leerlaufaufgaben und einige andere umfasst hängen vom externen Hardwareeingang ab.

Matlab

Die Mikrofonlösung:

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

Nimmt 10 Sekunden Ton auf, ermittelt die Anzahl der negativen Samples in der Aufnahme und gibt 0 aus, wenn diese Anzahl gerade ist, und 1, wenn sie ungerade ist. Also 0 mit 50% Wahrscheinlichkeit. Der Ansatz bedeutet, dass selbst geringe Mengen an Rauschen, die bei einer stillen Aufnahme unvermeidbar sind, ausreichen, um eine zufällige Ausgabe zu generieren. Der folgende etwas längere Code beschleunigt den Zahlengenerator, indem eine kürzere Aufzeichnung verwendet wird, die mit einer höheren Bitrate kompensiert wird, die mehr Rauschen erzeugt.

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

In einem Test unter ruhigen Bedingungen stelle ich fest, dass in 100 Läufen des letzteren Codes der Code 51 Mal null ausgibt. 100 Läufe unter lauten Bedingungen wurden 40-mal null produziert.

Edit: Danke an Emil für den Hinweis auf einen Fehler im Originalcode :-)

Bash

(Danke, Dennis.)

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

Nimmt das niedrigstwertige Bit des Beschleunigungsmessers des Computers (benötigt das hdapsLinux-Modul):

#!/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)

Dies misst im Wesentlichen das Rauschen des Sensors.

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.

Verwendet den Bewegungssensor des 3DS. Die Z-Achse des Beschleunigungsmessers liegt normalerweise bei -1 (aufgrund der Schwerkraft), und aufgrund von zufälligem Rauschen kann sie manchmal darüber oder darunter liegen.

Hier ist eine, die das Mikrofon verwendet:

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

Bash

Ich nahm Sohams eigenen Vorschlag an (unter Verwendung von top):

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

Bearbeiten: Es funktioniert genauso wie bei Soham. Alle nicht numerischen Zeichen in der Ausgabe von top werden in '+' umgewandelt, und die Parität der resultierenden Zeichenfolge wird ausgewertet.

Das 'b'-Flag nach oben führt es im Batch-Modus aus, sodass alle Prozesse gemeldet werden, nicht nur der erste Bildschirm und' n1 'sagt, dass nur 1 Iteration von oben ausgeführt werden soll.