Module: Random::Formatter

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Extended In: ::SecureRandom
Defined in:	lib/securerandom.rb

Constant Summary

ALPHANUMERIC =
# File 'lib/securerandom.rb', line 275
```
[*'A'..'Z', *'a'..'z', *'0'..'9']
```

Instance Method Summary

#alphanumeric(n = nil)

SecureRandom.alphanumeric generates a random alphanumeric string.
#base64(n = nil)

SecureRandom.base64 generates a random base64 string.
#hex(n = nil)

SecureRandom.hex generates a random hexadecimal string.
#random_bytes(n = nil)

SecureRandom.random_bytes generates a random binary string.
#urlsafe_base64(n = nil, padding = false)

SecureRandom.urlsafe_base64 generates a random URL-safe base64 string.
#uuid

SecureRandom.uuid generates a random v4 UUID (Universally Unique IDentifier).
#choose(source, n) private

SecureRandom.choose generates a string that randomly draws from a source array of characters.
#gen_random(n) private

Instance Method Details

#alphanumeric(n = nil)

SecureRandom.alphanumeric generates a random alphanumeric string.

The argument n specifies the length, in characters, of the alphanumeric string to be generated.

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

The result may contain A-Z, a-z and 0-9.

p SecureRandom.alphanumeric #=> "2BuBuLf3WfSKyQbR"
p SecureRandom.alphanumeric(10) #=> "i6K93NdqiH"

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

[ GitHub ]

# File 'lib/securerandom.rb', line 291


def alphanumeric(n=nil)
  n = 16 if n.nil?
  choose(ALPHANUMERIC, n)
end

#base64(n = nil)

SecureRandom.base64 generates a random base64 string.

The argument n specifies the length, in bytes, of the random number to be generated. The length of the result string is about 4/3 of n.

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

The result may contain A-Z, a-z, 0-9, “+”, “/” and “=”.

p SecureRandom.base64 #=> "/2BuBuLf3+WfSKyQbRcc/A=="
p SecureRandom.base64 #=> "6BbW0pxO0YENxn38HMUbcQ=="

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

See RFC 3548 for the definition of base64.

[ GitHub ]

# File 'lib/securerandom.rb', line 170


def base64(n=nil)
  [random_bytes(n)].pack("m0")
end

#choose(source, n) (private)

SecureRandom.choose generates a string that randomly draws from a source array of characters.

The argument source specifies the array of characters from which to generate the string. The argument n specifies the length, in characters, of the string to be generated.

The result may contain whatever characters are in the source array.

p SecureRandom.choose([*'l'..'r'], 16) #=> "lmrqpoonmmlqlron"
p SecureRandom.choose([*'0'..'9'], 5) #=> "27309"

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

[ GitHub ]

# File 'lib/securerandom.rb', line 246


private def choose(source, n)
  size = source.size
  m = 1
  limit = size
  while limit * size <= 0x100000000
    limit *= size
    m += 1
  end
  result = ''.dup
  while m <= n
    rs = random_number(limit)
    is = rs.digits(size)
    (m-is.length).times { is << 0 }
    result << source.values_at(*is).join('')
    n -= m
  end
  if 0 < n
    rs = random_number(limit)
    is = rs.digits(size)
    if is.length < n
      (n-is.length).times { is << 0 }
    else
      is.pop while n < is.length
    end
    result.concat source.values_at(*is).join('')
  end
  result
end

#gen_random(n) (private)

[ GitHub ]

# File 'lib/securerandom.rb', line 227


private def gen_random(n)
  self.bytes(n)
end

#hex(n = nil)

SecureRandom.hex generates a random hexadecimal string.

The argument n specifies the length, in bytes, of the random number to be generated. The length of the resulting hexadecimal string is twice of n.

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

The result may contain 0-9 and a-f.

p SecureRandom.hex #=> "eb693ec8252cd630102fd0d0fb7c3485"
p SecureRandom.hex #=> "91dc3bfb4de5b11d029d376634589b61"

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

[ GitHub ]

# File 'lib/securerandom.rb', line 149


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

#random_bytes(n = nil)

SecureRandom.random_bytes generates a random binary string.

The argument n specifies the length of the result string.

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

The result may contain any byte: “x00” - “xff”.

p SecureRandom.random_bytes #=> "\xD8\\\xE0\xF4\r\xB2\xFC*WM\xFF\x83\x18\xF45\xB6"
p SecureRandom.random_bytes #=> "m\xDC\xFC/\a\x00Uf\xB2\xB2P\xBD\xFF6S\x97"

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

[ GitHub ]

# File 'lib/securerandom.rb', line 129


def random_bytes(n=nil)
  n = n ? n.to_int : 16
  gen_random(n)
end

#urlsafe_base64(n = nil, padding = false)

SecureRandom.urlsafe_base64 generates a random URL-safe base64 string.

The argument n specifies the length, in bytes, of the random number to be generated. The length of the result string is about 4/3 of n.

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

The boolean argument padding specifies the padding. If it is false or nil, padding is not generated. Otherwise padding is generated. By default, padding is not generated because “=” may be used as a URL delimiter.

The result may contain A-Z, a-z, 0-9, “-” and “_”. “=” is also used if padding is true.

p SecureRandom.urlsafe_base64 #=> "b4GOKm4pOYU_-BOXcrUGDg"
p SecureRandom.urlsafe_base64 #=> "UZLdOkzop70Ddx-IJR0ABg"

p SecureRandom.urlsafe_base64(nil, true) #=> "i0XQ-7gglIsHGV2_BNPrdQ=="
p SecureRandom.urlsafe_base64(nil, true) #=> "-M8rLhr7JEpJlqFGUMmOxg=="

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

See RFC 3548 for the definition of URL-safe base64.

[ GitHub ]

# File 'lib/securerandom.rb', line 200


def urlsafe_base64(n=nil, padding=false)
  s = [random_bytes(n)].pack("m0")
  s.tr!("+/", "-_")
  s.delete!("=") unless padding
  s
end

#uuid

SecureRandom.uuid generates a random v4 UUID (Universally Unique IDentifier).

p SecureRandom.uuid #=> "2d931510-d99f-494a-8c67-87feb05e1594"
p SecureRandom.uuid #=> "bad85eb9-0713-4da7-8d36-07a8e4b00eab"
p SecureRandom.uuid #=> "62936e70-1815-439b-bf89-8492855a7e6b"

The version 4 UUID is purely random (except the version). It doesn't contain meaningful information such as MAC addresses, timestamps, etc.

The result contains 122 random bits (15.25 random bytes).

See RFC 4122 for details of UUID.

[ GitHub ]

# File 'lib/securerandom.rb', line 220


def uuid
  ary = random_bytes(16).unpack("NnnnnN")
  ary[2] = (ary[2] & 0x0fff) | 0x4000
  ary[3] = (ary[3] & 0x3fff) | 0x8000
  "%08x-%04x-%04x-%04x-%04x%08x" % ary
end