Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
87 changes: 66 additions & 21 deletions lib/github_advisory_sync.rb
Original file line number Diff line number Diff line change
Expand Up @@ -441,15 +441,23 @@ def vulnerable_version_ranges_for(package)
v['vulnerableVersionRange'].split(', ',2).map do |version_range|
version_range.split(' ',2)
end
}.sort_by { |((lower_op,lower_version),(upper_op,upper_version))|
lower_version
}
}.sort_by { |version_range| range_order(version_range) }
end

# A range with no lower bound ("< 1.2.3"), or with a start RubyGems cannot parse, sorts first.
# At the same start, ">" sorts after ">=" and "=", which cover the start itself.
def range_order(version_range)
operator, version = version_range.first
starts = %w[>= > =].include?(operator) && Gem::Version.correct?(version)

starts ? [1, Gem::Version.new(version), operator == '>' ? 1 : 0] : [0]
end

def unaffected_versions_for(package)
if (version_range = vulnerable_version_ranges_for(package).first)
lower_version_range = version_range[0]
operator, version = lower_version_range
return unless Gem::Version.correct?(version.to_s)

case operator
when '>'
Expand All @@ -461,32 +469,69 @@ def unaffected_versions_for(package)
end

def first_patched_versions_for(package)
first_patched_versions = []

vulnerabilities.each do |v|
if v['package']['name'] == package.name &&
v['firstPatchedVersion'] &&
v['firstPatchedVersion']['identifier']
first_patched_versions << v['firstPatchedVersion']['identifier']
end
end
versions = vulnerabilities.filter_map { |v|
v.dig('firstPatchedVersion', 'identifier') if v['package']['name'] == package.name
}
return versions.sort unless versions.all? { |version| Gem::Version.correct?(version) }

first_patched_versions.sort
versions.sort_by { |version| Gem::Version.new(version) }
end

def patched_versions_for(package)
first_patched_versions = first_patched_versions_for(package)
patched_versions = []
*older, newest = first_patched_versions_for(package)
return [] unless newest

if !first_patched_versions.empty?
first_patched_versions[0..-2].each do |version|
patched_versions << "~> #{version}"
end
ranges = vulnerable_version_ranges_for(package)
versions = older + [newest] + ranges.flatten(1).map(&:last)
parseable = versions.all? { |version| Gem::Version.correct?(version) }

older.map { |patched|
parseable ? patched_until_next_range(patched, ranges) : "~> #{patched}"
} << ">= #{newest}"
end

# "~> 3.33.1" stops at 3.34, so it flags 3.34.0 when GitHub's next vulnerable range only starts
# at 4.0, and it covers 2.2.11 when a range starts there. The lowest start above the fix decides.
def patched_until_next_range(patched, ranges)
fix = Gem::Version.new(patched)
later, earlier = ranges.partition { |version_range| starts_after?(version_range, fix) }
return "~> #{patched}" unless later.any? && earlier.all? { |version_range| ends_by?(version_range, fix) }

patched_versions << ">= #{first_patched_versions.last}"
operator, start = later.first.first
next_start = Gem::Version.new(start)

if next_start.release < fix.bump
">= #{patched}, #{operator == '>' ? '<=' : '<'} #{start}"
elsif (minor_line = minor_line_ending_at(next_start, patched))
"~> #{minor_line}, >= #{patched}"
else
"~> #{patched}"
end
end

def starts_after?(version_range, version)
operator, start = version_range.first

%w[>= > =].include?(operator) && Gem::Version.new(start) > version
end

def ends_by?(version_range, version)
operator, upper = version_range.last

case operator
when '<' then Gem::Version.new(upper) <= version
when '<=', '=' then Gem::Version.new(upper) < version
end
end

# "3.33" for a fix in 3.33.1 when the next range starts at 4.0. A fourth segment is a backport,
# which a later X.Y.Z can predate: cgi 0.1.1 came out a year before the fix in 0.1.0.2.
def minor_line_ending_at(next_start, patched)
major, minor, *rest = patched.split('.')
return unless rest.size == 1 && !Gem::Version.new(patched).prerelease?

return patched_versions
minor_line = "#{major}.#{minor}"
minor_line if Gem::Version.new(minor_line).bump == next_start.release
end

def create(package)
Expand Down
140 changes: 140 additions & 0 deletions spec/github_advisory_sync_spec.rb
Original file line number Diff line number Diff line change
Expand Up @@ -71,4 +71,144 @@
expect(YAML.safe_load(yaml)).to eq(data)
end
end

# Each line pairs a vulnerable range with its first patched version (nil when GitHub lists none).
def generated(field, gem_name, lines)
advisory = described_class.new({})

lines.each do |vulnerable_range, first_patched|
advisory.vulnerabilities << {
"package" => { "name" => gem_name },
"vulnerableVersionRange" => vulnerable_range,
"firstPatchedVersion" => first_patched && { "identifier" => first_patched }
}
end

advisory.public_send("#{field}_for", described_class::Package.new(advisory, gem_name))
end

describe "#patched_versions_for" do
it "keeps later minors of an older major patched when the next range starts at the next major" do
expect(generated(:patched_versions, "avo", "< 3.33.1" => "3.33.1", ">= 4.0.0.beta.1, < 4.3.1" => "4.3.1"))
.to eq(["~> 3.33, >= 3.33.1", ">= 4.3.1"])
end

it "keeps a later minor flagged when a vulnerable range without a fix starts inside the major" do
expect(generated(:patched_versions, "avo", "< 3.33.1" => "3.33.1", "= 3.40.0" => nil,
">= 4.0.0.beta.1, < 4.3.1" => "4.3.1"))
.to eq(["~> 3.33.1", ">= 4.3.1"])
end

{
"starts below the fix and ends above it" => ">= 3.10.0, <= 3.40.0",
"has no lower bound and ends above it" => "< 4.0.0",
"starts below the fix and never ends" => ">= 3.10.0"
}.each do |shape, overlapping_range|
it "keeps a later minor flagged when another vulnerable range #{shape}" do
expect(generated(:patched_versions, "avo", "< 3.33.1" => "3.33.1", overlapping_range => nil,
">= 4.0.0.beta.1, < 4.3.1" => "4.3.1"))
.to eq(["~> 3.33.1", ">= 4.3.1"])
end
end

it "does not widen a four-segment fix, which later releases can predate" do
expect(generated(:patched_versions, "cgi", "< 0.1.0.2" => "0.1.0.2", ">= 1.0.0, < 1.0.5" => "1.0.5"))
.to eq(["~> 0.1.0.2", ">= 1.0.5"])
end

it "does not widen a prerelease fix, which sorts below its own minor" do
expect(generated(:patched_versions, "avo", "< 3.0.rc1" => "3.0.rc1", ">= 4.0.0, < 4.3.1" => "4.3.1"))
.to eq(["~> 3.0.rc1", ">= 4.3.1"])
end

it "leaves a release line flagged when GitHub lists no fix for it" do
expect(generated(:patched_versions, "activerecord", ">= 2.3.0, < 2.3.18" => "2.3.18",
">= 3.1.0, < 3.1.12" => "3.1.12",
">= 3.2.0, < 3.2.13" => "3.2.13"))
.to eq(["~> 2.3.18", "~> 3.1.12", ">= 3.2.13"])
end

it "keeps the prereleases of the next minor flagged" do
expect(generated(:patched_versions, "recurly", "< 2.0.13" => "2.0.13", ">= 2.1.0.beta1, < 2.1.11" => "2.1.11"))
.to eq(["~> 2.0.13", ">= 2.1.11"])
end

it "stops before a vulnerable range that starts in the same minor" do
expect(generated(:patched_versions, "bundler", "< 2.2.10" => "2.2.10", ">= 2.2.11, < 2.2.18" => "2.2.18"))
.to eq([">= 2.2.10, < 2.2.11", ">= 2.2.18"])
end

it "stops before a single vulnerable version in the same minor" do
expect(generated(:patched_versions, "bundler", "< 2.2.10" => "2.2.10", "= 2.2.12" => nil,
">= 3.0.0, < 3.0.2" => "3.0.2"))
.to eq([">= 2.2.10, < 2.2.12", ">= 3.0.2"])
end

it "includes the bound itself when the next range starts after it" do
expect(generated(:patched_versions, "bundler", "< 2.2.10" => "2.2.10", "> 2.2.12, < 2.2.18" => "2.2.18"))
.to eq([">= 2.2.10, <= 2.2.12", ">= 2.2.18"])
end

it "orders release lines by version, so 2.10 comes after 2.9" do
expect(generated(:patched_versions, "recurly", ">= 2.10.0, < 2.10.4" => "2.10.4", ">= 2.9.0, < 2.9.2" => "2.9.2"))
.to eq(["~> 2.9.2", ">= 2.10.4"])
end

it "keeps the plain constraints when RubyGems cannot parse a range bound" do
expect(generated(:patched_versions, "avo", "< 3.33.1" => "3.33.1", ">= v4.0.0, < 4.3.1" => "4.3.1"))
.to eq(["~> 3.33.1", ">= 4.3.1"])
end

it "keeps the plain constraints when RubyGems cannot parse an older fix" do
expect(generated(:patched_versions, "avo", "< 1.0.0" => "1.0.0-x86_64-linux", ">= 2.0.0, < 2.0.3" => "2.0.3",
">= 3.0.0, < 3.0.1" => "3.0.1"))
.to eq(["~> 1.0.0-x86_64-linux", "~> 2.0.3", ">= 3.0.1"])
end

it "keeps the plain constraints when RubyGems cannot parse the newest fix" do
expect(generated(:patched_versions, "avo", "< 3.33.1" => "3.33.1", ">= 4.0.0, <= 4.3.0" => "v4.3.1"))
.to eq(["~> 3.33.1", ">= v4.3.1"])
end

it "reads only the release lines of the gem it is asked about" do
advisory = described_class.new({})
{ "solidus_api" => "2.8.6", "solidus_core" => "3.0.1" }.each do |gem_name, first_patched|
advisory.vulnerabilities << {
"package" => { "name" => gem_name },
"vulnerableVersionRange" => "< #{first_patched}",
"firstPatchedVersion" => { "identifier" => first_patched }
}
end

expect(advisory.patched_versions_for(described_class::Package.new(advisory, "solidus_api")))
.to eq([">= 2.8.6"])
end
end

describe "#unaffected_versions_for" do
it "starts at the oldest vulnerable range by version, so 1.8 comes before 1.12" do
expect(generated(:unaffected_versions, "ember-source", ">= 1.12.0, < 1.12.2" => "1.12.2",
">= 1.8.0, < 1.11.4" => "1.11.4"))
.to eq(["< 1.8.0"])
end

it "lists nothing when a vulnerable range has no lower bound" do
expect(generated(:unaffected_versions, "avo", "<= 0.10.1" => "0.10.2", "> 0.9.0" => nil)).to be_nil
end

it "counts a single vulnerable version as a start" do
expect(generated(:unaffected_versions, "avo", "= 2.0.0" => nil, ">= 1.0.0, < 1.5.0" => "1.5.0"))
.to eq(["< 1.0.0"])
end

it "lists nothing when RubyGems cannot parse a range start" do
expect(generated(:unaffected_versions, "avo", ">= 1.0.0, < 1.0.5" => "1.0.5", ">= 0.5.0+build, < 0.5.3" => nil))
.to be_nil
end

it "leaves a start vulnerable when one range starts at it and another right after it" do
expect(generated(:unaffected_versions, "avo", "> 1.0.0, < 1.0.5" => "1.0.5", "= 1.0" => "1.0.1"))
.to eq(["< 1.0"])
end
end
end