File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby18/lib64/ruby/1.8

opt / alt / ruby18 / lib64 / ruby / 1.8 /

?? ..
?? English.rb(5.6 KB)
?? Env.rb(274 B)
?? abbrev.rb(2.5 KB)
?? base64.rb(3.37 KB)
?? benchmark.rb(17.73 KB)
?? bigdecimal
?? cgi
?? cgi-lib.rb(6.89 KB)
?? cgi.rb(73.74 KB)
?? complex.rb(12.84 KB)
?? csv.rb(24.46 KB)
?? date
?? date.rb(53.02 KB)
?? date2.rb(128 B)
?? debug.rb(20.61 KB)
?? delegate.rb(8.81 KB)
?? digest
?? digest.rb(1.12 KB)
?? dl
?? drb
?? drb.rb(19 B)
?? e2mmap.rb(4.04 KB)
?? erb.rb(21.38 KB)
?? eregex.rb(487 B)
?? expect.rb(633 B)
?? fileutils.rb(42.23 KB)
?? finalize.rb(5.38 KB)
?? find.rb(1.84 KB)
?? forwardable.rb(6.16 KB)
?? ftools.rb(6.17 KB)
?? generator.rb(8.1 KB)
?? getoptlong.rb(14.88 KB)
?? getopts.rb(2.25 KB)
?? gserver.rb(6.43 KB)
?? importenv.rb(590 B)
?? io
?? ipaddr.rb(21.96 KB)
?? irb
?? irb.rb(7.43 KB)
?? jcode.rb(4.3 KB)
?? kconv.rb(8.12 KB)
?? logger.rb(17.59 KB)
?? mailread.rb(1.28 KB)
?? mathn.rb(5.42 KB)
?? matrix.rb(27.21 KB)
?? md5.rb(411 B)
?? mkmf.rb(50.65 KB)
?? monitor.rb(7.93 KB)
?? mutex_m.rb(2.07 KB)
?? net
?? observer.rb(5.15 KB)
?? open-uri.rb(20.49 KB)
?? open3.rb(2.1 KB)
?? openssl
?? openssl.rb(575 B)
?? optparse
?? optparse.rb(47.12 KB)
?? ostruct.rb(3.35 KB)
?? parsearg.rb(1.55 KB)
?? parsedate.rb(1.33 KB)
?? pathname.rb(29.39 KB)
?? ping.rb(1.48 KB)
?? pp.rb(15.97 KB)
?? prettyprint.rb(18.33 KB)
?? profile.rb(90 B)
?? profiler.rb(1.59 KB)
?? pstore.rb(11.15 KB)
?? racc
?? rational.rb(12.05 KB)
?? rdoc
?? readbytes.rb(835 B)
?? resolv-replace.rb(1.55 KB)
?? resolv.rb(56.83 KB)
?? rexml
?? rinda
?? rss
?? rss.rb(504 B)
?? rubyunit.rb(180 B)
?? runit
?? scanf.rb(20.63 KB)
?? securerandom.rb(4.27 KB)
?? set.rb(27.08 KB)
?? sha1.rb(418 B)
?? shell
?? shell.rb(4.66 KB)
?? shellwords.rb(3.99 KB)
?? singleton.rb(8.08 KB)
?? soap
?? sync.rb(6.09 KB)
?? tempfile.rb(4.86 KB)
?? test
?? thread.rb(104 B)
?? thwait.rb(4.32 KB)
?? time.rb(31.58 KB)
?? timeout.rb(3 KB)
?? tmpdir.rb(3.69 KB)
?? tracer.rb(2.73 KB)
?? tsort.rb(7.99 KB)
?? un.rb(4.54 KB)
?? uri
?? uri.rb(710 B)
?? weakref.rb(2.68 KB)
?? webrick
?? webrick.rb(811 B)
?? wsdl
?? x86_64-linux
?? xmlrpc
?? xsd
?? yaml
?? yaml.rb(12.36 KB)

Editing: securerandom.rb

# = Secure random number generator interface.
#
# This library is an interface for secure random number generator which is
# suitable for generating session key in HTTP cookies, etc.
#
# It supports following secure random number generators.
#
# * openssl
# * /dev/urandom
#
# == Example
#
# # random hexadecimal string.
# p SecureRandom.hex(10) #=> "52750b30ffbc7de3b362"
# p SecureRandom.hex(10) #=> "92b15d6c8dc4beb5f559"
# p SecureRandom.hex(11) #=> "6aca1b5c58e4863e6b81b8"
# p SecureRandom.hex(12) #=> "94b2fff3e7fd9b9c391a2306"
# p SecureRandom.hex(13) #=> "39b290146bea6ce975c37cfc23"
# ...
#
# # random base64 string.
# p SecureRandom.base64(10) #=> "EcmTPZwWRAozdA=="
# p SecureRandom.base64(10) #=> "9b0nsevdwNuM/w=="
# p SecureRandom.base64(10) #=> "KO1nIU+p9DKxGg=="
# p SecureRandom.base64(11) #=> "l7XEiFja+8EKEtY="
# p SecureRandom.base64(12) #=> "7kJSM/MzBJI+75j8"
# p SecureRandom.base64(13) #=> "vKLJ0tXBHqQOuIcSIg=="
# ...
#
# # random binary string.
# p SecureRandom.random_bytes(10) #=> "\016\t{\370g\310pbr\301"
# p SecureRandom.random_bytes(10) #=> "\323U\030TO\234\357\020\a\337"
# ...

begin
  require 'openssl'
rescue LoadError
end

module SecureRandom
  # 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.
  def self.random_bytes(n=nil)
    n ||= 16
    if defined? OpenSSL::Random
      @pid = 0 if !defined?(@pid)
      pid = $$
      if @pid != pid
        now = Time.now
        ary = [now.to_i, now.usec, @pid, pid]
        OpenSSL::Random.seed(ary.join('.'))
        @pid = pid
      end
      return OpenSSL::Random.random_bytes(n)
    end
    if !defined?(@has_urandom) || @has_urandom
      @has_urandom = false
      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
        raise NotImplementedError, "No random device"
      end
    end
    raise NotImplementedError, "No random device"
  end

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

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

# 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.
  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*")
      mask = bin[0]
      mask |= mask >> 1
      mask |= mask >> 2
      mask |= mask >> 4
      begin
        rnd = SecureRandom.random_bytes(bin.length)
        rnd[0] = (rnd[0] & 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
end

X7ROOT File Manager

Editing: securerandom.rb

Upload File

Create Folder