Tugas Anda adalah mengimprovisasi generator nomor acak perangkat keras dengan perangkat keras apa pun yang Anda miliki.

Tantangan

Tulis program dengan properti berikut:

1. Mencetak baik 0atau 1(dan tidak ada yang lain).
2. Outputnya tergantung pada proses fisik dan bukan hanya keadaan internal komputer.
3. Tidak ada hubungan antara output berjalan berikutnya (terpisah satu menit).
4. Output tidak dapat diprediksi dengan upaya realistis.
5. Probabilitas output 0adalah antara 0,2 dan 0,8.
6. Ini berjalan dalam waktu kurang dari satu menit dengan probabilitas yang cukup tinggi.

Anda harus menjelaskan mengapa program Anda memiliki properti ini, jika tidak jelas.

Klarifikasi dan Batasan

Berikut ini mungkin tampak seperti banyak sekali pembatasan untuk kontes popularitas, tetapi pada akhirnya itu semua untuk memastikan bahwa program tetap dalam semangat pertanyaan, agak berhasil dan untuk menghindari solusi yang populer karena menjadi total berlebihan tetapi secara ultimatif agak membosankan.

• Waktu sistem tidak dihitung sebagai proses fisik.
• Anda dapat menggunakan perangkat keras tingkat konsumen apa pun yang Anda suka dari cakram floopy-disk 8 inci ke peluncur roket USB ke headphone - kecuali jika itu dimaksudkan untuk pembangkitan angka acak. Sebuah perangkat keras adalah kelas konsumen, jika diproduksi secara massal dan harganya kurang dari $ 1000 / €, sehingga Anda tidak dapat menggunakan teleskop radio, CERN, MRI atau detektor partikel buatan rumah Anda.
• Anda hanya dapat membuat asumsi paling mendasar tentang status dan penyelarasan perangkat keras seperti dihidupkan (jika memiliki saklar daya) dan terpasang dengan baik dan fungsional. Misalnya, Anda dapat menganggap drive CD umumnya mampu membaca disk dan tidak macet, tetapi Anda tidak dapat menganggap itu drive terbuka atau tertutup atau mengandung disk. Dalam contoh lain Anda tidak dapat mengasumsikan dua buah perangkat keras yang akan disejajarkan untuk memungkinkan interaksi khusus, tetapi Anda dapat menganggap mereka berada di ruangan yang sama.
• Anda dapat meninggalkan perangkat keras dalam keadaan apa pun yang Anda suka, kecuali jika Anda merusaknya.
• Anda dapat dan harus menganggap perangkat keras berada di lingkungan alami, tetapi tidak lebih. Misalnya, Anda dapat mengasumsikan bahwa perangkat keras tidak diposisikan di dalam tangki helium cair atau di ruang yang sangat kedap suara dan ringan atau di ruang angkasa. Namun, Anda tidak dapat mengasumsikan sumber suara dan cahaya apa pun ada kecuali yang hanya bisa dihindari dengan upaya radikal.
• Program Anda harus dijalankan pada komputer desktop standar dengan sistem operasi non-esoterik pilihan Anda. Anda dapat menggunakan perangkat lunak apa pun yang tidak dirancang khusus untuk pembuatan angka acak.
• Anda tidak dapat mengambil akses Internet.
• Anda tidak dapat menganggap manusia hadir atau tidak ada, tetapi Anda dapat mengasumsikan bahwa tidak ada orang yang dengan sengaja mengganggu program Anda, misalnya, dengan menghentikan kipas angin secara manual atau menjalankan program yang tidak melakukan apa pun selain mematikan mikrofon sesering mungkin.
• Anda hanya dapat membuat asumsi paling mendasar tentang pengaturan perangkat lunak. Misalnya, Anda dapat menganggap driver diinstal dan diaktifkan tetapi Anda harus siap untuk suara yang akan dimatikan.
• Anda dapat meninggalkan pengaturan perangkat lunak dalam kondisi apa pun yang Anda suka.

Bonus

Hadiah khusus diberikan untuk solusi yang sangat singkat. Ini bukan dengan jumlah instruksi dan mirip dengan oleh karakter. Para pemenang (diikat sesuai dengan kriteria saya):

• Jawaban ini oleh Franki.
• Jawaban ini oleh Tejas Kale.

Saya hanya bisa memberikan satu jawaban dan jawaban Tejas Kale dimenangkan banyak.

Kulit

Membaca sampel tunggal dari aliran mikrofon dan mencetak bit yang paling tidak signifikan, yang harus didominasi oleh noise.

EDIT: Diubah untuk mengaktifkan mikrofon ... dan yang lainnya juga!

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

Pesta

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

Mengumpulkan entropi dari waktu respons satu ping ke localhost.

Perhatikan bahwa waktu respons muncul persis tiga kali dalam output 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

Semua angka lain dan konstan dan - lebih penting - independen dari waktu respons.

sed 's/[^1-9]/+/g'mengubah setiap nol dan non-digit menjadi tanda plus, dan echo $[...0&1]mencetak paritas dari jumlah yang dihasilkan.

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 di sini .

Menggunakan HTML5 DeviceMotion API pada perangkat yang didukung (kebanyakan perangkat seluler). Ini mengubah accelerationobjek yang dihasilkan menjadi JSON, hash itu, dan mengambil modulo 2 sisanya.

Sebagian besar kode adalah fungsi hash (JavaScript sialan, dan total Anda tidak memiliki perpustakaan standar). Mungkin bisa lebih pendek, tapi saya payah untuk fungsi hash yang baik.

Python + Webcam

Menggunakan kode yang dicuri tanpa malu-malu dari sini , mengambil gambar dengan menggunakan webcam Anda, hash data, dan mencetak bit yang paling tidak signifikan.

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

Periksa waktu respons Harddrive Anda, dengan menentukan waktu tiga operasi:

• Membaca sumbernya sendiri
• Menghapus sendiri
• Menulis sendiri lagi

Akhirnya, waktu yang diambil dikemas sebagai pelampung, dan bit ke-11 paling signifikan digunakan (bit paling signifikan kedua dari mantissa).

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

Pesta

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

sensors mencetak suhu sistem saat ini bersama dengan kecepatan kipas.

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'mengkonversi setiap nol dan non-digit menjadi tanda plus, dan gema $[...0&1]mencetak paritas dari jumlah yang dihasilkan.

Regex dan perhitungan paritas dipinjam dari jawaban dennis.

Pesta

(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

Menggunakan semuanya, untuk berjaga-jaga ...

Tergantung pada

• sensor membaca sebagian besar sensor perangkat keras (tentang semua entah bagaimana mengekspos nilai-nilai mereka di suatu tempat /sysatau /proc)
• angka, tata letak memori, dan runtime dari semua proses pada sistem (yang dapat dianggap "keadaan sistem" tetapi biasanya sendiri tergantung pada pengaturan waktu perangkat keras)
• tergantung pada sistem, berbagai nilai dalam /proc/<pid>/s*(mis. sched / schedstat) bergantung pada kecepatan perangkat keras yang diperlukan untuk menghidupkan proses tersebut.
• hal-hal yang mungkin tidak terpikir oleh saya yang tersedia di file-file itu juga.

Runtime pada sistem saya adalah ~ 10s, tetapi dapat sangat bervariasi. Terutama jangan menjalankan ini sebagai root, atau setidaknya memodifikasinya untuk mengecualikan /proc/kcore(kecuali jika Anda bersedia menghabiskan banyak waktu untuk memasukkan entropi yang terkandung di sana, yang mungkin akan benar-benar mencakup semuanya)

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

Masukkan kartu wi-fi ke dalam mode monitor, menerima paket senilai 30 detik yang diterima (termasuk data terenkripsi yang tidak terbaca dari jaringan tetangga), mengambil hash sha512 dari data paket, dan mengembalikan 1 jika huruf pertama hash adalah 0-7 . Berasumsi bahwa kartu wi-fi Anda adalah wlan0, dan saat ini Anda tidak memiliki mon0perangkat.

Jika tidak ada perangkat wi-fi terdekat, maka hasilnya akan dapat diprediksi, karena akan selalu sama setiap waktu.

Prosesor kompatibel modern 8086 yang diproduksi oleh Intel mengandung periferal yang mudah diakses yang menghasilkan keacakan yang tepat. Mengemudi periferal itu dilakukan dengan menggunakan rdrandinstruksi yang menghasilkan pola bit acak atau menetapkan flag carry jika periferal tidak tersedia atau keluar dari entropi.

Program singkat berikut untuk 80386 Linux memeriksa apakah perangkat tersedia dengan cpuidinstruksi dan mencoba untuk menghasilkan nomor acak. Jika salah satu perangkat atau nomor acak tidak tersedia, program akan berakhir dengan status 1. Jika nomor acak dapat dihasilkan, baik a 1atau a 0dicetak dan program berakhir dengan status keluar 0.

Simpan sebagai rand.sdan berkumpul dengan

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

Inilah seluruh majelis:

        .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

Dan dump dari 77 byte kode mesin yang dihasilkan:

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

pesta

Bertujuan untuk metode pengumpulan angka acak yang paling mahal dan tidak perlu. Waktu berapa lama untuk menelurkan emacs sejuta kali, kemudian gunakan trik Dennis 'untuk mengubah waktu yang diambil menjadi Boolean tunggal (membutuhkan sekitar 7 detik pada mesin saya).

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

Arduino Mega1280

sunting: versi terbaru yang kuat terhadap segala yang dicolokkan ke pin. Idenya bergantung pada fakta bahwa ATMega1280 menggunakan osilator internal yang terpisah untuk osilator pengawas. Saya cukup mengatur pengawas interupsi yang menetapkan bendera, memiliki penghitung berdasarkan jam sistem (pada Arduino ini adalah kristal eksternal 16MHz), dan memungkinkan clock jitter / varian melakukan pekerjaan.

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

Mengambil input video.

Anda dapat melihat tangkapan layar yang digunakan untuk menghitung angka acak.

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

Ukur kecepatan baca hard drive + waktu akses dari direktori yang sering diperbarui pada disk ini yang tata letaknya tidak dapat diprediksi.

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

membutuhkan:

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.

Pendekatan ini memiliki keuntungan karena tidak memodifikasi data apa pun pada sistem dan tidak memerlukan perl lebih dari yang primer.

Kulit

Diuji di Linux, tetapi mungkin U * IX Anda memang memiliki / proc / stat juga?

Ini hanya memulai satu proses tambahan, membaca hanya satu file tambahan (bahkan pada disk) dan pendeknya 37 karakter. Ini juga cukup cepat.

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

Orang mungkin berpikir bahwa ini ditentukan oleh semua status proses kernel dan userland, tetapi bukan itu masalahnya, karena / proc / stat juga termasuk waktu tunggu IO, waktu untuk menyelesaikan gangguan perangkat keras, waktu yang dihabiskan dalam tugas menganggur dan beberapa lainnya yang semuanya tergantung pada input perangkat keras eksternal.

Matlab

Solusi mikrofon:

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

Merekam 10 detik suara, menemukan jumlah sampel negatif dalam rekaman dan menghasilkan 0 jika angka ini genap dan 1 jika aneh. Jadi 0 dengan probabilitas 50%. Pendekatan ini berarti bahwa bahkan jumlah kecil noice, yang tidak dapat dihindari dalam rekaman diam, akan cukup untuk menghasilkan keluaran acak. Kode yang sedikit lebih panjang berikut ini mempercepat generator angka dengan menggunakan rekaman yang lebih pendek, dikompensasi dengan bitrate yang lebih tinggi, yang memberikan lebih banyak noise.

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

Dalam pengujian dalam kondisi tenang, saya menemukan bahwa dalam 100 kali menjalankan kode yang terakhir, kode output nol 51 kali. 100 berjalan dalam kondisi bising menghasilkan nol 40 kali.

Sunting: Terima kasih kepada Emil karena menunjukkan kesalahan pada kode asli :-)

Pesta

(Terima kasih, Dennis.)

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

Mengambil sedikit signifikan dari accelerometer komputer (membutuhkan hdapsmodul 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)

Ini pada dasarnya mengukur kebisingan 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.

Menggunakan sensor gerak 3DS. Sumbu Z accelerometer biasanya sekitar -1 (karena gravitasi), dan karena noise acak, kadang-kadang bisa di atas atau di bawah itu.

Inilah yang menggunakan mikrofon:

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

Pesta

Saya mengambil saran Soham sendiri (menggunakan top):

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

Sunting: Ini bekerja dengan cara yang sama seperti yang dilakukan Soham. Ini mengubah semua karakter non numerik di output atas menjadi '+' dan kemudian mengevalusi paritas string yang dihasilkan.

flag 'b' menjalankannya dalam mode batch sehingga melaporkan semua proses, bukan hanya screenful pertama dan 'n1' mengatakan untuk hanya menjalankan 1 iterasi atas.