Module: SecureRandom

Defined in:
lib/ext/uuidtools-2.1.1/lib/compat/securerandom.rb

Class Method Summary collapse

Class Method Details

.base64(n = nil) ⇒ Object

SecureRandom.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.



145
146
147
 
# File 'lib/ext/uuidtools-2.1.1/lib/compat/securerandom.rb', line 145

def self.base64(n=nil)
  [random_bytes(n)].pack("m*").delete("\n")
end

.hex(n = nil) ⇒ Object

SecureRandom.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.



131
132
133
 
# File 'lib/ext/uuidtools-2.1.1/lib/compat/securerandom.rb', line 131

def self.hex(n=nil)
  random_bytes(n).unpack("H*")[0]
end

.lastWin32ErrorMessage ⇒ Object

Following code is based on David Garamond’s GUID library for Ruby.



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/ext/uuidtools-2.1.1/lib/compat/securerandom.rb', line 183

def self.lastWin32ErrorMessage # :nodoc:
  get_last_error = Win32API.new(
    "kernel32", "GetLastError", '', 'L'
  )
  format_message = Win32API.new(
    "kernel32", "FormatMessageA", 'LPLLPLPPPPPPPP', 'L'
  )
  format_message_ignore_inserts = 0x00000200
  format_message_from_system    = 0x00001000

  code = get_last_error.call
  msg = "\0" * 1024
  len = format_message.call(
    format_message_ignore_inserts + format_message_from_system,
    0, code, 0, msg, 1024, nil, nil, nil, nil, nil, nil, nil, nil
  )
  msg[0, len].tr("\r", '').chomp
end

.random_bytes(n = nil) ⇒ Object

SecureRandom.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.

Raises:

  • (NotImplementedError) 


52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/ext/uuidtools-2.1.1/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) ⇒ Object

SecureRandom.random_number generates a random number.

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

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



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/ext/uuidtools-2.1.1/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