super_random 2.0.210126 → 3.1.230114

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2480d12416526288677a0a9203d7e63ae666eb70b59fc792cc1a67bc2c35978a
-  data.tar.gz: 52d9c2e334770c1498f6afffc1bc967db38686a1d5098882f2b1290bbf5f1e60
+  metadata.gz: da086dfbbc9f424f5c8f7f35e38fc1be67633986797aea732af695c0ed4a8b67
+  data.tar.gz: ed4274a6e0b5b113c37c9adc4b20f9f96eacdeb5798e79235d023b6c5683f847
 SHA512:
-  metadata.gz: 3dcb0cb30658abd969e2930cc60bc9d0ff33bca7b4dc7ee0e418c43ba6f9815d52c7af4c21346320ff7941422e2ff8fbbb75a3e0453c9172edf3f05e5a0609ff
-  data.tar.gz: c0b24a58b9a236992b615a3bad666af0d5377575dabed3fd760cc3b2857904f9bec41ed3ee0f186c11820979c0bea50cf4f52de580ff6a576d3dc253a2644f43
+  metadata.gz: 78284485c7c649b00f1916d6a7b946f9673ab223f01f8b28bc227975da9154ccbc87bfb1af76eb36a0ad378c4c222c9135b239cad57b655f02d6860c146f9205
+  data.tar.gz: bab65a30405474b92539bfffdbd82fca278882c0be7d45f74d12c57d2c0f7ffc874cfd7e9ba0c0d1cc5b949d909adf298aa036b9974cf35c8dd248340f929be3

data/README.md

@@ -1,6 +1,6 @@
 # SuperRandom
 
-* [VERSION 2.0.210126](https://github.com/carlosjhr64/super_random/releases)
+* [VERSION 3.1.230114](https://github.com/carlosjhr64/super_random/releases)
 * [github](https://github.com/carlosjhr64/super_random)
 * [rubygems](https://rubygems.org/gems/super_random)
 
@@ -8,51 +8,82 @@
 
 You can't get more random than random, but you can try really, really, really hard.
 
-SuperRandom combines three online real random services to create a more perfect random byte.
+`SuperRandom` combines sources of entropy to generate super-random bytes!
 
 ## INSTALL:
 
     $ gem install super_random
 
 ## SYNOPSIS:
-
 ```ruby
 require 'super_random'
+SuperRandom::VERSION              #=> "3.1.230114"
+SuperRandom::DEFAULT_SOURCES      #~> www.random.org
 super_random = SuperRandom.new
+super_random.sources              #~> www.random.org
+super_random.bytes                #~> ^\[\d+(, \d+){63}\]$
+# The source_count attribute gives the number of sources successfully used.
+super_random.source_count         #=> 1
+# The byte_count attribute gives the total bytes digested from sources.
+super_random.byte_count           #=> 210
+super_random.hexadecimal          #~> ^\h{128}$
+super_random.random_number(100.0) #~> ^\d{1,2}\.\d+$
+super_random.random_number(100)   #~> ^\d{1,2}$
+# Because of a 1 minute rate limit, subsequent source counts are zero:
+super_random.source_count         #=> 0
+super_random.byte_count           #=> 0
+# Snapshots from your webcam can be a good entropy source:
+super_random = SuperRandom.new('/var/lib/motion/lastsnap.jpg')
+super_random.sources              #=> ["/var/lib/motion/lastsnap.jpg"]
+# Dice!
+d6 = super_random.dice(6)
+d6.roll                           #~> ^[123456]$
+```
+## METHODOLOGY:
 
-super_random.bytes(32) #~> ^\[\d+(, \d+){31}\]$
-# Example:
-# [142, 36, 107, 199, 1, 222, 69, 238, 130, 159, 236, 201, 199,
-#   33, 237, 166, 189, 166, 95, 246, 111, 103, 113, 126, 27, 31,
-#  244, 215, 200, 60, 255, 184]
+`SuperRandom` uses `OpenUri` to read your sources, which
+can be http, https, or ftp URLs.
+`Digest::SHA2.new(512)` is used to digest your sources.
+Finally, `SecureRandom.bytes` are fed to the digest as a fail safe.
+This generates the final 64 random bytes.
 
-sleep 1 # rate limit to be nice
-super_random.hexadecimal(32) #~> ^\h{64}$
-# Example:
-# "3e0dffe42c08b849dc3c1290e7aa87dff4ad3037b29694136786a4db1e3efab8"
+## SOURCES:
 
-sleep 1
-super_random.random_number(100.0) #~> ^\d{1,2}\.\d+$
-# Example:
-# 16.882225652425537
-
-sleep 1
-super_random.random_number(100) #~> ^\d{1,2}$
-# Example:
-# 85
-
-# The "services" attribute gives the number of online services used.
-# It's possible for a service to fail.
-# Ultimately, SuperRandom uses SecureRandom as a failsafe.
-super_random.services   #=> 3
-super_random.randomness #=> 3.0
-```
+I could only find one good source expressly for this purpose, `www.random.org`.
+Another good one is `qrng.anu.edu.au`, but you'll need an API key.
+Consider using:
 
+* Snapshots from your webcam
+* List of market spot prices
+* Weather forecasts
+* News or micro-logging feeds
+
+Be very nice about your calls,
+specially when you're not using the source as intended.
+`SuperRandom` enforces a one minute rate limit in the use of sources.
+Here are ways to set custom sources:
+```ruby
+# Sources specified in the constructor: 
+super_random = SuperRandom.new('/var/lib/motion/lastsnap.jpg', 'https://wttr.in')
+super_random.sources
+#=> ["/var/lib/motion/lastsnap.jpg", "https://wttr.in"]
+
+# Sources appended on the instance: 
+super_random.sources.append 'https://text.npr.org'
+super_random.sources
+#=> ["/var/lib/motion/lastsnap.jpg", "https://wttr.in", "https://text.npr.org"]
+
+# Sources appended to the DEFAULT_SOURCES
+SuperRandom::DEFAULT_SOURCES.append 'https://coinmarketcap.com'
+super_random = SuperRandom.new
+super_random.sources
+#~> random.org.*coinmarketcap.com
+```
 ## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2021 carlosjhr64
+Copyright (c) 2023 carlosjhr64
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/super_random.rb

@@ -1,15 +1,135 @@
-# Standard Libraries
 require 'timeout'
 require 'securerandom'
-require 'net/http'
-require 'json'
+require 'open-uri'
+require 'digest'
+# Requires:
+#`ruby`
 
 class SuperRandom
-  VERSION = '2.0.210126'
-  # This Gem
-  require 'super_random/services'
-  require 'super_random/generator'
-end
+  VERSION = '3.1.230114'
+  DEFAULT_SOURCES = [
+    'https://www.random.org/strings/?num=10&len=20&digits=on&upperalpha=on&loweralpha=on&unique=on&format=plain&rnd=new',
+  ]
+  MUTEX = Mutex.new
+  DIV = 128.times.inject(''){|h,_|h<<'f'}.to_i(16)
+  RATE_LIMIT = 60 # One minute, be nice!
+  @@LAST_TIME = Time.now.to_i - RATE_LIMIT - 1
 
-# Requires:
-#`ruby`
+  attr_accessor :first_timeout, :second_timeout, :nevermind
+  attr_reader   :sources, :source_count, :byte_count
+  def initialize(*sources)
+    @sources = sources.empty? ? DEFAULT_SOURCES.dup : sources
+    @byte_count,@source_count = 0,0
+    @first_timeout,@second_timeout,@nevermind = 3,6,true
+  end
+
+  # Returns 64 random bytes(at least from SecureRandom's)
+  def bytes
+    @byte_count,@source_count = 0,0
+    _do_updates if Time.now.to_i - @@LAST_TIME > RATE_LIMIT
+    _get_bytes
+  end
+
+  def hexadecimal
+    bytes.map{_1.to_s(16).rjust(2,'0')}.join
+  end
+
+  def integer
+    hexadecimal.to_i(16)
+  end
+
+  def float
+    Rational(integer, DIV).to_f
+  end
+
+  def float2
+    # An alternate way to generate a float but...
+    hex = hexadecimal
+    x = hex[0...64].to_i(16)
+    y = hex[64..128].to_i(16)
+    # ...what distribution is this?
+    Rational(x,y).to_f
+  rescue ZeroDivisionError
+    # Fat chance!
+    return 0 if x == 0
+    1.0/0.0
+  end
+
+  def random_number(scale=1.0)
+    case scale
+    when Float
+      return scale * float
+    when Integer
+      return ((integer + SecureRandom.random_number(scale)) % scale)
+    end
+    raise "rand(scale Integer|Float)"
+  end
+  alias rand random_number
+
+  class Dice
+    private def set_big
+      @big = @rng.integer + SecureRandom.random_number(@sides)
+    end
+    def initialize(sides, minimum:1, rng:SuperRandom.new)
+      @sides,@minimum,@rng = sides,minimum,rng
+      set_big
+    end
+    def roll
+      @big,roll = @big.divmod(@sides)
+      return roll+@minimum
+    ensure
+      set_big unless @big>0
+    end
+  end
+  def dice(sides, minimum:1)
+    Dice.new(sides, minimum:minimum, rng:self)
+  end
+
+  private
+
+  SHASUM = Digest::SHA2.new(512)
+  def _get_bytes
+    MUTEX.synchronize do
+      SHASUM.update SecureRandom.bytes(64)
+      SHASUM.digest.chars.map{_1.ord}
+    end
+  ensure
+    MUTEX.synchronize{SHASUM.update SecureRandom.bytes(64)}
+  end
+
+  def _update_with(source)
+    URI.open(source) do |tmp|
+      MUTEX.synchronize do
+        tmp.each_line do |line|
+          SHASUM.update line
+          @byte_count += line.bytesize
+        end
+        @source_count += 1
+      end
+    end
+  rescue
+    $stderr.puts $!
+  end
+
+  def _do_updates
+    @@LAST_TIME = Time.now.to_i
+    threads = @sources.inject([]){|t,s|t.push Thread.new{_update_with s}}
+    begin
+      # Initially, would like to get them all.
+      Timeout.timeout(@first_timeout){threads.each{_1.join}}
+    rescue Timeout::Error
+      begin
+        Timeout.timeout(@second_timeout) do
+          # But at this point,
+          # would like to get at least one.
+          while @services<1 and threads.any?{_1.alive?}
+            Thread.pass
+          end
+        end
+      rescue Timeout::Error
+        Mutex.sychronize{threads.each{_1.exit}} # Exit each thread
+        raise $! unless @nevermind # Go on if never-minding
+      end
+    end
+  end
+end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: super_random
 version: !ruby/object:Gem::Version
-  version: 2.0.210126
+  version: 3.1.230114
 platform: ruby
 authors:
-- carlosjhr64
-autorequire:
+- CarlosJHR64
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-26 00:00:00.000000000 Z
+date: 2023-01-14 00:00:00.000000000 Z
 dependencies: []
 description: |
   You can't get more random than random, but you can try really, really, really hard.
 
-  SuperRandom combines three online real random services to create a more perfect random byte.
+  `SuperRandom` combines sources of entropy to generate super-random bytes!
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
@@ -21,13 +21,11 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/super_random.rb
-- lib/super_random/generator.rb
-- lib/super_random/services.rb
 homepage: https://github.com/carlosjhr64/super_random
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -42,9 +40,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-linux]'
-rubygems_version: 3.2.3
-signing_key:
+- 'ruby: ruby 3.2.0 (2022-12-25 revision a528908271) [aarch64-linux]'
+rubygems_version: 3.4.3
+signing_key: 
 specification_version: 4
 summary: You can't get more random than random, but you can try really, really, really
   hard.

data/lib/super_random/generator.rb

@@ -1,99 +0,0 @@
-class SuperRandom
-  DEFAULT_BYTES = 32
-
-  attr_accessor :first_timeout, :second_timeout, :nevermind
-  attr_reader :randomness, :services
-
-  def initialize
-    @first_timeout = 3
-    @second_timeout = 6
-    @nevermind = true
-    @randomness = 0.0
-    @services = 0
-  end
-
-  def bytes(n=DEFAULT_BYTES)
-    @randomness = 0.0
-    @services = 0
-
-    m = SuperRandom.services
-    a = Array.new m.length
-    t = Array.new m.length
-    m.each_with_index do |k,i|
-      t[i] = Thread.new{ a[i] = SuperRandom.send(k, n) }
-    end
-
-    begin
-      Timeout.timeout(@first_timeout) do
-        # Initially, would like to get them all.
-        t.each{_1.join}
-      end
-    rescue Timeout::Error
-      begin
-        Timeout.timeout(@second_timeout) do
-          # But at this point,
-          # would like to get at least one.
-          while a.all?{_1.nil?} and t.any?{_1.alive?}
-            Thread.pass
-          end
-        end
-      rescue Timeout::Error
-        # If we don't care that we got nothing, go on.
-        raise $! unless @nevermind
-      end
-    end
-
-    r = Array.new n
-    n.times{|i| r[i] = SecureRandom.random_number(256)}
-
-    a.each do |b|
-      next if b.nil?
-      l = b.length
-      @randomness += l.to_f/n.to_f
-      @services += 1
-      n.times{|i|r[i]=(r[i]+b[i%l])%256}
-    end
-
-    return r
-  end
-
-  def hexadecimal(n=DEFAULT_BYTES)
-    bytes(n).map{|i|i.to_s(16).rjust(2,'0')}.join
-  end
-
-  def random_number(scale=1.0, minbytes=6, maxbytes=[minbytes,DEFAULT_BYTES].max)
-    case scale
-    when Float
-      div = minbytes.times.inject(''){|s,i| s+'FF'}.to_i(16)
-      den = hexadecimal(minbytes).to_i(16)
-      return  scale * den.to_f / div.to_f
-    when Integer
-      n = n0 = Math.log(scale, 256).ceil
-      e = e0 = 256**n
-      r = r0 = e0 % scale
-      while r > 0
-        n0 += 1
-        e0 *= 256
-        r0 = e0 % scale
-        if r0 <= r
-          # break if repeating pattern with big enough integer
-          break if r0 == r and n0 > minbytes
-          r,n,e = r0,n0,e0
-        end
-        break if n0 >= maxbytes
-      end
-      max = (e/scale)*scale
-      loop do
-        number = hexadecimal(n).to_i(16)
-        return number % scale if number < max
-        # On a relatively small chance that we're above max...
-        if @nevermind
-          warn "using SecureRandom.random_number(#{scale})"
-          return SecureRandom.random_number(scale)
-        end
-      end
-    end
-    raise "rand(scale Integer|Float)"
-  end
-  alias rand random_number
-end

data/lib/super_random/services.rb

@@ -1,45 +0,0 @@
-class SuperRandom
-  def self.services
-    [:quantum, :atmospheric, :hotbits]
-  end
-
-  # https://qrng.anu.edu.au/
-  # https://qrng.anu.edu.au/contact/api-documentation/
-  def self.quantum(n)
-    s = Net::HTTP.get(URI(
-      "https://qrng.anu.edu.au/API/jsonI.php?length=#{n}&type=uint8"))
-    a = JSON.parse(s)['data']
-    raise unless a.is_a?(Array) and a.length==n
-    raise unless a.all?{|i| i.is_a?(Integer) and i.between?(0,255)}
-    return a
-  rescue StandardError
-    warn "quantum (qrng.anu.edu.au) failed."
-    return nil
-  end
-
-  # https://www.random.org/
-  # https://www.random.org/integers/
-  def self.atmospheric(n)
-    s = Net::HTTP.get(URI(
-      "https://www.random.org/integers/?num=#{n}&min=0&max=255&col=1&base=10&format=plain&rnd=new"))
-    a = s.strip.split(/\s+/).map{|j|j.to_i}
-    raise unless a.length==n
-    raise unless a.all?{|i| i.between?(0,255)}
-    return a
-  rescue StandardError
-    warn "atmospheric (www.random.org) failed."
-    return nil
-  end
-
-  # https://www.fourmilab.ch/hotbits/
-  def self.hotbits(n, k='Pseudorandom')
-    s = Net::HTTP.get(URI(
-      "https://www.fourmilab.ch/cgi-bin/Hotbits.api?nbytes=#{n}&fmt=bin&apikey=#{k}"))
-    a = s.bytes
-    raise unless a.length==n
-    return a
-  rescue StandardError
-    warn "hotbits (www.fourmilab.ch) failed."
-    return nil
-  end
-end