vendor/rails/activesupport/lib/active_support/secure_random.rb

   1 begin
   2   require 'openssl'
   3 rescue LoadError
   4 end
   5
   6 begin
   7   require 'securerandom'
   8 rescue LoadError
   9 end
  10
  11 module ActiveSupport
  12   if defined?(::SecureRandom)
  13     # Use Ruby 1.9's SecureRandom library whenever possible.
  14     SecureRandom = ::SecureRandom # :nodoc:
  15   else
  16     # = Secure random number generator interface.
  17     #
  18     # This library is an interface for secure random number generator which is
  19     # suitable for generating session key in HTTP cookies, etc.
  20     #
  21     # It supports following secure random number generators.
  22     #
  23     # * openssl
  24     # * /dev/urandom
  25     # * Win32
  26     #
  27     # *Note*: This module is based on the SecureRandom library from Ruby 1.9,
  28     # revision 18786, August 23 2008. It's 100% interface-compatible with Ruby 1.9's
  29     # SecureRandom library.
  30     #
  31     # == Example
  32     #
  33     #  # random hexadecimal string.
  34     #  p SecureRandom.hex(10) #=> "52750b30ffbc7de3b362"
  35     #  p SecureRandom.hex(10) #=> "92b15d6c8dc4beb5f559"
  36     #  p SecureRandom.hex(11) #=> "6aca1b5c58e4863e6b81b8"
  37     #  p SecureRandom.hex(12) #=> "94b2fff3e7fd9b9c391a2306"
  38     #  p SecureRandom.hex(13) #=> "39b290146bea6ce975c37cfc23"
  39     #  ...
  40     #
  41     #  # random base64 string.
  42     #  p SecureRandom.base64(10) #=> "EcmTPZwWRAozdA=="
  43     #  p SecureRandom.base64(10) #=> "9b0nsevdwNuM/w=="
  44     #  p SecureRandom.base64(10) #=> "KO1nIU+p9DKxGg=="
  45     #  p SecureRandom.base64(11) #=> "l7XEiFja+8EKEtY="
  46     #  p SecureRandom.base64(12) #=> "7kJSM/MzBJI+75j8"
  47     #  p SecureRandom.base64(13) #=> "vKLJ0tXBHqQOuIcSIg=="
  48     #  ...
  49     #
  50     #  # random binary string.
  51     #  p SecureRandom.random_bytes(10) #=> "\016\t{\370g\310pbr\301"
  52     #  p SecureRandom.random_bytes(10) #=> "\323U\030TO\234\357\020\a\337"
  53     #  ...
  54     module SecureRandom
  55       # SecureRandom.random_bytes generates a random binary string.
  56       #
  57       # The argument n specifies the length of the result string.
  58       #
  59       # If n is not specified, 16 is assumed.
  60       # It may be larger in future.
  61       #
  62       # If secure random number generator is not available,
  63       # NotImplementedError is raised.
  64       def self.random_bytes(n=nil)
  65         n ||= 16
  66
  67         if defined? OpenSSL::Random
  68           return OpenSSL::Random.random_bytes(n)
  69         end
  70
  71         if !defined?(@has_urandom) || @has_urandom
  72           flags = File::RDONLY
  73           flags |= File::NONBLOCK if defined? File::NONBLOCK
  74           flags |= File::NOCTTY if defined? File::NOCTTY
  75           flags |= File::NOFOLLOW if defined? File::NOFOLLOW
  76           begin
  77             File.open("/dev/urandom", flags) {|f|
  78               unless f.stat.chardev?
  79                 raise Errno::ENOENT
  80               end
  81               @has_urandom = true
  82               ret = f.readpartial(n)
  83               if ret.length != n
  84                 raise NotImplementedError, "Unexpected partial read from random device"
  85               end
  86               return ret
  87             }
  88           rescue Errno::ENOENT
  89             @has_urandom = false
  90           end
  91         end
  92
  93         if !defined?(@has_win32)
  94           begin
  95             require 'Win32API'
  96
  97             crypt_acquire_context = Win32API.new("advapi32", "CryptAcquireContext", 'PPPII', 'L')
  98             @crypt_gen_random = Win32API.new("advapi32", "CryptGenRandom", 'LIP', 'L')
  99
 100             hProvStr = " " * 4
 101             prov_rsa_full = 1
 102             crypt_verifycontext = 0xF0000000
 103
 104             if crypt_acquire_context.call(hProvStr, nil, nil, prov_rsa_full, crypt_verifycontext) == 0
 105               raise SystemCallError, "CryptAcquireContext failed: #{lastWin32ErrorMessage}"
 106             end
 107             @hProv, = hProvStr.unpack('L')
 108
 109             @has_win32 = true
 110           rescue LoadError
 111             @has_win32 = false
 112           end
 113         end
 114         if @has_win32
 115           bytes = " " * n
 116           if @crypt_gen_random.call(@hProv, bytes.size, bytes) == 0
 117             raise SystemCallError, "CryptGenRandom failed: #{lastWin32ErrorMessage}"
 118           end
 119           return bytes
 120         end
 121
 122         raise NotImplementedError, "No random device"
 123       end
 124
 125       # SecureRandom.hex generates a random hex string.
 126       #
 127       # The argument n specifies the length of the random length.
 128       # The length of the result string is twice of n.
 129       #
 130       # If n is not specified, 16 is assumed.
 131       # It may be larger in future.
 132       #
 133       # If secure random number generator is not available,
 134       # NotImplementedError is raised.
 135       def self.hex(n=nil)
 136         random_bytes(n).unpack("H*")[0]
 137       end
 138
 139       # SecureRandom.base64 generates a random base64 string.
 140       #
 141       # The argument n specifies the length of the random length.
 142       # The length of the result string is about 4/3 of n.
 143       #
 144       # If n is not specified, 16 is assumed.
 145       # It may be larger in future.
 146       #
 147       # If secure random number generator is not available,
 148       # NotImplementedError is raised.
 149       def self.base64(n=nil)
 150         [random_bytes(n)].pack("m*").delete("\n")
 151       end
 152
 153       # SecureRandom.random_number generates a random number.
 154       #
 155       # If an positive integer is given as n,
 156       # SecureRandom.random_number returns an integer:
 157       # 0 <= SecureRandom.random_number(n) < n.
 158       #
 159       # If 0 is given or an argument is not given,
 160       # SecureRandom.random_number returns an float:
 161       # 0.0 <= SecureRandom.random_number() < 1.0.
 162       def self.random_number(n=0)
 163         if 0 < n
 164           hex = n.to_s(16)
 165           hex = '0' + hex if (hex.length & 1) == 1
 166           bin = [hex].pack("H*")
 167           mask = bin[0]
 168           mask |= mask >> 1
 169           mask |= mask >> 2
 170           mask |= mask >> 4
 171           begin
 172             rnd = SecureRandom.random_bytes(bin.length)
 173             rnd[0] = rnd[0] & mask
 174           end until rnd < bin
 175           rnd.unpack("H*")[0].hex
 176         else
 177           # assumption: Float::MANT_DIG <= 64
 178           i64 = SecureRandom.random_bytes(8).unpack("Q")[0]
 179           Math.ldexp(i64 >> (64-Float::MANT_DIG), -Float::MANT_DIG)
 180         end
 181       end
 182
 183       # Following code is based on David Garamond's GUID library for Ruby.
 184       def self.lastWin32ErrorMessage # :nodoc:
 185         get_last_error = Win32API.new("kernel32", "GetLastError", '', 'L')
 186         format_message = Win32API.new("kernel32", "FormatMessageA", 'LPLLPLPPPPPPPP', 'L')
 187         format_message_ignore_inserts = 0x00000200
 188         format_message_from_system    = 0x00001000
 189
 190         code = get_last_error.call
 191         msg = "\0" * 1024
 192         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)
 193         msg[0, len].tr("\r", '').chomp
 194       end
 195     end
 196   end
 197 end