Class: Gem::Package

# File 'lib/rubygems/package.rb', line 241

def initialize(gem, security_policy) # :notnew:
  require "zlib"

  @gem = gem

  @build_time      = Gem.source_date_epoch
  @checksums       = {}
  @contents        = nil
  @digests         = Hash.new {|h, algorithm| h[algorithm] = {} }
  @files           = nil
  @security_policy = security_policy
  @signatures      = {}
  @signer          = nil
  @spec            = nil
end

# File 'lib/rubygems/package.rb', line 217

def self.raw_spec(path, security_policy = nil)
  format = new(path, security_policy)
  spec = format.spec

  metadata = nil

  File.open path, Gem.binary_mode do |io|
    tar = Gem::Package::TarReader.new io
    tar.each_entry do |entry|
      case entry.full_name
      when "metadata" then
        metadata = entry.read
      when "metadata.gz" then
        metadata = Gem::Util.gunzip entry.read
      end
    end
  end

  [spec, metadata]
end

# File 'lib/rubygems/package.rb', line 109

attr_reader :checksums

# File 'lib/rubygems/package.rb', line 142

attr_accessor :data_mode

# File 'lib/rubygems/package.rb', line 134

attr_accessor :dir_mode

# File 'lib/rubygems/package.rb', line 115

attr_reader :files

# File 'lib/rubygems/package.rb', line 120

attr_reader :gem

# File 'lib/rubygems/package.rb', line 138

attr_accessor :prog_mode

# File 'lib/rubygems/package.rb', line 125

attr_accessor :security_policy

# File 'lib/rubygems/package.rb', line 707

def spec
  verify unless @spec

  @spec
end

# File 'lib/rubygems/package.rb', line 130

attr_writer :spec

# File 'lib/rubygems/package.rb', line 308

def add_contents(tar) # :nodoc:
  digests = tar.add_file_signed "data.tar.gz", 0o444, @signer do |io|
    gzip_to io do |gz_io|
      Gem::Package::TarWriter.new gz_io do |data_tar|
        add_files data_tar
      end
    end
  end

  @checksums["data.tar.gz"] = digests
end

# File 'lib/rubygems/package.rb', line 323

def add_files(tar) # :nodoc:
  @spec.files.each do |file|
    if invalid_windows_filename?(file)
      alert_warning "filename '#{file}' contains characters that are invalid on Windows (e.g., colons). This gem may fail to install on Windows."
    end

    stat = File.lstat file

    if stat.symlink?
      tar.add_symlink file, File.readlink(file), stat.mode
    end

    next unless stat.file?

    tar.add_file_simple file, stat.mode, stat.size do |dst_io|
      File.open file, "rb" do |src_io|
        copy_stream(src_io, dst_io, stat.size)
      end
    end
  end
end

# File 'lib/rubygems/package.rb', line 348

def add_metadata(tar) # :nodoc:
  digests = tar.add_file_signed "metadata.gz", 0o444, @signer do |io|
    gzip_to io do |gz_io|
      gz_io.write @spec.to_yaml
    end
  end

  @checksums["metadata.gz"] = digests
end

# File 'lib/rubygems/package.rb', line 361

def build(skip_validation = false, strict_validation = false)
  raise ArgumentError, "skip_validation = true and strict_validation = true are incompatible" if skip_validation && strict_validation

  Gem.load_yaml

  @spec.validate true, strict_validation unless skip_validation

  setup_signer(
    signer_options: {
      expiration_length_days: Gem.configuration.cert_expiration_length_days,
    }
  )

  @gem.with_write_io do |gem_io|
    Gem::Package::TarWriter.new gem_io do |gem|
      add_metadata gem
      add_contents gem
      add_checksums gem
    end
  end

  message = <<-EOM
Successfully built RubyGem
Name: #{@spec.name}
Version: #{@spec.version}
EOM

  message += "  File: #{File.basename(@gem.path)}\n" if @gem.path
  say message
ensure
  @signer = nil
end

# File 'lib/rubygems/package.rb', line 403

def build_content_addressable_file(skip_validation = false, strict_validation = false)
  Gem::ContentAddress.eligible!(@spec)
  ruby_abi = Gem::ContentAddress.ruby_abi_for(@spec.required_ruby_version)
  @spec.required_rubygems_version = normalized_required_rubygems_version(ruby_abi)

  build skip_validation, strict_validation

  bytes = @gem.with_read_io(&:read)
  gem_file = "#{@spec.name}-#{@spec.version}-#{Gem::ContentAddress.address_for(bytes)}.gem"
  File.binwrite(gem_file, bytes)

  say "  File: #{gem_file}"
  say "  Platform: #{@spec.platform}"
  say "  Ruby ABI: #{ruby_abi}"

  gem_file
end

# File 'lib/rubygems/package.rb', line 268

def content_address
  path = @gem&.path
  return unless path

  address = Gem::ContentAddress.verified_file_name_claim(path, spec)
  return nil unless address
  return nil unless Gem::ContentAddress.eligible?(spec)

  address
end

# File 'lib/rubygems/package.rb', line 424

def contents
  return @contents if @contents

  verify unless @spec

  @contents = []

  @gem.with_read_io do |io|
    gem_tar = Gem::Package::TarReader.new io

    gem_tar.each do |entry|
      next unless entry.full_name == "data.tar.gz"

      open_tar_gz entry do |pkg_tar|
        pkg_tar.each do |contents_entry|
          @contents << contents_entry.full_name
        end
      end

      return @contents
    end
  end
rescue Zlib::GzipFile::Error, EOFError, Gem::Package::TarInvalidError => e
  raise Gem::Package::FormatError.new e.message, @gem
end

# File 'lib/rubygems/package.rb', line 921

def copy_stream(src, dst, size) # :nodoc:
  dst.write src.read(size)
end

# File 'lib/rubygems/package.rb', line 260

def copy_to(path)
  FileUtils.cp @gem.path, path unless File.exist? path
end

# File 'lib/rubygems/package.rb', line 944

def create_symlink(old_name, new_name)
  File.symlink(old_name, new_name)
rescue Errno::EACCES, TypeError
  from = File.expand_path(old_name, File.dirname(new_name))
  FileUtils.cp_r(from, new_name)
end

# File 'lib/rubygems/package.rb', line 454

def digest(entry) # :nodoc:
  algorithms = if @checksums
    @checksums.to_h {|algorithm, _| [algorithm, Gem::Security.create_digest(algorithm)] }
  elsif Gem::Security::DIGEST_NAME
    { Gem::Security::DIGEST_NAME => Gem::Security.create_digest(Gem::Security::DIGEST_NAME) }
  end

  return @digests if algorithms.nil? || algorithms.empty?

  buf = String.new(capacity: 16_384, encoding: Encoding::BINARY)
  until entry.eof?
    entry.readpartial(16_384, buf)
    algorithms.each_value {|digester| digester << buf }
  end
  entry.rewind

  algorithms.each do |algorithm, digester|
    @digests[algorithm][entry.full_name] = digester
  end

  @digests
end

# File 'lib/rubygems/package.rb', line 792

def excludes_rubygems_floor?(requirement, floor)
  capped_below_floor = requirement.requirements.any? do |op, version|
    case op
    when "<" then version <= floor
    when "<=", "=" then version < floor
    when "~>" then version.bump <= floor.release
    else false
    end
  end

  return true if capped_below_floor

  !requirement.satisfied_by?(floor) && requirement.requirements.any? do |op, version|
    ["<=", "="].include?(op) && version == floor
  end
end

# File 'lib/rubygems/package.rb', line 483

def extract_files(destination_dir, pattern = "*")
  verify unless @spec

  FileUtils.mkdir_p destination_dir, mode: dir_mode && 0o755

  @gem.with_read_io do |io|
    reader = Gem::Package::TarReader.new io

    reader.each do |entry|
      next unless entry.full_name == "data.tar.gz"

      extract_tar_gz entry, destination_dir, pattern

      break # ignore further entries
    end
  end
rescue Zlib::GzipFile::Error, EOFError, Gem::Package::TarInvalidError => e
  raise Gem::Package::FormatError.new e.message, @gem
end

# File 'lib/rubygems/package.rb', line 514

def extract_tar_gz(io, destination_dir, pattern = "*") # :nodoc:
  destination_dir = File.realpath(destination_dir)

  directories = []
  symlinks = []

  open_tar_gz io do |tar|
    tar.each do |entry|
      full_name = entry.full_name
      next unless File.fnmatch pattern, full_name, File::FNM_DOTMATCH

      if Gem.win_platform? && invalid_windows_filename?(full_name)
        gem_name = @spec ? @spec.full_name : "unknown"
        raise Gem::Package::InvalidWindowsFileNameError.new(full_name, gem_name)
      end

      destination = install_location full_name, destination_dir

      if entry.symlink?
        link_target = entry.header.linkname
        real_destination = File.expand_path(link_target, File.dirname(destination))

        raise Gem::Package::SymlinkError.new(full_name, real_destination, destination_dir) unless
          normalize_path(real_destination).start_with? normalize_path(destination_dir + "/")

        symlinks << [full_name, link_target, destination, real_destination]
      end

      mkdir =
        if entry.directory?
          destination
        else
          File.dirname destination
        end

      unless directories.include?(mkdir)
        FileUtils.mkdir_p mkdir, mode: dir_mode ? 0o755 : (entry.header.mode & 0o777 if entry.directory?)
        directories << mkdir
      end

      verify_extraction_dir mkdir, destination_dir

      if entry.file?
        File.open(destination, "wb") do |out|
          copy_stream(tar.io, out, entry.size)
          # Flush needs to happen before chmod because there could be data
          # in the IO buffer that needs to be written, and that could be
          # written after the chmod (on close) which would mess up the perms
          out.flush
          out.chmod file_mode(entry.header.mode) & ~File.umask
        end
      end

      verbose destination
    end
  end

  symlinks.each do |name, target, destination, real_destination|
    if File.exist?(real_destination)
      create_symlink(target, destination)
    else
      alert_warning "#{@spec.full_name} ships with a dangling symlink named #{name} pointing to missing #{target} file. Ignoring"
    end
  end

  if dir_mode && !directories.empty?
    File.chmod(dir_mode, *directories)
  end
end

# File 'lib/rubygems/package.rb', line 584

def file_mode(mode) # :nodoc:
  ((mode & 0o111).zero? ? data_mode : prog_mode) ||
    # If we're not using one of the default modes, then we're going to fall
    # back to the permission bits from the tarball. Masking drops setuid,
    # setgid and sticky bits along with anything that does not fit into a
    # mode in CRuby (an unsigned short).
    (mode & 0o777)
end

# File 'lib/rubygems/package.rb', line 599

def gzip_to(io) # :yields: gz_io
  gz_io = Zlib::GzipWriter.new io, Zlib::BEST_COMPRESSION
  gz_io.mtime = @build_time

  yield gz_io
ensure
  gz_io.close
end

# File 'lib/rubygems/package.rb', line 828

def install_location(filename, destination_dir) # :nodoc:
  raise Gem::Package::PathError.new(filename, destination_dir) if
    filename.start_with? "/"

  destination = File.expand_path(filename, destination_dir)

  raise Gem::Package::PathError.new(destination, destination_dir) unless
    normalize_path(destination).start_with? normalize_path(destination_dir + "/")

  destination
end

# File 'lib/rubygems/package.rb', line 624

def invalid_windows_filename?(filename) # :nodoc:
  filename.to_s.split("/").any? {|part| part.match?(/[:<>"|?*\\\x00-\x1f]/) }
end

# File 'lib/rubygems/package.rb', line 926

def limit_read(io, name, limit)
  bytes = io.read(limit + 1)
  raise Gem::Package::FormatError, "#{name} is too big (over #{limit} bytes)" if bytes.size > limit
  bytes
end

# File 'lib/rubygems/package.rb', line 631

def load_spec_from_metadata(entry) # :nodoc:
  limit = 10 * 1024 * 1024
  case entry.full_name
  when "metadata" then
    @spec = Gem::Specification.from_yaml limit_read(entry, "metadata", limit)
  when "metadata.gz" then
    Zlib::GzipReader.wrap(entry, external_encoding: Encoding::UTF_8) do |gzio|
      @spec = Gem::Specification.from_yaml limit_read(gzio, "metadata.gz", limit)
    end
  end
end

# File 'lib/rubygems/package.rb', line 613

def normalize_path(pathname) # :nodoc:
  pathname.downcase
end

# File 'lib/rubygems/package.rb', line 758

def normalized_required_rubygems_version(ruby_abi)
  minimum = Gem::Requirement.new(MINIMUM_RUBYGEMS_VERSION)
  existing = @spec.required_rubygems_version

  return minimum if existing.nil? || existing == Gem::Requirement.default

  floor = minimum.requirements.first.last

  if excludes_rubygems_floor?(existing, floor)
    raise ArgumentError,
      "Cannot build gem for Ruby ABI #{ruby_abi} because required_rubygems_version is set to #{existing}, " \
      "which excludes RubyGems #{MINIMUM_RUBYGEMS_VERSION} required to install content addressable gems. " \
      "Please remove or loosen the conflicting constraint."
  end

  return existing if satisfies_rubygems_floor?(existing, floor)

  preserved = existing.requirements.filter_map do |op, version|
    "#{op} #{version}" if ["~>", "<", "<=", "!="].include?(op)
  end

  normalized = Gem::Requirement.new([MINIMUM_RUBYGEMS_VERSION, *preserved])

  alert_warning \
    "required_rubygems_version was changed from \"#{existing}\" to \"#{normalized}\" for this build " \
    "because content addressable gems can only be installed by RubyGems #{MINIMUM_RUBYGEMS_VERSION}."

  normalized
end

# File 'lib/rubygems/package.rb', line 646

def open_tar_gz(io) # :nodoc:
  Zlib::GzipReader.wrap io do |gzio|
    tar = Gem::Package::TarReader.new gzio

    yield tar
  ensure
    # Consume remaining gzip data to prevent the
    # "attempt to close unfinished zstream; reset forced" warning
    # when the GzipReader is closed with unconsumed compressed data.
    begin
      IO.copy_stream(gzio, IO::NULL)
    rescue Zlib::GzipFile::Error, IOError
      nil
    end
  end
end

# File 'lib/rubygems/package.rb', line 666

def read_checksums(gem)
  Gem.load_yaml

  @checksums = gem.seek "checksums.yaml.gz" do |entry|
    Zlib::GzipReader.wrap entry do |gz_io|
      Gem::SafeYAML.safe_load limit_read(gz_io, "checksums.yaml.gz", 10 * 1024 * 1024)
    end
  end
end

# File 'lib/rubygems/package.rb', line 813

def satisfies_rubygems_floor?(requirement, floor)
  requirement.requirements.any? do |op, version|
    case op
    when ">=", "~>", "=", ">" then version >= floor
    else false
    end
  end
end

# File 'lib/rubygems/package.rb', line 680

def setup_signer(signer_options: {})
  passphrase = ENV["GEM_PRIVATE_KEY_PASSPHRASE"]
  if @spec.signing_key
    @signer =
      Gem::Security::Signer.new(
        @spec.signing_key,
        @spec.cert_chain,
        passphrase,
        signer_options
      )

    @spec.signing_key = nil
    @spec.cert_chain = @signer.cert_chain.map(&:to_s)
  else
    @signer = Gem::Security::Signer.new nil, nil, passphrase
    @spec.cert_chain = @signer.cert_chain.map(&:to_pem) if
      @signer.cert_chain
  end
end

# File 'lib/rubygems/package.rb', line 723

def verify
  @files     = []
  @spec      = nil

  @gem.with_read_io do |io|
    Gem::Package::TarReader.new io do |reader|
      read_checksums reader

      verify_files reader
    end
  end

  verify_checksums @digests, @checksums

  @security_policy&.verify_signatures @spec, @digests, @signatures

  true
rescue Gem::Security::Exception
  @spec = nil
  @files = []
  raise
rescue Errno::ENOENT => e
  raise Gem::Package::FormatError.new e.message
rescue Zlib::GzipFile::Error, EOFError, Gem::Package::TarInvalidError => e
  raise Gem::Package::FormatError.new e.message, @gem
end

# File 'lib/rubygems/package.rb', line 858

def verify_checksums(digests, checksums) # :nodoc:
  return unless checksums

  checksums.sort.each do |algorithm, gem_digests|
    gem_digests.sort.each do |file_name, gem_hexdigest|
      computed_digest = digests[algorithm][file_name]

      unless computed_digest.hexdigest == gem_hexdigest
        raise Gem::Package::FormatError.new \
          "#{algorithm} checksum mismatch for #{file_name}", @gem
      end
    end
  end
end

# File 'lib/rubygems/package.rb', line 876

def verify_entry(entry)
  file_name = entry.full_name
  @files << file_name

  case file_name
  when /\.sig$/ then
    @signatures[$`] = limit_read(entry, file_name, 1024 * 1024) if @security_policy
    return
  else
    digest entry
  end

  load_spec_from_metadata entry
rescue StandardError
  warn "Exception while verifying #{@gem.path}"
  raise
end

# File 'lib/rubygems/package.rb', line 845

def verify_extraction_dir(dir, destination_dir) # :nodoc:
  real_dir = File.realpath(dir)

  return if real_dir == destination_dir ||
            normalize_path(real_dir).start_with?(normalize_path(destination_dir + "/"))

  raise Gem::Package::PathError.new(real_dir, destination_dir)
end

# File 'lib/rubygems/package.rb', line 897

def verify_files(gem)
  gem.each do |entry|
    verify_entry entry
  end

  unless @spec
    raise Gem::Package::FormatError.new "package metadata is missing", @gem
  end

  unless @files.include? "data.tar.gz"
    raise Gem::Package::FormatError.new \
      "package content (data.tar.gz) is missing", @gem
  end

  if (duplicates = @files.group_by {|f| f }.select {|_k,v| v.size > 1 }.map(&:first)) && duplicates.any?
    raise Gem::Security::Exception, "duplicate files in the package: (#{duplicates.map(&:inspect).join(", ")})"
  end
end