rubygems-update 2.6.1 → 3.5.0

data/lib/rubygems/resolver.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
-require 'rubygems/dependency'
-require 'rubygems/exceptions'
-require 'rubygems/util'
-require 'rubygems/util/list'
 
-require 'uri'
-require 'net/http'
+require_relative "dependency"
+require_relative "exceptions"
+require_relative "util/list"
 
 ##
 # Given a set of Gem::Dependency objects as +needed+ and a way to query the
@@ -14,14 +11,14 @@ require 'net/http'
 # all the requirements.
 
 class Gem::Resolver
-  require 'rubygems/resolver/molinillo'
+  require_relative "resolver/molinillo"
 
   ##
   # If the DEBUG_RESOLVER environment variable is set then debugging mode is
   # enabled for the resolver.  This will display information about the state
   # of the resolver while a set of dependencies is being resolved.
 
-  DEBUG_RESOLVER = !ENV['DEBUG_RESOLVER'].nil?
+  DEBUG_RESOLVER = !ENV["DEBUG_RESOLVER"].nil?
 
   ##
   # Set to true if all development dependencies should be considered.
@@ -41,8 +38,6 @@ class Gem::Resolver
   ##
   # List of dependencies that could not be found in the configured sources.
 
-  attr_reader :missing
-
   attr_reader :stats
 
   ##
@@ -52,8 +47,7 @@ class Gem::Resolver
   attr_accessor :skip_gems
 
   ##
-  # When a missing dependency, don't stop. Just go on and record what was
-  # missing.
+  #
 
   attr_accessor :soft_missing
 
@@ -62,7 +56,7 @@ class Gem::Resolver
   # uniform manner.  If one of the +sets+ is itself a ComposedSet its sets are
   # flattened into the result ComposedSet.
 
-  def self.compose_sets *sets
+  def self.compose_sets(*sets)
     sets.compact!
 
     sets = sets.map do |set|
@@ -78,7 +72,7 @@ class Gem::Resolver
 
     case sets.length
     when 0 then
-      raise ArgumentError, 'one set in the composition must be non-nil'
+      raise ArgumentError, "one set in the composition must be non-nil"
     when 1 then
       sets.first
     else
@@ -90,7 +84,7 @@ class Gem::Resolver
   # Creates a Resolver that queries only against the already installed gems
   # for the +needed+ dependencies.
 
-  def self.for_current_gems needed
+  def self.for_current_gems(needed)
     new needed, Gem::Resolver::CurrentSet.new
   end
 
@@ -102,32 +96,34 @@ class Gem::Resolver
   # satisfy the Dependencies. This defaults to IndexSet, which will query
   # rubygems.org.
 
-  def initialize needed, set = nil
+  def initialize(needed, set = nil)
     @set = set || Gem::Resolver::IndexSet.new
     @needed = needed
 
     @development         = false
     @development_shallow = false
     @ignore_dependencies = false
-    @missing             = []
     @skip_gems           = {}
     @soft_missing        = false
     @stats               = Gem::Resolver::Stats.new
   end
 
-  def explain stage, *data # :nodoc:
+  def explain(stage, *data) # :nodoc:
     return unless DEBUG_RESOLVER
 
-    d = data.map { |x| x.pretty_inspect }.join(", ")
+    d = data.map(&:pretty_inspect).join(", ")
     $stderr.printf "%10s %s\n", stage.to_s.upcase, d
   end
 
-  def explain_list stage # :nodoc:
+  def explain_list(stage) # :nodoc:
     return unless DEBUG_RESOLVER
 
     data = yield
     $stderr.printf "%10s (%d entries)\n", stage.to_s.upcase, data.size
-    PP.pp data, $stderr unless data.empty?
+    unless data.empty?
+      require "pp"
+      PP.pp data, $stderr
+    end
   end
 
   ##
@@ -136,7 +132,7 @@ class Gem::Resolver
   #
   # Returns the Specification and the ActivationRequest
 
-  def activation_request dep, possible # :nodoc:
+  def activation_request(dep, possible) # :nodoc:
     spec = possible.pop
 
     explain :activate, [spec.full_name, possible.size]
@@ -145,19 +141,19 @@ class Gem::Resolver
     activation_request =
       Gem::Resolver::ActivationRequest.new spec, dep, possible
 
-    return spec, activation_request
+    [spec, activation_request]
   end
 
-  def requests s, act, reqs=[] # :nodoc:
+  def requests(s, act, reqs=[]) # :nodoc:
     return reqs if @ignore_dependencies
 
     s.fetch_development_dependencies if @development
 
     s.dependencies.reverse_each do |d|
-      next if d.type == :development and not @development
-      next if d.type == :development and @development_shallow and
+      next if d.type == :development && !@development
+      next if d.type == :development && @development_shallow &&
               act.development?
-      next if d.type == :development and @development_shallow and
+      next if d.type == :development && @development_shallow &&
               act.parent
 
       reqs << Gem::Resolver::DependencyRequest.new(d, act)
@@ -174,7 +170,7 @@ class Gem::Resolver
   include Molinillo::UI
 
   def output
-    @output ||= debug? ? $stdout : File.open(Gem::Util::NULL_DEVICE, 'w')
+    @output ||= debug? ? $stdout : File.open(IO::NULL, "w")
   end
 
   def debug?
@@ -187,25 +183,24 @@ class Gem::Resolver
   # Proceed with resolution! Returns an array of ActivationRequest objects.
 
   def resolve
-    locking_dg = Molinillo::DependencyGraph.new
-    Molinillo::Resolver.new(self, self).resolve(@needed.map { |d| DependencyRequest.new d, nil }, locking_dg).tsort.map(&:payload).compact
+    Molinillo::Resolver.new(self, self).resolve(@needed.map {|d| DependencyRequest.new d, nil }).tsort.map(&:payload).compact
   rescue Molinillo::VersionConflict => e
     conflict = e.conflicts.values.first
     raise Gem::DependencyResolutionError, Conflict.new(conflict.requirement_trees.first.first, conflict.existing, conflict.requirement)
   ensure
-    @output.close if @output and !debug?
+    @output.close if defined?(@output) && !debug?
   end
 
   ##
   # Extracts the specifications that may be able to fulfill +dependency+ and
   # returns those that match the local platform and all those that match.
 
-  def find_possible dependency # :nodoc:
+  def find_possible(dependency) # :nodoc:
     all = @set.find_all dependency
 
     if (skip_dep_gems = skip_gems[dependency.name]) && !skip_dep_gems.empty?
       matching = all.select do |api_spec|
-        skip_dep_gems.any? { |s| api_spec.version == s.version }
+        skip_dep_gems.any? {|s| api_spec.version == s.version }
       end
 
       all = matching unless matching.empty?
@@ -213,13 +208,13 @@ class Gem::Resolver
 
     matching_platform = select_local_platforms all
 
-    return matching_platform, all
+    [matching_platform, all]
   end
 
   ##
   # Returns the gems in +specs+ that match the local platform.
 
-  def select_local_platforms specs # :nodoc:
+  def select_local_platforms(specs) # :nodoc:
     specs.select do |spec|
       Gem::Platform.installable? spec
     end
@@ -228,13 +223,30 @@ class Gem::Resolver
   def search_for(dependency)
     possibles, all = find_possible(dependency)
     if !@soft_missing && possibles.empty?
-      @missing << dependency
       exc = Gem::UnsatisfiableDependencyError.new dependency, all
       exc.errors = @set.errors
       raise exc
     end
-    possibles.sort_by { |s| [s.source, s.version, s.platform.to_s == Gem::Platform.local.to_s ? 1 : 0] }.
-      map { |s| ActivationRequest.new s, dependency, [] }
+
+    groups = Hash.new {|hash, key| hash[key] = [] }
+
+    # create groups & sources in the same loop
+    sources = possibles.map do |spec|
+      source = spec.source
+      groups[source] << spec
+      source
+    end.uniq.reverse
+
+    activation_requests = []
+
+    sources.each do |source|
+      groups[source].
+        sort_by {|spec| [spec.version, spec.platform =~ Gem::Platform.local ? 1 : 0] }. # rubocop:disable Performance/RegexpMatch
+        map {|spec| ActivationRequest.new spec, dependency }.
+        each {|activation_request| activation_requests << activation_request }
+    end
+
+    activation_requests
   end
 
   def dependencies_for(specification)
@@ -244,7 +256,12 @@ class Gem::Resolver
   end
 
   def requirement_satisfied_by?(requirement, activated, spec)
-    requirement.matches_spec? spec
+    matches_spec = requirement.matches_spec? spec
+    return matches_spec if @soft_missing
+
+    matches_spec &&
+      spec.spec.required_ruby_version.satisfied_by?(Gem.ruby_version) &&
+      spec.spec.required_rubygems_version.satisfied_by?(Gem.rubygems_version)
   end
 
   def name_for(dependency)
@@ -252,41 +269,73 @@ class Gem::Resolver
   end
 
   def allow_missing?(dependency)
-    @missing << dependency
     @soft_missing
   end
 
+  def sort_dependencies(dependencies, activated, conflicts)
+    dependencies.sort_by.with_index do |dependency, i|
+      name = name_for(dependency)
+      [
+        activated.vertex_named(name).payload ? 0 : 1,
+        amount_constrained(dependency),
+        conflicts[name] ? 0 : 1,
+        activated.vertex_named(name).payload ? 0 : search_for(dependency).count,
+        i, # for stable sort
+      ]
+    end
+  end
+
+  SINGLE_POSSIBILITY_CONSTRAINT_PENALTY = 1_000_000
+  private_constant :SINGLE_POSSIBILITY_CONSTRAINT_PENALTY if defined?(private_constant)
+
+  # returns an integer \in (-\infty, 0]
+  # a number closer to 0 means the dependency is less constraining
+  #
+  # dependencies w/ 0 or 1 possibilities (ignoring version requirements)
+  # are given very negative values, so they _always_ sort first,
+  # before dependencies that are unconstrained
+  def amount_constrained(dependency)
+    @amount_constrained ||= {}
+    @amount_constrained[dependency.name] ||= begin
+      name_dependency = Gem::Dependency.new(dependency.name)
+      dependency_request_for_name = Gem::Resolver::DependencyRequest.new(name_dependency, dependency.requester)
+      all = @set.find_all(dependency_request_for_name).size
+
+      if all <= 1
+        all - SINGLE_POSSIBILITY_CONSTRAINT_PENALTY
+      else
+        search = search_for(dependency).size
+        search - all
+      end
+    end
+  end
+  private :amount_constrained
 end
 
-##
-# TODO remove in RubyGems 3
-
-Gem::DependencyResolver = Gem::Resolver # :nodoc:
-
-require 'rubygems/resolver/activation_request'
-require 'rubygems/resolver/conflict'
-require 'rubygems/resolver/dependency_request'
-require 'rubygems/resolver/requirement_list'
-require 'rubygems/resolver/stats'
-
-require 'rubygems/resolver/set'
-require 'rubygems/resolver/api_set'
-require 'rubygems/resolver/composed_set'
-require 'rubygems/resolver/best_set'
-require 'rubygems/resolver/current_set'
-require 'rubygems/resolver/git_set'
-require 'rubygems/resolver/index_set'
-require 'rubygems/resolver/installer_set'
-require 'rubygems/resolver/lock_set'
-require 'rubygems/resolver/vendor_set'
-require 'rubygems/resolver/source_set'
-
-require 'rubygems/resolver/specification'
-require 'rubygems/resolver/spec_specification'
-require 'rubygems/resolver/api_specification'
-require 'rubygems/resolver/git_specification'
-require 'rubygems/resolver/index_specification'
-require 'rubygems/resolver/installed_specification'
-require 'rubygems/resolver/local_specification'
-require 'rubygems/resolver/lock_specification'
-require 'rubygems/resolver/vendor_specification'
+require_relative "resolver/activation_request"
+require_relative "resolver/conflict"
+require_relative "resolver/dependency_request"
+require_relative "resolver/requirement_list"
+require_relative "resolver/stats"
+
+require_relative "resolver/set"
+require_relative "resolver/api_set"
+require_relative "resolver/composed_set"
+require_relative "resolver/best_set"
+require_relative "resolver/current_set"
+require_relative "resolver/git_set"
+require_relative "resolver/index_set"
+require_relative "resolver/installer_set"
+require_relative "resolver/lock_set"
+require_relative "resolver/vendor_set"
+require_relative "resolver/source_set"
+
+require_relative "resolver/specification"
+require_relative "resolver/spec_specification"
+require_relative "resolver/api_specification"
+require_relative "resolver/git_specification"
+require_relative "resolver/index_specification"
+require_relative "resolver/installed_specification"
+require_relative "resolver/local_specification"
+require_relative "resolver/lock_specification"
+require_relative "resolver/vendor_specification"

data/lib/rubygems/s3_uri_signer.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "openssl"
+
+##
+# S3URISigner implements AWS SigV4 for S3 Source to avoid a dependency on the aws-sdk-* gems
+# More on AWS SigV4: https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html
+class Gem::S3URISigner
+  class ConfigurationError < Gem::Exception
+    def initialize(message)
+      super message
+    end
+
+    def to_s # :nodoc:
+      super.to_s
+    end
+  end
+
+  class InstanceProfileError < Gem::Exception
+    def initialize(message)
+      super message
+    end
+
+    def to_s # :nodoc:
+      super.to_s
+    end
+  end
+
+  attr_accessor :uri
+
+  def initialize(uri)
+    @uri = uri
+  end
+
+  ##
+  # Signs S3 URI using query-params according to the reference: https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
+  def sign(expiration = 86_400)
+    s3_config = fetch_s3_config
+
+    current_time = Time.now.utc
+    date_time = current_time.strftime("%Y%m%dT%H%m%SZ")
+    date = date_time[0,8]
+
+    credential_info = "#{date}/#{s3_config.region}/s3/aws4_request"
+    canonical_host = "#{uri.host}.s3.#{s3_config.region}.amazonaws.com"
+
+    query_params = generate_canonical_query_params(s3_config, date_time, credential_info, expiration)
+    canonical_request = generate_canonical_request(canonical_host, query_params)
+    string_to_sign = generate_string_to_sign(date_time, credential_info, canonical_request)
+    signature = generate_signature(s3_config, date, string_to_sign)
+
+    URI.parse("https://#{canonical_host}#{uri.path}?#{query_params}&X-Amz-Signature=#{signature}")
+  end
+
+  private
+
+  S3Config = Struct.new :access_key_id, :secret_access_key, :security_token, :region
+
+  def generate_canonical_query_params(s3_config, date_time, credential_info, expiration)
+    canonical_params = {}
+    canonical_params["X-Amz-Algorithm"] = "AWS4-HMAC-SHA256"
+    canonical_params["X-Amz-Credential"] = "#{s3_config.access_key_id}/#{credential_info}"
+    canonical_params["X-Amz-Date"] = date_time
+    canonical_params["X-Amz-Expires"] = expiration.to_s
+    canonical_params["X-Amz-SignedHeaders"] = "host"
+    canonical_params["X-Amz-Security-Token"] = s3_config.security_token if s3_config.security_token
+
+    # Sorting is required to generate proper signature
+    canonical_params.sort.to_h.map do |key, value|
+      "#{base64_uri_escape(key)}=#{base64_uri_escape(value)}"
+    end.join("&")
+  end
+
+  def generate_canonical_request(canonical_host, query_params)
+    [
+      "GET",
+      uri.path,
+      query_params,
+      "host:#{canonical_host}",
+      "", # empty params
+      "host",
+      "UNSIGNED-PAYLOAD",
+    ].join("\n")
+  end
+
+  def generate_string_to_sign(date_time, credential_info, canonical_request)
+    [
+      "AWS4-HMAC-SHA256",
+      date_time,
+      credential_info,
+      OpenSSL::Digest::SHA256.hexdigest(canonical_request),
+    ].join("\n")
+  end
+
+  def generate_signature(s3_config, date, string_to_sign)
+    date_key = OpenSSL::HMAC.digest("sha256", "AWS4" + s3_config.secret_access_key, date)
+    date_region_key = OpenSSL::HMAC.digest("sha256", date_key, s3_config.region)
+    date_region_service_key = OpenSSL::HMAC.digest("sha256", date_region_key, "s3")
+    signing_key = OpenSSL::HMAC.digest("sha256", date_region_service_key, "aws4_request")
+    OpenSSL::HMAC.hexdigest("sha256", signing_key, string_to_sign)
+  end
+
+  ##
+  # Extracts S3 configuration for S3 bucket
+  def fetch_s3_config
+    return S3Config.new(uri.user, uri.password, nil, "us-east-1") if uri.user && uri.password
+
+    s3_source = Gem.configuration[:s3_source] || Gem.configuration["s3_source"]
+    host = uri.host
+    raise ConfigurationError.new("no s3_source key exists in .gemrc") unless s3_source
+
+    auth = s3_source[host] || s3_source[host.to_sym]
+    raise ConfigurationError.new("no key for host #{host} in s3_source in .gemrc") unless auth
+
+    provider = auth[:provider] || auth["provider"]
+    case provider
+    when "env"
+      id = ENV["AWS_ACCESS_KEY_ID"]
+      secret = ENV["AWS_SECRET_ACCESS_KEY"]
+      security_token = ENV["AWS_SESSION_TOKEN"]
+    when "instance_profile"
+      credentials = ec2_metadata_credentials_json
+      id = credentials["AccessKeyId"]
+      secret = credentials["SecretAccessKey"]
+      security_token = credentials["Token"]
+    else
+      id = auth[:id] || auth["id"]
+      secret = auth[:secret] || auth["secret"]
+      security_token = auth[:security_token] || auth["security_token"]
+    end
+
+    raise ConfigurationError.new("s3_source for #{host} missing id or secret") unless id && secret
+
+    region = auth[:region] || auth["region"] || "us-east-1"
+    S3Config.new(id, secret, security_token, region)
+  end
+
+  def base64_uri_escape(str)
+    str.gsub(%r{[\+/=\n]}, BASE64_URI_TRANSLATE)
+  end
+
+  def ec2_metadata_credentials_json
+    require_relative "net/http"
+    require_relative "request"
+    require_relative "request/connection_pools"
+    require "json"
+
+    iam_info = ec2_metadata_request(EC2_IAM_INFO)
+    # Expected format: arn:aws:iam::<id>:instance-profile/<role_name>
+    role_name = iam_info["InstanceProfileArn"].split("/").last
+    ec2_metadata_request(EC2_IAM_SECURITY_CREDENTIALS + role_name)
+  end
+
+  def ec2_metadata_request(url)
+    uri = URI(url)
+    @request_pool ||= create_request_pool(uri)
+    request = Gem::Request.new(uri, Gem::Net::HTTP::Get, nil, @request_pool)
+    response = request.fetch
+
+    case response
+    when Gem::Net::HTTPOK then
+      JSON.parse(response.body)
+    else
+      raise InstanceProfileError.new("Unable to fetch AWS metadata from #{uri}: #{response.message} #{response.code}")
+    end
+  end
+
+  def create_request_pool(uri)
+    proxy_uri = Gem::Request.proxy_uri(Gem::Request.get_proxy_from_env(uri.scheme))
+    certs = Gem::Request.get_cert_files
+    Gem::Request::ConnectionPools.new(proxy_uri, certs).pool_for(uri)
+  end
+
+  BASE64_URI_TRANSLATE = { "+" => "%2B", "/" => "%2F", "=" => "%3D", "\n" => "" }.freeze
+  EC2_IAM_INFO = "http://169.254.169.254/latest/meta-data/iam/info"
+  EC2_IAM_SECURITY_CREDENTIALS = "http://169.254.169.254/latest/meta-data/iam/security-credentials/"
+end

data/lib/rubygems/safe_marshal/elements.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Gem
+  module SafeMarshal
+    module Elements
+      class Element
+      end
+
+      class Symbol < Element
+        def initialize(name)
+          @name = name
+        end
+        attr_reader :name
+      end
+
+      class UserDefined < Element
+        def initialize(name, binary_string)
+          @name = name
+          @binary_string = binary_string
+        end
+
+        attr_reader :name, :binary_string
+      end
+
+      class UserMarshal < Element
+        def initialize(name, data)
+          @name = name
+          @data = data
+        end
+
+        attr_reader :name, :data
+      end
+
+      class String < Element
+        def initialize(str)
+          @str = str
+        end
+
+        attr_reader :str
+      end
+
+      class Hash < Element
+        def initialize(pairs)
+          @pairs = pairs
+        end
+
+        attr_reader :pairs
+      end
+
+      class HashWithDefaultValue < Hash
+        def initialize(pairs, default)
+          super(pairs)
+          @default = default
+        end
+
+        attr_reader :default
+      end
+
+      class Array < Element
+        def initialize(elements)
+          @elements = elements
+        end
+
+        attr_reader :elements
+      end
+
+      class Integer < Element
+        def initialize(int)
+          @int = int
+        end
+
+        attr_reader :int
+      end
+
+      class True < Element
+        def initialize
+        end
+        TRUE = new.freeze
+      end
+
+      class False < Element
+        def initialize
+        end
+
+        FALSE = new.freeze
+      end
+
+      class WithIvars < Element
+        def initialize(object, ivars)
+          @object = object
+          @ivars = ivars
+        end
+
+        attr_reader :object, :ivars
+      end
+
+      class Object < Element
+        def initialize(name)
+          @name = name
+        end
+        attr_reader :name
+      end
+
+      class Nil < Element
+        NIL = new.freeze
+      end
+
+      class ObjectLink < Element
+        def initialize(offset)
+          @offset = offset
+        end
+        attr_reader :offset
+      end
+
+      class SymbolLink < Element
+        def initialize(offset)
+          @offset = offset
+        end
+        attr_reader :offset
+      end
+
+      class Float < Element
+        def initialize(string)
+          @string = string
+        end
+        attr_reader :string
+      end
+
+      class Bignum < Element # rubocop:disable Lint/UnifiedInteger
+        def initialize(sign, data)
+          @sign = sign
+          @data = data
+        end
+        attr_reader :sign, :data
+      end
+    end
+  end
+end