mirror of
https://github.com/github/codeql.git
synced 2025-12-19 18:33:16 +01:00
1017 lines
20 KiB
Ruby
1017 lines
20 KiB
Ruby
def taint x
|
|
x
|
|
end
|
|
|
|
def sink x
|
|
puts x
|
|
end
|
|
|
|
def m1()
|
|
hash = {
|
|
:a => taint(1.1),
|
|
:b => 1,
|
|
c: taint(1.2),
|
|
d: 2,
|
|
'e': taint(1.3),
|
|
'f': 3,
|
|
'g' => taint(1.4),
|
|
'h' => 4,
|
|
0 => taint(1.5),
|
|
1 => 5
|
|
}
|
|
sink(hash[:a]) # $ hasValueFlow=1.1
|
|
sink(hash[:b])
|
|
sink(hash[:c]) # $ hasValueFlow=1.2
|
|
sink(hash[:d])
|
|
sink(hash['e']) # $ hasValueFlow=1.3
|
|
sink(hash['f'])
|
|
sink(hash['g']) # $ hasValueFlow=1.4
|
|
sink(hash['h'])
|
|
sink(hash[0]) # $ hasValueFlow=1.5
|
|
sink(hash[1])
|
|
end
|
|
|
|
m1()
|
|
|
|
def m2()
|
|
hash = Hash.new
|
|
hash[0] = taint(2.1)
|
|
hash[1] = 1
|
|
hash[:a] = taint(2.2)
|
|
hash[:b] = 2
|
|
hash['a'] = taint(2.3)
|
|
hash['b'] = 3
|
|
sink(hash[0]) # $ hasValueFlow=2.1
|
|
sink(hash[1])
|
|
sink(hash[:a]) # $ hasValueFlow=2.2 $ SPURIOUS hasValueFlow=2.3
|
|
sink(hash[:b])
|
|
sink(hash['a']) # $ hasValueFlow=2.3 $ SPURIOUS hasValueFlow=2.2
|
|
sink(hash['b'])
|
|
end
|
|
|
|
m2()
|
|
|
|
def m3()
|
|
hash1 = Hash[a: taint(3.1), b: 1]
|
|
sink(hash1[:a]) # $ hasValueFlow=3.1
|
|
sink(hash1[:b])
|
|
|
|
x = {a: taint(3.2), b: 1}
|
|
hash2 = Hash[x]
|
|
sink(hash2[:a]) # $ hasValueFlow=3.2
|
|
sink(hash2[:b]) # $ hasTaintFlow=3.2
|
|
|
|
hash3 = Hash[[[:a, taint(3.3)], [:b, 1]]]
|
|
sink(hash3[:a]) # $ hasValueFlow=3.3
|
|
sink(hash3[:b]) # $ SPURIOUS hasValueFlow=3.3
|
|
|
|
hash4 = Hash[:a, taint(3.4), :b, 1]
|
|
sink(hash4[:a]) # $ hasValueFlow=3.4
|
|
sink(hash4[:b])
|
|
|
|
hash5 = Hash["a" => taint(3.5), "b" => 1]
|
|
sink(hash5["a"]) # $ hasValueFlow=3.5
|
|
sink(hash5["b"])
|
|
|
|
hash6 = Hash[{"a" => taint(3.6), "b" => 1}]
|
|
sink(hash6["a"]) # $ hasValueFlow=3.6
|
|
sink(hash6["b"]) # $ hasTaintFlow=3.6
|
|
end
|
|
|
|
m3()
|
|
|
|
def m4()
|
|
hash1 = ::Hash.[](a: taint(4.1), b: 1)
|
|
sink(hash1[:a]) # $ hasValueFlow=4.1
|
|
sink(hash1[:b])
|
|
end
|
|
|
|
m4()
|
|
|
|
def m5()
|
|
hash = {
|
|
:a => taint(5.1),
|
|
:b => 1
|
|
}
|
|
hash2 = Hash.try_convert(hash)
|
|
sink(hash2[:a]) # $ hasValueFlow=5.1
|
|
sink(hash2[:b])
|
|
end
|
|
|
|
m5()
|
|
|
|
def m6()
|
|
hash = Hash.new
|
|
b = (hash[:a] = taint(6.1))
|
|
sink(b) # $ hasValueFlow=6.1
|
|
end
|
|
|
|
m6()
|
|
|
|
def m7(x)
|
|
hash = Hash.new
|
|
b = hash.store(:a, taint(7.1))
|
|
sink(hash[:a]) # $ hasValueFlow=7.1
|
|
sink(b) # $ hasValueFlow=7.1
|
|
hash.store(:a, 1)
|
|
sink(hash[:a])
|
|
c = hash.store(x, taint(7.2))
|
|
sink(hash[:a]) # $ hasValueFlow=7.2
|
|
sink(hash[10]) # $ hasValueFlow=7.2
|
|
sink(c) # $ hasValueFlow=7.2
|
|
end
|
|
|
|
m7("foo")
|
|
|
|
def m8()
|
|
hash = {
|
|
:a => taint(8.1),
|
|
:b => 1
|
|
}
|
|
hash.any? { |key_or_value|
|
|
sink(key_or_value) # $ hasValueFlow=8.1
|
|
}
|
|
hash.any? { |key,value|
|
|
sink(key)
|
|
sink(value) # $ hasValueFlow=8.1
|
|
}
|
|
end
|
|
|
|
m8()
|
|
|
|
def m9(x, y)
|
|
hash = {
|
|
:a => taint(10.1),
|
|
:b => 1
|
|
}
|
|
b = hash.assoc(:a)
|
|
sink(b[0])
|
|
sink(b[1]) # $ hasValueFlow=10.1
|
|
sink(b[x]) # $ hasValueFlow=10.1
|
|
c = hash.assoc(y)
|
|
sink(c[1]) # $ hasValueFlow=10.1
|
|
end
|
|
|
|
m9(1, :a)
|
|
|
|
def m10()
|
|
hash = {
|
|
:a => taint(9.1),
|
|
:b => 1
|
|
}
|
|
hash.clear
|
|
sink(hash[:a])
|
|
end
|
|
|
|
m10()
|
|
|
|
def m11()
|
|
hash = {
|
|
:a => taint(11.1),
|
|
:b => 1
|
|
}
|
|
a = hash.compact
|
|
sink(a[:a]) # $ hasValueFlow=11.1
|
|
sink(a[:b])
|
|
end
|
|
|
|
m11()
|
|
|
|
def m12()
|
|
hash = {
|
|
:a => taint(12.1),
|
|
:b => 1
|
|
}
|
|
a = hash.delete(:a)
|
|
sink(a) # $ hasValueFlow=12.1
|
|
sink(hash[:a])
|
|
end
|
|
|
|
m12()
|
|
|
|
def m13()
|
|
hash = {
|
|
:a => taint(13.1),
|
|
:b => 1
|
|
}
|
|
a = hash.delete_if do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=13.1
|
|
end
|
|
sink(a[:a]) # $ hasValueFlow=13.1
|
|
sink(hash[:a]) # $ hasValueFlow=13.1
|
|
sink(hash[0])
|
|
end
|
|
|
|
m13()
|
|
|
|
def m14()
|
|
hash = {
|
|
:a => taint(14.1),
|
|
:b => 1,
|
|
:c => {
|
|
:d => taint(14.2),
|
|
:e => 2
|
|
}
|
|
}
|
|
sink(hash.dig(:a)) # $ hasValueFlow=14.1
|
|
sink(hash.dig(:b))
|
|
sink(hash.dig(:c,:d)) # $ hasValueFlow=14.2
|
|
sink(hash.dig(:c,:e))
|
|
end
|
|
|
|
m14()
|
|
|
|
def m15()
|
|
hash = {
|
|
:a => taint(15.1),
|
|
:b => 1
|
|
}
|
|
x = hash.each do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=15.1
|
|
end
|
|
sink(x[:a]) # $ hasValueFlow=15.1
|
|
sink(x[:b])
|
|
end
|
|
|
|
m15()
|
|
|
|
def m16()
|
|
hash = {
|
|
:a => taint(16.1),
|
|
:b => 1
|
|
}
|
|
x = hash.each_key do |key|
|
|
sink key
|
|
end
|
|
sink(x[:a]) # $ hasValueFlow=16.1
|
|
sink(x[:b])
|
|
end
|
|
|
|
m16()
|
|
|
|
def m17()
|
|
hash = {
|
|
:a => taint(17.1),
|
|
:b => 1
|
|
}
|
|
x = hash.each_pair do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=17.1
|
|
end
|
|
sink(x[:a]) # $ hasValueFlow=17.1
|
|
sink(x[:b])
|
|
end
|
|
|
|
m17()
|
|
|
|
def m18()
|
|
hash = {
|
|
:a => taint(18.1),
|
|
:b => 1
|
|
}
|
|
x = hash.each_value do |value|
|
|
sink value # $ hasValueFlow=18.1
|
|
end
|
|
sink(x[:a]) # $ hasValueFlow=18.1
|
|
sink(x[:b])
|
|
end
|
|
|
|
m18()
|
|
|
|
def m19(x)
|
|
hash = {
|
|
:a => taint(19.1),
|
|
:b => 1,
|
|
:c => taint(19.2),
|
|
:d => taint(19.3)
|
|
}
|
|
x = hash.except(:a,x,:d)
|
|
sink(x[:a])
|
|
sink(x[:b])
|
|
sink(x[:c]) # $ hasValueFlow=19.2
|
|
sink(x[:d])
|
|
end
|
|
|
|
m19(:c)
|
|
|
|
def m20(x)
|
|
hash = {
|
|
:a => taint(20.1),
|
|
:b => 1,
|
|
:c => taint(20.2)
|
|
}
|
|
b = hash.fetch(taint(20.3)) do |x|
|
|
sink x # $ hasValueFlow=20.3
|
|
end
|
|
sink(b) # $ hasValueFlow=20.1 $ hasValueFlow=20.2
|
|
b = hash.fetch(:a)
|
|
sink b # $ hasValueFlow=20.1
|
|
b = hash.fetch(:a, taint(20.4))
|
|
sink b # $ hasValueFlow=20.1 $ hasValueFlow=20.4
|
|
b = hash.fetch(:b, taint(20.5))
|
|
sink b # $ hasValueFlow=20.5
|
|
b = hash.fetch(x, taint(20.6))
|
|
sink b # $ hasValueFlow=20.1 $ hasValueFlow=20.2 $ hasValueFlow=20.6
|
|
end
|
|
|
|
m20(:a)
|
|
|
|
def m21(x)
|
|
hash = {
|
|
:a => taint(21.1),
|
|
:b => 1,
|
|
:c => taint(21.2)
|
|
}
|
|
b = hash.fetch_values(taint(21.3)) do |x|
|
|
sink x # $ hasValueFlow=21.3
|
|
taint(21.4)
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=21.1 $ hasValueFlow=21.2 $ hasValueFlow=21.4
|
|
b = hash.fetch_values(:a)
|
|
sink(b[0]) # $ hasValueFlow=21.1
|
|
b = hash.fetch_values(:a,x)
|
|
sink(b[1]) # $ hasValueFlow=21.1 $ hasValueFlow=21.2
|
|
end
|
|
|
|
m21(:c)
|
|
|
|
def m22()
|
|
hash = {
|
|
:a => taint(22.1),
|
|
:b => 1,
|
|
:c => taint(22.2)
|
|
}
|
|
b = hash.filter do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=22.1 $ hasValueFlow=22.2
|
|
true
|
|
end
|
|
sink (b[:a]) # $ hasValueFlow=22.1
|
|
end
|
|
|
|
m22()
|
|
|
|
def m23()
|
|
hash = {
|
|
:a => taint(23.1),
|
|
:b => 1,
|
|
:c => taint(23.2)
|
|
}
|
|
hash.filter! do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=23.1 $ hasValueFlow=23.2
|
|
true
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=23.1
|
|
end
|
|
|
|
m23()
|
|
|
|
def m24()
|
|
hash = {
|
|
:a => taint(24.1),
|
|
:b => 1,
|
|
:c => taint(24.2)
|
|
}
|
|
b = hash.flatten
|
|
sink (b[1]) # $ hasValueFlow=24.1 $ hasValueFlow=24.2
|
|
end
|
|
|
|
m24()
|
|
|
|
def m25()
|
|
hash = {
|
|
:a => taint(25.1),
|
|
:b => 1,
|
|
:c => taint(25.2)
|
|
}
|
|
b = hash.keep_if do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=25.1 $ hasValueFlow=25.2
|
|
true
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=25.1
|
|
sink (b[:a]) # $ hasValueFlow=25.1
|
|
end
|
|
|
|
m25()
|
|
|
|
def m26()
|
|
hash1 = {
|
|
:a => taint(26.1),
|
|
:b => 1,
|
|
:c => taint(26.2)
|
|
}
|
|
hash2 = {
|
|
:d => taint(26.3),
|
|
:e => 1,
|
|
:f => taint(26.4)
|
|
}
|
|
hash = hash1.merge(hash2) do |key, old_value, new_value|
|
|
sink key
|
|
sink old_value # $ hasValueFlow=26.1 $ hasValueFlow=26.2 $ hasValueFlow=26.3 $ hasValueFlow=26.4
|
|
sink new_value # $ hasValueFlow=26.1 $ hasValueFlow=26.2 $ hasValueFlow=26.3 $ hasValueFlow=26.4
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=26.1
|
|
sink (hash[:b])
|
|
sink (hash[:c]) # $ hasValueFlow=26.2
|
|
sink (hash[:d]) # $ hasValueFlow=26.3
|
|
sink (hash[:e])
|
|
sink (hash[:f]) # $ hasValueFlow=26.4
|
|
end
|
|
|
|
m26()
|
|
|
|
def m27()
|
|
hash1 = {
|
|
:a => taint(27.1),
|
|
:b => 1,
|
|
:c => taint(27.2)
|
|
}
|
|
hash2 = {
|
|
:d => taint(27.3),
|
|
:e => 1,
|
|
:f => taint(27.4)
|
|
}
|
|
hash = hash1.merge!(hash2) do |key, old_value, new_value|
|
|
sink key
|
|
sink old_value # $ hasValueFlow=27.1 $ hasValueFlow=27.2 $ hasValueFlow=27.3 $ hasValueFlow=27.4
|
|
sink new_value # $ hasValueFlow=27.1 $ hasValueFlow=27.2 $ hasValueFlow=27.3 $ hasValueFlow=27.4
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=27.1
|
|
sink (hash[:b])
|
|
sink (hash[:c]) # $ hasValueFlow=27.2
|
|
sink (hash[:d]) # $ hasValueFlow=27.3
|
|
sink (hash[:e])
|
|
sink (hash[:f]) # $ hasValueFlow=27.4
|
|
|
|
sink (hash1[:a]) # $ hasValueFlow=27.1
|
|
sink (hash1[:b])
|
|
sink (hash1[:c]) # $ hasValueFlow=27.2
|
|
sink (hash1[:d]) # $ hasValueFlow=27.3
|
|
sink (hash1[:e])
|
|
sink (hash1[:f]) # $ hasValueFlow=27.4
|
|
end
|
|
|
|
m27()
|
|
|
|
def m28
|
|
hash = {
|
|
:a => taint(28.1),
|
|
:b => 1
|
|
}
|
|
b = hash.rassoc(0)
|
|
sink(b[0])
|
|
sink(b[1]) # $ hasValueFlow=28.1
|
|
end
|
|
|
|
m28()
|
|
|
|
def m29
|
|
hash = {
|
|
:a => taint(29.1),
|
|
:b => 1
|
|
}
|
|
b = hash.reject do |key,value|
|
|
sink key
|
|
sink value # $ hasValueFlow=29.1
|
|
value > 10
|
|
end
|
|
sink b[:a] # $ hasValueFlow=29.1
|
|
end
|
|
|
|
m29()
|
|
|
|
def m30
|
|
hash = {
|
|
:a => taint(30.1),
|
|
:b => 1
|
|
}
|
|
b = hash.reject! do |key,value|
|
|
sink key
|
|
sink value # $ hasValueFlow=30.1
|
|
value > 10
|
|
end
|
|
sink b[:a] # $ hasValueFlow=30.1
|
|
sink hash[:a] # $ hasValueFlow=30.1
|
|
end
|
|
|
|
m30()
|
|
|
|
def m31()
|
|
hash = {
|
|
:a => taint(31.1),
|
|
:b => 1,
|
|
:c => taint(31.2)
|
|
}
|
|
hash2 = {
|
|
:c => taint(31.3)
|
|
}
|
|
hash2.replace(hash)
|
|
sink (hash2[:a]) # $ hasValueFlow=31.1
|
|
sink (hash2[:b])
|
|
sink (hash2[:c]) # $ hasValueFlow=31.2
|
|
end
|
|
|
|
def m32()
|
|
hash = {
|
|
:a => taint(32.1),
|
|
:b => 1,
|
|
:c => taint(32.2)
|
|
}
|
|
b = hash.select do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=32.1 $ hasValueFlow=32.2
|
|
true
|
|
end
|
|
sink (b[:a]) # $ hasValueFlow=32.1
|
|
end
|
|
|
|
m32()
|
|
|
|
def m33()
|
|
hash = {
|
|
:a => taint(33.1),
|
|
:b => 1,
|
|
:c => taint(33.2)
|
|
}
|
|
hash.select! do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=33.1 $ hasValueFlow=33.2
|
|
true
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=33.1
|
|
end
|
|
|
|
m33()
|
|
|
|
def m34()
|
|
hash = {
|
|
:a => taint(34.1),
|
|
:b => 1,
|
|
:c => taint(34.2)
|
|
}
|
|
b = hash.shift
|
|
sink (hash[:a]) # $ hasValueFlow=34.1
|
|
sink (b[0])
|
|
sink (b[1]) # $ hasValueFlow=34.1 $ hasValueFlow=34.2
|
|
end
|
|
|
|
m34()
|
|
|
|
def m35(x)
|
|
hash = {
|
|
:a => taint(35.1),
|
|
:b => 1,
|
|
:c => taint(35.2)
|
|
}
|
|
b = hash.slice(:a, :b)
|
|
sink (b[:a]) # $ hasValueFlow=35.1
|
|
sink (b[:b])
|
|
sink (b[:c])
|
|
|
|
c = hash.slice(:a, x)
|
|
sink (c[:a]) # $ hasValueFlow=35.1
|
|
sink (c[:b])
|
|
sink (c[:c]) # $ hasValueFlow=35.2
|
|
end
|
|
|
|
m35(:c)
|
|
|
|
def m36()
|
|
hash = {
|
|
:a => taint(36.1),
|
|
:b => 1,
|
|
:c => taint(36.2)
|
|
}
|
|
a = hash.to_a
|
|
sink (a[0][0])
|
|
sink (a[0][1]) # $ hasValueFlow=36.1 $ hasValueFlow=36.2
|
|
end
|
|
|
|
m36()
|
|
|
|
def m37()
|
|
hash = {
|
|
:a => taint(37.1),
|
|
:b => 1,
|
|
:c => taint(37.2)
|
|
}
|
|
a = hash.to_h
|
|
sink (a[:a]) # $ hasValueFlow=37.1
|
|
sink (a[:b])
|
|
sink (a[:c]) # $ hasValueFlow=37.2
|
|
|
|
b = hash.to_h do |key, value|
|
|
sink key
|
|
sink value # $ hasValueFlow=37.1 $ hasValueFlow=37.2
|
|
[:d, taint(37.3)]
|
|
end
|
|
sink (b[:d]) # $ hasValueFlow=37.3
|
|
end
|
|
|
|
m37()
|
|
|
|
def m38()
|
|
hash = {
|
|
:a => taint(38.1),
|
|
:b => 1,
|
|
:c => taint(38.2)
|
|
}
|
|
a = hash.transform_keys {|key| key.to_s }
|
|
sink (a["a"]) # $ hasValueFlow=38.1 $ hasValueFlow=38.2
|
|
sink (a["b"]) # $ hasValueFlow=38.1 $ hasValueFlow=38.2
|
|
sink (a["c"]) # $ hasValueFlow=38.1 $ hasValueFlow=38.2
|
|
end
|
|
|
|
m38()
|
|
|
|
def m39(x)
|
|
hash = {
|
|
:a => taint(39.1),
|
|
:b => 1,
|
|
:c => taint(39.2)
|
|
}
|
|
hash[x] = taint(39.3)
|
|
|
|
hash.transform_keys! {|key| key.to_s }
|
|
sink (hash["a"]) # $ hasValueFlow=39.1 $ hasValueFlow=39.2 $ hasValueFlow=39.3
|
|
sink (hash["b"]) # $ hasValueFlow=39.1 $ hasValueFlow=39.2 $ hasValueFlow=39.3
|
|
sink (hash["c"]) # $ hasValueFlow=39.1 $ hasValueFlow=39.2 $ hasValueFlow=39.3
|
|
end
|
|
|
|
m39(:d)
|
|
|
|
def m40()
|
|
hash = {
|
|
:a => taint(40.1),
|
|
:b => 1,
|
|
:c => taint(40.2)
|
|
}
|
|
b = hash.transform_values do |value|
|
|
sink value # $ hasValueFlow=40.1 $ hasValueFlow=40.2
|
|
taint(40.3)
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=40.1
|
|
sink (b[:a]) # $ hasValueFlow=40.3
|
|
end
|
|
|
|
m40()
|
|
|
|
def m41()
|
|
hash = {
|
|
:a => taint(41.1),
|
|
:b => 1,
|
|
:c => taint(41.2)
|
|
}
|
|
hash.transform_values! do |value|
|
|
sink value # $ hasValueFlow=41.1 $ hasValueFlow=41.2
|
|
taint(41.3)
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=41.3
|
|
end
|
|
|
|
m41()
|
|
|
|
def m42()
|
|
hash1 = {
|
|
:a => taint(42.1),
|
|
:b => 1,
|
|
:c => taint(42.2)
|
|
}
|
|
hash2 = {
|
|
:d => taint(42.3),
|
|
:e => 1,
|
|
:f => taint(42.4)
|
|
}
|
|
hash = hash1.update(hash2) do |key, old_value, new_value|
|
|
sink key
|
|
sink old_value # $ hasValueFlow=42.1 $ hasValueFlow=42.2 $ hasValueFlow=42.3 $ hasValueFlow=42.4
|
|
sink new_value # $ hasValueFlow=42.1 $ hasValueFlow=42.2 $ hasValueFlow=42.3 $ hasValueFlow=42.4
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=42.1
|
|
sink (hash[:b])
|
|
sink (hash[:c]) # $ hasValueFlow=42.2
|
|
sink (hash[:d]) # $ hasValueFlow=42.3
|
|
sink (hash[:e])
|
|
sink (hash[:f]) # $ hasValueFlow=42.4
|
|
|
|
sink (hash1[:a]) # $ hasValueFlow=42.1
|
|
sink (hash1[:b])
|
|
sink (hash1[:c]) # $ hasValueFlow=42.2
|
|
sink (hash1[:d]) # $ hasValueFlow=42.3
|
|
sink (hash1[:e])
|
|
sink (hash1[:f]) # $ hasValueFlow=42.4
|
|
end
|
|
|
|
m42()
|
|
|
|
def m43()
|
|
hash = {
|
|
:a => taint(43.1),
|
|
:b => 1,
|
|
:c => taint(43.2)
|
|
}
|
|
a = hash.values
|
|
sink (a[0]) # $ hasValueFlow=43.1 # $ hasValueFlow=43.2
|
|
end
|
|
|
|
m43()
|
|
|
|
def m44(x)
|
|
hash = {
|
|
:a => taint(44.1),
|
|
:b => 1,
|
|
:c => taint(44.2)
|
|
}
|
|
b = hash.values_at(:a)
|
|
sink(b[0]) # $ hasValueFlow=44.1
|
|
b = hash.fetch_values(:a,x)
|
|
sink(b[1]) # $ hasValueFlow=44.1 $ hasValueFlow=44.2
|
|
end
|
|
|
|
m44(:c)
|
|
|
|
def m45()
|
|
hash1 = {
|
|
:a => taint(45.1),
|
|
:b => 1,
|
|
:c => taint(45.2)
|
|
}
|
|
hash2 = {
|
|
:d => taint(45.3),
|
|
:e => 2,
|
|
:f => taint(45.4)
|
|
}
|
|
hash = { **hash1, :g => taint(45.5), **hash2, :h => 3 }
|
|
sink(hash[:a]) # $ hasValueFlow=45.1
|
|
sink(hash[:b])
|
|
sink(hash[:c]) # $ hasValueFlow=45.2
|
|
sink(hash[:d]) # $ hasValueFlow=45.3
|
|
sink(hash[:e])
|
|
sink(hash[:f]) # $ hasValueFlow=45.4
|
|
sink(hash[:g]) # $ hasValueFlow=45.5
|
|
sink(hash[:h])
|
|
end
|
|
|
|
m45()
|
|
|
|
def m46(x)
|
|
hash = {
|
|
:a => taint(46.1),
|
|
:b => 1,
|
|
:c => taint(46.2),
|
|
:d => taint(46.3)
|
|
}
|
|
|
|
sink(hash[:a]) # $ hasValueFlow=46.1
|
|
sink(hash[:b])
|
|
sink(hash[:c]) # $ hasValueFlow=46.2
|
|
sink(hash[:d]) # $ hasValueFlow=46.3
|
|
|
|
x = hash.except!(:a, x, :d)
|
|
|
|
sink(x[:a])
|
|
sink(x[:b])
|
|
sink(x[:c]) # $ hasValueFlow=46.2
|
|
sink(x[:d])
|
|
|
|
sink(hash[:a])
|
|
sink(hash[:b])
|
|
sink(hash[:c]) # $ hasValueFlow=46.2
|
|
sink(hash[:d])
|
|
end
|
|
|
|
m46(:c)
|
|
|
|
def m47()
|
|
hash1 = {
|
|
:a => taint(47.1),
|
|
:b => 1,
|
|
:c => taint(47.2)
|
|
}
|
|
hash2 = {
|
|
:d => taint(47.3),
|
|
:e => 1,
|
|
:f => taint(47.4)
|
|
}
|
|
hash = hash1.deep_merge(hash2) do |key, old_value, new_value|
|
|
sink key
|
|
sink old_value # $ hasValueFlow=47.1 $ hasValueFlow=47.2 $ hasValueFlow=47.3 $ hasValueFlow=47.4
|
|
sink new_value # $ hasValueFlow=47.1 $ hasValueFlow=47.2 $ hasValueFlow=47.3 $ hasValueFlow=47.4
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=47.1
|
|
sink (hash[:b])
|
|
sink (hash[:c]) # $ hasValueFlow=47.2
|
|
sink (hash[:d]) # $ hasValueFlow=47.3
|
|
sink (hash[:e])
|
|
sink (hash[:f]) # $ hasValueFlow=47.4
|
|
end
|
|
|
|
m47()
|
|
|
|
def m48()
|
|
hash1 = {
|
|
:a => taint(48.1),
|
|
:b => 1,
|
|
:c => taint(48.2)
|
|
}
|
|
hash2 = {
|
|
:d => taint(48.3),
|
|
:e => 1,
|
|
:f => taint(48.4)
|
|
}
|
|
hash = hash1.deep_merge!(hash2) do |key, old_value, new_value|
|
|
sink key
|
|
sink old_value # $ hasValueFlow=48.1 $ hasValueFlow=48.2 $ hasValueFlow=48.3 $ hasValueFlow=48.4
|
|
sink new_value # $ hasValueFlow=48.1 $ hasValueFlow=48.2 $ hasValueFlow=48.3 $ hasValueFlow=48.4
|
|
end
|
|
sink (hash[:a]) # $ hasValueFlow=48.1
|
|
sink (hash[:b])
|
|
sink (hash[:c]) # $ hasValueFlow=48.2
|
|
sink (hash[:d]) # $ hasValueFlow=48.3
|
|
sink (hash[:e])
|
|
sink (hash[:f]) # $ hasValueFlow=48.4
|
|
|
|
sink (hash1[:a]) # $ hasValueFlow=48.1
|
|
sink (hash1[:b])
|
|
sink (hash1[:c]) # $ hasValueFlow=48.2
|
|
sink (hash1[:d]) # $ hasValueFlow=48.3
|
|
sink (hash1[:e])
|
|
sink (hash1[:f]) # $ hasValueFlow=48.4
|
|
end
|
|
|
|
m48()
|
|
|
|
def m49()
|
|
hash1 = {
|
|
a: taint(49.1),
|
|
b: 1,
|
|
c: taint(49.2)
|
|
}
|
|
hash2 = {
|
|
d: taint(49.3),
|
|
e: 1,
|
|
f: taint(49.4)
|
|
}
|
|
|
|
hash3 = hash1.reverse_merge(hash2)
|
|
sink (hash3[:a]) # $ hasValueFlow=49.1
|
|
sink (hash3[:b])
|
|
sink (hash3[:c]) # $ hasValueFlow=49.2
|
|
sink (hash3[:d]) # $ hasValueFlow=49.3
|
|
sink (hash3[:e])
|
|
sink (hash3[:f]) # $ hasValueFlow=49.4
|
|
|
|
# alias for reverse_merge
|
|
hash4 = hash1.with_defaults(hash2)
|
|
sink (hash4[:a]) # $ hasValueFlow=49.1
|
|
sink (hash4[:b])
|
|
sink (hash4[:c]) # $ hasValueFlow=49.2
|
|
sink (hash4[:d]) # $ hasValueFlow=49.3
|
|
sink (hash4[:e])
|
|
sink (hash4[:f]) # $ hasValueFlow=49.4
|
|
end
|
|
|
|
m49()
|
|
|
|
def m50()
|
|
hash1 = {
|
|
a: taint(50.1),
|
|
b: 1,
|
|
c: taint(50.2)
|
|
}
|
|
hash2 = {
|
|
d: taint(50.3),
|
|
e: 1,
|
|
f: taint(50.4)
|
|
}
|
|
|
|
hash = hash1.reverse_merge!(hash2)
|
|
sink (hash[:a]) # $ hasValueFlow=50.1
|
|
sink (hash[:b])
|
|
sink (hash[:c]) # $ hasValueFlow=50.2
|
|
sink (hash[:d]) # $ hasValueFlow=50.3
|
|
sink (hash[:e])
|
|
sink (hash[:f]) # $ hasValueFlow=50.4
|
|
|
|
sink (hash1[:a]) # $ hasValueFlow=50.1
|
|
sink (hash1[:b])
|
|
sink (hash1[:c]) # $ hasValueFlow=50.2
|
|
sink (hash1[:d]) # $ hasValueFlow=50.3
|
|
sink (hash1[:e])
|
|
sink (hash1[:f]) # $ hasValueFlow=50.4
|
|
end
|
|
|
|
m50()
|
|
|
|
def m51()
|
|
hash1 = {
|
|
a: taint(51.1),
|
|
b: 1,
|
|
c: taint(51.2)
|
|
}
|
|
hash2 = {
|
|
d: taint(51.3),
|
|
e: 1,
|
|
f: taint(51.4)
|
|
}
|
|
|
|
hash = hash1.with_defaults!(hash2)
|
|
sink (hash[:a]) # $ hasValueFlow=51.1
|
|
sink (hash[:b])
|
|
sink (hash[:c]) # $ hasValueFlow=51.2
|
|
sink (hash[:d]) # $ hasValueFlow=51.3
|
|
sink (hash[:e])
|
|
sink (hash[:f]) # $ hasValueFlow=51.4
|
|
|
|
sink (hash1[:a]) # $ hasValueFlow=51.1
|
|
sink (hash1[:b])
|
|
sink (hash1[:c]) # $ hasValueFlow=51.2
|
|
sink (hash1[:d]) # $ hasValueFlow=51.3
|
|
sink (hash1[:e])
|
|
sink (hash1[:f]) # $ hasValueFlow=51.4
|
|
end
|
|
|
|
m51()
|
|
|
|
def m52()
|
|
hash1 = {
|
|
a: taint(52.1),
|
|
b: 1,
|
|
c: taint(52.2)
|
|
}
|
|
hash2 = {
|
|
d: taint(52.3),
|
|
e: 1,
|
|
f: taint(52.4)
|
|
}
|
|
|
|
hash = hash1.with_defaults!(hash2)
|
|
sink (hash[:a]) # $ hasValueFlow=52.1
|
|
sink (hash[:b])
|
|
sink (hash[:c]) # $ hasValueFlow=52.2
|
|
sink (hash[:d]) # $ hasValueFlow=52.3
|
|
sink (hash[:e])
|
|
sink (hash[:f]) # $ hasValueFlow=52.4
|
|
|
|
sink (hash1[:a]) # $ hasValueFlow=52.1
|
|
sink (hash1[:b])
|
|
sink (hash1[:c]) # $ hasValueFlow=52.2
|
|
sink (hash1[:d]) # $ hasValueFlow=52.3
|
|
sink (hash1[:e])
|
|
sink (hash1[:f]) # $ hasValueFlow=52.4
|
|
end
|
|
|
|
m52()
|
|
|
|
def m53(i)
|
|
h = Hash[a: 1, b: taint(53), c: 2]
|
|
sink(h[:a])
|
|
sink(h[:b]) # $ hasValueFlow=53
|
|
sink(h[:c])
|
|
sink(h[i]) # $ hasValueFlow=53
|
|
end
|
|
|
|
m53(:b)
|
|
|
|
class M54
|
|
class Hash
|
|
def self.[](**kwargs)
|
|
::Hash.new
|
|
end
|
|
end
|
|
|
|
def m54(i)
|
|
h = Hash[a: 0, b: taint(54.1), c: 2]
|
|
sink(h[:a])
|
|
sink(h[:b])
|
|
sink(h[:c])
|
|
sink(h[i])
|
|
|
|
h2 = ::Hash[a: 0, b: taint(54.2), c: 2]
|
|
sink(h2[:a])
|
|
sink(h2[:b]) # $ hasValueFlow=54.2
|
|
sink(h2[:c])
|
|
sink(h2[i]) # $ hasValueFlow=54.2
|
|
end
|
|
end
|
|
|
|
M54.new.m54(:b)
|
|
|
|
def m55
|
|
h = taint(55.1)
|
|
keys = h.keys
|
|
sink(keys[f()]) # $ hasTaintFlow=55.1
|
|
end
|
|
|
|
def m56
|
|
h = { a: taint(56.1), taint(56.2) => :b }
|
|
h.map do |k, v|
|
|
sink(v) # $ hasValueFlow=56.1
|
|
sink(k) # $ MISSING: hasValueFlow=56.2 SPURIOUS: hasValueFlow=56.1
|
|
end
|
|
end
|