Gecko [ www.corporacionhdm.com.pe ]

Name	Size	Permission	Date
cgi	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
digest	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
drb	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
fiddle	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
io	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
irb	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
json	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
matrix	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
net	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
openssl	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
optparse	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
psych	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
racc	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
rbconfig	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
rdoc	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
rexml	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
rinda	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
ripper	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
rss	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
rubygems	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
shell	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
syslog	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
unicode_normalize	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
uri	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
webrick	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
x86_64-linux	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
xmlrpc	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
yaml	[ DIR ]	drwxr-xr-x	2024-03-03 22:43
English.rb	6.45 KB	-rw-r--r--	2015-12-16 05:07
abbrev.rb	3.49 KB	-rw-r--r--	2015-12-16 05:07
base64.rb	3.31 KB	-rw-r--r--	2015-12-16 05:07
benchmark.rb	17.9 KB	-rw-r--r--	2015-12-23 03:43
cgi.rb	9.8 KB	-rw-r--r--	2015-12-16 05:07
cmath.rb	9.48 KB	-rw-r--r--	2015-12-16 05:07
csv.rb	82.15 KB	-rw-r--r--	2015-12-19 05:23
date.rb	1011 B	-rw-r--r--	2023-07-26 14:39
debug.rb	29.97 KB	-rw-r--r--	2015-12-16 05:07
delegate.rb	10.29 KB	-rw-r--r--	2015-12-16 05:07
digest.rb	2.82 KB	-rw-r--r--	2023-07-26 14:39
drb.rb	50 B	-rw-r--r--	2015-12-16 05:07
e2mmap.rb	3.8 KB	-rw-r--r--	2015-12-16 05:07
erb.rb	26.45 KB	-rw-r--r--	2017-06-30 11:24
expect.rb	2.17 KB	-rw-r--r--	2023-07-26 14:39
fiddle.rb	1.68 KB	-rw-r--r--	2023-07-26 14:39
fileutils.rb	47.47 KB	-rw-r--r--	2017-03-27 16:57
find.rb	2.51 KB	-rw-r--r--	2015-12-16 05:07
forwardable.rb	7.97 KB	-rw-r--r--	2018-03-18 15:04
getoptlong.rb	15.41 KB	-rw-r--r--	2015-12-23 03:43
ipaddr.rb	17.08 KB	-rw-r--r--	2015-12-16 05:07
irb.rb	20.06 KB	-rw-r--r--	2016-03-29 06:10
json.rb	1.77 KB	-rw-r--r--	2023-07-26 14:39
kconv.rb	5.77 KB	-rw-r--r--	2023-07-26 14:39
logger.rb	21.93 KB	-rw-r--r--	2016-10-17 17:38
mathn.rb	3.87 KB	-rw-r--r--	2015-12-16 05:07
matrix.rb	53.37 KB	-rw-r--r--	2015-12-16 05:07
mkmf.rb	83.79 KB	-rw-r--r--	2023-07-26 14:36
monitor.rb	7.01 KB	-rw-r--r--	2015-12-16 05:07
mutex_m.rb	2.03 KB	-rw-r--r--	2015-12-16 05:07
observer.rb	5.83 KB	-rw-r--r--	2015-12-16 05:07
open-uri.rb	24.61 KB	-rw-r--r--	2015-11-11 03:48
open3.rb	20.67 KB	-rw-r--r--	2015-11-14 07:43
openssl.rb	445 B	-rw-r--r--	2023-07-26 14:39
optionparser.rb	59 B	-rw-r--r--	2015-12-16 05:07
optparse.rb	56.91 KB	-rw-r--r--	2017-08-09 07:56
ostruct.rb	9.95 KB	-rw-r--r--	2018-01-31 11:05
pathname.rb	16.08 KB	-rw-r--r--	2023-07-26 14:39
pp.rb	14.2 KB	-rw-r--r--	2015-11-10 11:48
prettyprint.rb	15.89 KB	-rw-r--r--	2015-11-10 11:48
prime.rb	12.35 KB	-rw-r--r--	2015-12-16 05:07
profile.rb	236 B	-rw-r--r--	2015-12-16 05:07
profiler.rb	4.54 KB	-rw-r--r--	2015-12-16 05:07
pstore.rb	14.58 KB	-rw-r--r--	2015-12-23 03:43
psych.rb	15.29 KB	-rw-r--r--	2023-07-26 14:39
psych_jars.rb	175 B	-rw-r--r--	2023-07-26 14:39
rdoc.rb	5.07 KB	-rw-r--r--	2015-12-22 12:08
resolv-replace.rb	1.76 KB	-rw-r--r--	2015-11-14 08:25
resolv.rb	73.52 KB	-rw-r--r--	2018-03-28 06:03
ripper.rb	2.56 KB	-rw-r--r--	2023-07-26 14:39
rss.rb	2.87 KB	-rw-r--r--	2015-12-16 05:07
rubygems.rb	32.24 KB	-rw-r--r--	2018-02-16 16:21
scanf.rb	23.56 KB	-rw-r--r--	2015-12-16 05:07
securerandom.rb	7.49 KB	-rw-r--r--	2016-04-22 15:30
set.rb	19.67 KB	-rw-r--r--	2015-11-16 07:41
shell.rb	11.33 KB	-rw-r--r--	2015-12-16 05:07
shellwords.rb	6.28 KB	-rw-r--r--	2015-12-16 09:25
singleton.rb	4.05 KB	-rw-r--r--	2015-12-16 05:07
socket.rb	43.49 KB	-rw-r--r--	2023-07-26 14:39
sync.rb	7.29 KB	-rw-r--r--	2015-12-16 05:07
tempfile.rb	10.87 KB	-rw-r--r--	2017-03-27 14:47
thwait.rb	3.34 KB	-rw-r--r--	2015-12-16 05:07
time.rb	22.28 KB	-rw-r--r--	2015-11-14 12:45
timeout.rb	3.68 KB	-rw-r--r--	2015-12-18 15:46
tmpdir.rb	4.17 KB	-rw-r--r--	2018-03-28 10:29
tracer.rb	6.43 KB	-rw-r--r--	2015-12-16 05:07
tsort.rb	14.3 KB	-rw-r--r--	2015-11-14 08:46
ubygems.rb	299 B	-rw-r--r--	2015-12-16 05:07
un.rb	8.87 KB	-rw-r--r--	2015-12-16 05:07
unicode_normalize.rb	3.19 KB	-rw-r--r--	2015-12-16 05:07
uri.rb	3.1 KB	-rw-r--r--	2015-12-16 05:07
weakref.rb	2.95 KB	-rw-r--r--	2015-12-16 05:07
webrick.rb	6.72 KB	-rw-r--r--	2015-12-23 03:43
xmlrpc.rb	8.93 KB	-rw-r--r--	2015-12-23 03:43
yaml.rb	1.73 KB	-rw-r--r--	2015-12-16 05:07

Rename

# -*- coding: us-ascii -*-
# frozen_string_literal: true
begin
  require 'openssl'
rescue LoadError
end

# == Secure random number generator interface.
#
# This library is an interface to secure random number generators which are
# suitable for generating session keys in HTTP cookies, etc.
#
# You can use this library in your application by requiring it:
#
#   require 'securerandom'
#
# It supports the following secure random number generators:
#
# * openssl
# * /dev/urandom
# * Win32
#
# === Examples
#
# Generate random hexadecimal strings:
#
#   require 'securerandom'
#
#   p SecureRandom.hex(10) #=> "52750b30ffbc7de3b362"
#   p SecureRandom.hex(10) #=> "92b15d6c8dc4beb5f559"
#   p SecureRandom.hex(13) #=> "39b290146bea6ce975c37cfc23"
#
# Generate random base64 strings:
#
#   p SecureRandom.base64(10) #=> "EcmTPZwWRAozdA=="
#   p SecureRandom.base64(10) #=> "KO1nIU+p9DKxGg=="
#   p SecureRandom.base64(12) #=> "7kJSM/MzBJI+75j8"
#
# Generate random binary strings:
#
#   p SecureRandom.random_bytes(10) #=> "\016\t{\370g\310pbr\301"
#   p SecureRandom.random_bytes(10) #=> "\323U\030TO\234\357\020\a\337"
#
# Generate UUIDs:
#
#   p SecureRandom.uuid #=> "2d931510-d99f-494a-8c67-87feb05e1594"
#   p SecureRandom.uuid #=> "bad85eb9-0713-4da7-8d36-07a8e4b00eab"
#

module SecureRandom
  if defined?(OpenSSL::Random) && /mswin|mingw/ !~ RUBY_PLATFORM
    def self.gen_random(n)
      @pid = 0 unless defined?(@pid)
      pid = $$
      unless @pid == pid
        now = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
        ary = [now, @pid, pid]
        OpenSSL::Random.random_add(ary.join("").to_s, 0.0)
        seed = Random.raw_seed(16)
        if (seed)
          OpenSSL::Random.random_add(seed, 16)
        end
        @pid = pid
      end
      return OpenSSL::Random.random_bytes(n)
    end
  else
    def self.gen_random(n)
      ret = Random.raw_seed(n)
      unless ret
        raise NotImplementedError, "No random device"
      end
      unless ret.length == n
        raise NotImplementedError, "Unexpected partial read from random device: only #{ret.length} for #{n} bytes"
      end
      ret
    end
  end
end

module Random::Formatter

# 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.
  def random_bytes(n=nil)
    n = n ? n.to_int : 16
    gen_random(n)
  end

# 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.
  def hex(n=nil)
    random_bytes(n).unpack("H*")[0]
  end

# 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.
  def base64(n=nil)
    [random_bytes(n)].pack("m*").delete("\n")
  end

# 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.
  def urlsafe_base64(n=nil, padding=false)
    s = [random_bytes(n)].pack("m*")
    s.delete!("\n")
    s.tr!("+/", "-_")
    s.delete!("=") unless padding
    s
  end

=begin
  # SecureRandom.random_number generates a random number.
  #
  # If a positive integer is given as _n_,
  # +SecureRandom.random_number+ returns an integer, such that:
  # +0 <= SecureRandom.random_number(n) < n+.
  #
  #   p SecureRandom.random_number(100) #=> 15
  #   p SecureRandom.random_number(100) #=> 88
  #
  # If 0 is given or an argument is not given,
  # +SecureRandom.random_number+ returns a float, such that:
  # +0.0 <= SecureRandom.random_number() < 1.0+.
  #
  #   p SecureRandom.random_number #=> 0.596506046187744
  #   p SecureRandom.random_number #=> 0.350621695741409
  #
  def random_number(n=0)
    if 0 < n
      if defined? OpenSSL::BN
        OpenSSL::BN.rand_range(n).to_i
      else
        hex = n.to_s(16)
        hex = '0' + hex if (hex.length & 1) == 1
        bin = [hex].pack("H*")
        mask = bin[0].ord
        mask |= mask >> 1
        mask |= mask >> 2
        mask |= mask >> 4
        begin
          rnd = random_bytes(bin.length)
          rnd[0] = (rnd[0].ord & mask).chr
        end until rnd < bin
        rnd.unpack("H*")[0].hex
      end
    else
      # assumption: Float::MANT_DIG <= 64
      if defined? OpenSSL::BN
        i64 = OpenSSL::BN.rand(64, -1).to_i
      else
        i64 = random_bytes(8).unpack("Q")[0]
      end
      Math.ldexp(i64 >> (64-Float::MANT_DIG), -Float::MANT_DIG)
    end
  end
=end

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

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

SecureRandom.extend(Random::Formatter)