module SecureRandom

base64(n=nil) click to toggle source

::base64 generates a random base64 string.

The argument n specifies the length of the random length. The length of the result string is about 4/3 of n.

If n is not specified, 16 is assumed. It may be larger in future.

If secure random number generator is not available, NotImplementedError is raised.

# File lib/compat/securerandom.rb, line 145
def self.base64(n=nil)
  [random_bytes(n)].pack("m*").delete("\n")
end

hex(n=nil) click to toggle source

::hex generates a random hex string.

The argument n specifies the length of the random length. The length of the result string is twice of n.

If n is not specified, 16 is assumed. It may be larger in future.

If secure random number generator is not available, NotImplementedError is raised.

# File lib/compat/securerandom.rb, line 131
def self.hex(n=nil)
  random_bytes(n).unpack("H*")[0]
end

random_bytes(n=nil) click to toggle source

::random_bytes generates a random binary string.

The argument n specifies the length of the result string.

If n is not specified, 16 is assumed. It may be larger in future.

If secure random number generator is not available, NotImplementedError is raised.

# File lib/compat/securerandom.rb, line 52
def self.random_bytes(n=nil)
  n ||= 16

  if defined? OpenSSL::Random
    return OpenSSL::Random.random_bytes(n)
  end

  if !defined?(@has_urandom) || @has_urandom
    flags = File::RDONLY
    flags |= File::NONBLOCK if defined? File::NONBLOCK
    flags |= File::NOCTTY if defined? File::NOCTTY
    flags |= File::NOFOLLOW if defined? File::NOFOLLOW
    begin
      File.open("/dev/urandom", flags) {|f|
        unless f.stat.chardev?
          raise Errno::ENOENT
        end
        @has_urandom = true
        ret = f.readpartial(n)
        if ret.length != n
          raise NotImplementedError,
            "Unexpected partial read from random device"
        end
        return ret
      }
    rescue Errno::ENOENT
      @has_urandom = false
    end
  end

  if !defined?(@has_win32)
    begin
      require 'Win32API'

      crypt_acquire_context = Win32API.new(
        "advapi32", "CryptAcquireContext", 'PPPII', 'L'
      )
      @crypt_gen_random = Win32API.new(
        "advapi32", "CryptGenRandom", 'LIP', 'L'
      )

      hProvStr = " " * 4
      prov_rsa_full = 1
      crypt_verifycontext = 0xF0000000

      if crypt_acquire_context.call(
          hProvStr, nil, nil, prov_rsa_full, crypt_verifycontext) == 0
        raise SystemCallError,
          "CryptAcquireContext failed: #{lastWin32ErrorMessage}"
      end
      @hProv, = hProvStr.unpack('L')

      @has_win32 = true
    rescue LoadError
      @has_win32 = false
    end
  end
  if @has_win32
    bytes = " " * n
    if @crypt_gen_random.call(@hProv, bytes.size, bytes) == 0
      raise SystemCallError,
        "CryptGenRandom failed: #{lastWin32ErrorMessage}"
    end
    return bytes
  end

  raise NotImplementedError, "No random device"
end

random_number(n=0) click to toggle source

::random_number generates a random number.

If an positive integer is given as n, ::random_number returns an integer: 0 <= ::random_number < n.

If 0 is given or an argument is not given, ::random_number returns an float: 0.0 <= ::random_number < 1.0.

# File lib/compat/securerandom.rb, line 158
def self.random_number(n=0)
  if 0 < n
    hex = n.to_s(16)
    hex = '0' + hex if (hex.length & 1) == 1
    bin = [hex].pack("H*")
    first = bin[0..0]
    mask = first.respond_to?(:ord) ? first.ord : first.sum(8)
    mask |= mask >> 1
    mask |= mask >> 2
    mask |= mask >> 4
    begin
      rnd = SecureRandom.random_bytes(bin.length)
      first = rnd[0..0]
      ordinal = first.respond_to?(:ord) ? first.ord : first.sum(8)
      rnd[0..0] = (ordinal & mask).chr
    end until rnd < bin
    rnd.unpack("H*")[0].hex
  else
    # assumption: Float::MANT_DIG <= 64
    i64 = SecureRandom.random_bytes(8).unpack("Q")[0]
    Math.ldexp(i64 >> (64-Float::MANT_DIG), -Float::MANT_DIG)
  end
end

Public Class Methods