664 lines
23 KiB
Ruby
664 lines
23 KiB
Ruby
# ©AngelaMos | 2026
|
|
# parser_test.rb
|
|
|
|
require_relative "../test_helper"
|
|
require_relative "../support/adversarial_corpus"
|
|
|
|
module Rube
|
|
module Marshal
|
|
class ParserTest < Minitest::Test
|
|
def parse(blob)
|
|
Parser.new(blob).parse
|
|
end
|
|
|
|
def roundtrip(object)
|
|
parse(::Marshal.dump(object)).root
|
|
end
|
|
|
|
def test_rejects_empty_stream
|
|
assert_raises(TruncatedStreamError) { parse("") }
|
|
end
|
|
|
|
def test_rejects_header_only
|
|
assert_raises(TruncatedStreamError) { parse("\x04\x08") }
|
|
end
|
|
|
|
def test_rejects_wrong_major_version
|
|
assert_raises(UnsupportedVersionError) { parse("\x05\x08\x30") }
|
|
end
|
|
|
|
def test_rejects_future_minor_version
|
|
assert_raises(UnsupportedVersionError) { parse("\x04\x09\x30") }
|
|
end
|
|
|
|
def test_accepts_older_minor_version
|
|
assert_equal :nil, parse("\x04\x07\x30").root.type
|
|
end
|
|
|
|
def ruby_accepts_stream?(bytes)
|
|
::Marshal.load(bytes)
|
|
true
|
|
rescue ArgumentError, TypeError
|
|
false
|
|
end
|
|
|
|
def parser_accepts_stream?(bytes)
|
|
parse(bytes)
|
|
true
|
|
rescue StreamError
|
|
false
|
|
end
|
|
|
|
def test_header_version_agreement_with_real_ruby
|
|
probes = (0..9).to_h { |minor| ["4.#{minor}", "\x04#{minor.chr}0".b] }
|
|
observed = probes.transform_values { |bytes| ruby_accepts_stream?(bytes) }
|
|
|
|
assert_includes observed.values, true, "no version accepted, so the oracle is dead"
|
|
assert_includes observed.values, false, "every version accepted, so the oracle proves nothing"
|
|
|
|
mismatches = probes.filter_map do |label, bytes|
|
|
mine = parser_accepts_stream?(bytes)
|
|
next if mine == observed.fetch(label)
|
|
|
|
"#{label}: ruby=#{observed.fetch(label)} parser=#{mine}"
|
|
end
|
|
|
|
assert_empty mismatches,
|
|
"the parser is a forensic tool and must accept exactly what Marshal.load " \
|
|
"accepts:\n #{mismatches.join("\n ")}"
|
|
end
|
|
|
|
def test_result_reports_the_declared_version
|
|
result = parse("\x04\x07\x30")
|
|
assert_equal [4, 7], [result.major, result.minor]
|
|
refute_predicate result, :canonical_version?
|
|
|
|
assert_predicate parse(::Marshal.dump(nil)), :canonical_version?
|
|
end
|
|
|
|
class RoleFixture; end
|
|
|
|
def class_name_slot_streams
|
|
name = "Rube::Marshal::ParserTest::RoleFixture"
|
|
symbol = AdversarialCorpus.sym(name)
|
|
|
|
{
|
|
"symbol" => AdversarialCorpus.stream("o#{symbol}#{AdversarialCorpus.fixnum(0)}"),
|
|
"ivar wrapped symbol" => AdversarialCorpus.stream(
|
|
"oI#{symbol}#{AdversarialCorpus.fixnum(1)}#{AdversarialCorpus.sym('E')}T#{AdversarialCorpus.fixnum(0)}"
|
|
),
|
|
"symlink" => AdversarialCorpus.stream(
|
|
"[#{AdversarialCorpus.fixnum(2)}#{symbol}o#{AdversarialCorpus.symlink(0)}#{AdversarialCorpus.fixnum(0)}"
|
|
),
|
|
"fixnum" => AdversarialCorpus.stream("oi\x0a#{AdversarialCorpus.fixnum(0)}"),
|
|
"string" => AdversarialCorpus.stream("o#{AdversarialCorpus.str(name)}#{AdversarialCorpus.fixnum(0)}"),
|
|
"nil" => AdversarialCorpus.stream("o0#{AdversarialCorpus.fixnum(0)}")
|
|
}
|
|
end
|
|
|
|
def test_class_name_slot_role_agreement_with_real_ruby
|
|
observed = class_name_slot_streams.transform_values { |bytes| ruby_accepts_stream?(bytes) }
|
|
|
|
assert_includes observed.values, true, "no slot accepted, so the oracle is dead"
|
|
assert_includes observed.values, false, "every slot accepted, so the oracle proves nothing"
|
|
|
|
mismatches = class_name_slot_streams.filter_map do |label, bytes|
|
|
mine = parser_accepts_stream?(bytes)
|
|
next if mine == observed.fetch(label)
|
|
|
|
"#{label}: ruby=#{observed.fetch(label)} parser=#{mine}"
|
|
end
|
|
|
|
assert_empty mismatches,
|
|
"a class-name slot accepts only a symbol, an ivar-wrapped symbol, or a " \
|
|
"symlink:\n #{mismatches.join("\n ")}"
|
|
end
|
|
|
|
def test_rejects_unknown_tag
|
|
assert_raises(UnknownTagError) { parse("\x04\x08\x00") }
|
|
end
|
|
|
|
def test_rejects_trailing_bytes
|
|
assert_raises(TrailingBytesError) { parse(::Marshal.dump(nil) + "junk") }
|
|
end
|
|
|
|
def test_parses_nil
|
|
assert_equal :nil, roundtrip(nil).type
|
|
end
|
|
|
|
def test_parses_booleans
|
|
assert_equal true, roundtrip(true).value
|
|
assert_equal false, roundtrip(false).value
|
|
end
|
|
|
|
def test_parses_fixnum_across_every_encoding_width
|
|
[0, 1, 5, 122, 123, 255, 256, 65_535, 65_536, 1_073_741_823,
|
|
-1, -123, -124, -256, -65_536, -1_073_741_824].each do |n|
|
|
assert_equal n, roundtrip(n).value, "fixnum #{n} did not round-trip"
|
|
end
|
|
end
|
|
|
|
def test_parses_bignum_both_signs
|
|
[2**64, -(2**64), 2**128 + 7].each do |n|
|
|
assert_equal n, roundtrip(n).value, "bignum #{n} did not round-trip"
|
|
end
|
|
end
|
|
|
|
def ruby_rejects_bignum_sign?(bytes)
|
|
::Marshal.load(bytes)
|
|
false
|
|
rescue ArgumentError, TypeError
|
|
true
|
|
end
|
|
|
|
def parser_rejects_bignum_sign?(bytes)
|
|
parse(bytes)
|
|
false
|
|
rescue StreamError
|
|
true
|
|
end
|
|
|
|
def test_bignum_sign_byte_agreement_with_real_ruby
|
|
probes = AdversarialCorpus::BIGNUM_SIGNS.to_h do |sign|
|
|
[sign, AdversarialCorpus.stream(AdversarialCorpus.bignum(sign, 1))]
|
|
end
|
|
observed = probes.transform_values { |bytes| ruby_rejects_bignum_sign?(bytes) }
|
|
|
|
assert_includes observed.values, true, "no sign was rejected, so the oracle is dead"
|
|
assert_includes observed.values, false, "every sign was rejected, so the oracle proves nothing"
|
|
|
|
mismatches = probes.filter_map do |sign, bytes|
|
|
mine = parser_rejects_bignum_sign?(bytes)
|
|
next if mine == observed.fetch(sign)
|
|
|
|
"#{sign.inspect}: ruby_rejects=#{observed.fetch(sign)} parser_rejects=#{mine}"
|
|
end
|
|
|
|
assert_empty mismatches, "bignum sign handling diverges from Marshal.load:\n #{mismatches.join("\n ")}"
|
|
end
|
|
|
|
def test_bignum_magnitude_is_charged_the_same_budget_as_a_string
|
|
words = AdversarialCorpus::BIGNUM_HUGE_WORDS
|
|
magnitude = words * AdversarialCorpus::BIGNUM_WORD_BYTES
|
|
limits = Limits.new
|
|
|
|
big = AdversarialCorpus.stream(AdversarialCorpus.bignum("+", words))
|
|
str = AdversarialCorpus.stream(AdversarialCorpus.str("A" * magnitude))
|
|
|
|
assert_raises(LimitExceededError, "a #{magnitude}-byte string is rejected") do
|
|
Parser.new(str, limits: limits).parse
|
|
end
|
|
assert_raises(LimitExceededError, "so #{magnitude} bignum magnitude bytes must be too") do
|
|
Parser.new(big, limits: limits).parse
|
|
end
|
|
end
|
|
|
|
def test_parses_float
|
|
assert_in_delta 3.5, roundtrip(3.5).value, 0.0
|
|
end
|
|
|
|
def test_parses_symbol
|
|
assert_equal :marshal_load, roundtrip(:marshal_load).value
|
|
end
|
|
|
|
def test_parses_string_through_ivar_wrapper
|
|
node = roundtrip("hello")
|
|
assert_equal :string, node.type
|
|
assert_equal "hello", node.value
|
|
end
|
|
|
|
def test_parses_array
|
|
node = roundtrip([1, 2, 3])
|
|
assert_equal :array, node.type
|
|
assert_equal [1, 2, 3], node.children.map(&:value)
|
|
end
|
|
|
|
def test_parses_nested_array
|
|
node = roundtrip([1, [2, [3]]])
|
|
assert_equal 3, node.children.last.children.last.children.first.value
|
|
end
|
|
|
|
def test_parses_hash
|
|
node = roundtrip({ a: 1 })
|
|
assert_equal :hash, node.type
|
|
assert_equal 1, node.children.length
|
|
end
|
|
|
|
def test_object_links_are_zero_indexed
|
|
cyclic = []
|
|
cyclic << cyclic
|
|
node = roundtrip(cyclic)
|
|
link = node.children.first
|
|
assert_equal :object_link, link.type
|
|
assert_equal 0, link.value
|
|
end
|
|
|
|
class LinkStringSubclass < String; end
|
|
|
|
module LinkExtension; end
|
|
|
|
def link_probe(first)
|
|
shared = +"ccc"
|
|
::Marshal.dump([first, +"bbb", shared, shared])
|
|
end
|
|
|
|
def link_probes
|
|
{
|
|
"plain object (o)" => link_probe(Object.new),
|
|
"user_class (C)" => link_probe(LinkStringSubclass.new("aaa")),
|
|
"extended (e)" => link_probe((+"aaa").extend(LinkExtension))
|
|
}
|
|
end
|
|
|
|
def test_object_link_indices_match_ruby_for_wrapper_tags
|
|
mismatches = link_probes.filter_map do |label, blob|
|
|
link = parse(blob).nodes.find { |node| node.type == :object_link }
|
|
flunk "#{label}: fixture carries no object link, so it proves nothing" unless link
|
|
|
|
ruby_target = ::Marshal.load(blob)[3]
|
|
next if link.link_target&.value == ruby_target
|
|
|
|
"#{label}: index #{link.value} resolves to " \
|
|
"#{link.link_target&.value.inspect}, Ruby resolves it to #{ruby_target.inspect}"
|
|
end
|
|
|
|
assert_empty mismatches,
|
|
"a wrapper tag must occupy the same object-table slot Ruby gives it:\n " \
|
|
"#{mismatches.join("\n ")}"
|
|
end
|
|
|
|
def test_rejects_out_of_bounds_object_link
|
|
assert_raises(InvalidLinkError) { parse("\x04\x08@\x0a") }
|
|
end
|
|
|
|
def test_rejects_out_of_bounds_symlink
|
|
assert_raises(InvalidLinkError) { parse("\x04\x08;\x0a") }
|
|
end
|
|
|
|
def test_resolves_symlink_to_prior_symbol
|
|
node = roundtrip([:same, :same])
|
|
assert_equal :symlink, node.children.last.type
|
|
assert_equal :same, node.children.last.value
|
|
end
|
|
|
|
def test_extracts_class_name_from_plain_object
|
|
blob = ::Marshal.dump(Fixture.new)
|
|
result = parse(blob)
|
|
assert_includes result.class_names, "Rube::Marshal::ParserTest::Fixture"
|
|
end
|
|
|
|
def test_extracts_class_name_without_instantiating
|
|
refute Fixture.instantiated, "parser must not construct the class"
|
|
parse(::Marshal.dump(Fixture.new))
|
|
refute Fixture.instantiated, "parser instantiated a class during parse"
|
|
end
|
|
|
|
def test_flags_usermarshal_as_sink
|
|
result = parse(::Marshal.dump(UserMarshalFixture.new))
|
|
sink = result.sinks.first
|
|
refute_nil sink
|
|
assert_equal "marshal_load", sink.sink_method
|
|
assert_equal "Rube::Marshal::ParserTest::UserMarshalFixture", sink.class_name
|
|
end
|
|
|
|
def test_flags_userdef_as_sink
|
|
result = parse(::Marshal.dump(UserDefFixture.new))
|
|
assert_equal "_load", result.sinks.first.sink_method
|
|
end
|
|
|
|
def test_clean_payload_reports_no_sinks
|
|
assert_empty parse(::Marshal.dump([1, "two", :three, { a: 1 }])).sinks
|
|
end
|
|
|
|
def test_rejects_truncated_string_body
|
|
assert_raises(TruncatedStreamError) { parse("\x04\x08\"\x0aab") }
|
|
end
|
|
|
|
def test_rejects_truncated_array_elements
|
|
assert_raises(TruncatedStreamError) { parse("\x04\x08[\x08i\x06") }
|
|
end
|
|
|
|
def test_rejects_truncated_multibyte_fixnum
|
|
assert_raises(TruncatedStreamError) { parse("\x04\x08i\x03\x01") }
|
|
end
|
|
|
|
def test_rejects_negative_array_count
|
|
assert_raises(MalformedCountError) { parse("\x04\x08[\xFA") }
|
|
end
|
|
|
|
def test_rejects_negative_hash_count
|
|
assert_raises(MalformedCountError) { parse("\x04\x08{\xFA") }
|
|
end
|
|
|
|
def test_rejects_negative_bignum_word_count
|
|
assert_raises(MalformedCountError) { parse("\x04\x08l+\xFA") }
|
|
end
|
|
|
|
def test_rejects_negative_instance_variable_count
|
|
assert_raises(MalformedCountError) { parse("\x04\x08I\"\x06a\xFA") }
|
|
end
|
|
|
|
def test_rejects_negative_string_length
|
|
assert_raises(MalformedCountError) { parse("\x04\x08\"\xFA") }
|
|
end
|
|
|
|
def test_rejects_negative_struct_member_count
|
|
assert_raises(MalformedCountError) { parse("\x04\x08S:\x06A\xFA") }
|
|
end
|
|
|
|
def test_negative_length_is_caught_by_the_count_guard_not_the_take_guard
|
|
error = assert_raises(MalformedCountError) { parse("\x04\x08\"\xFA") }
|
|
assert_includes error.message, Constants::ROLE_LENGTH,
|
|
"take's own guard caught it, so read_count is not enforcing anything"
|
|
end
|
|
|
|
def test_negative_counts_never_rewind_the_cursor
|
|
parser = Parser.new("\x04\x08\"\xFA")
|
|
before = parser.instance_variable_get(:@position)
|
|
assert_raises(MalformedCountError) { parser.parse }
|
|
assert_operator parser.instance_variable_get(:@position), :>=, before,
|
|
"the cursor moved backwards, which is a loop primitive"
|
|
end
|
|
|
|
def test_parses_regexp_and_consumes_its_options_byte
|
|
node = roundtrip(/pattern/i)
|
|
assert_equal :regexp, node.type
|
|
assert_equal "pattern", node.value
|
|
end
|
|
|
|
def test_parses_regexp_nested_in_a_collection
|
|
node = roundtrip([/first/, /second/mx])
|
|
assert_equal %w[first second], node.children.map(&:value)
|
|
end
|
|
|
|
def test_regexp_options_byte_is_not_mistaken_for_the_next_value
|
|
node = roundtrip([/pattern/ix, :sentinel])
|
|
assert_equal :symbol, node.children.last.type
|
|
assert_equal :sentinel, node.children.last.value
|
|
end
|
|
|
|
def test_every_malformed_count_stays_inside_the_stream_error_hierarchy
|
|
["\x04\x08[\xFA", "\x04\x08{\xFA", "\x04\x08l+\xFA", "\x04\x08\"\xFA"].each do |blob|
|
|
parse(blob)
|
|
flunk "expected #{blob.inspect} to be rejected"
|
|
rescue StreamError
|
|
pass
|
|
rescue StandardError => e
|
|
flunk "#{blob.inspect} leaked #{e.class} outside StreamError"
|
|
end
|
|
end
|
|
|
|
def test_rejects_negative_object_link_index
|
|
assert_raises(InvalidLinkError) { parse("\x04\x08[\x06@\xFA") }
|
|
end
|
|
|
|
def test_rejects_negative_symlink_index
|
|
assert_raises(InvalidLinkError) { parse("\x04\x08[\x07:\x06a;\xFA") }
|
|
end
|
|
|
|
def test_sink_in_an_instance_variable_name_position_is_still_reported
|
|
result = parse("\x04\x08I\"\x06a\x06u:\x09Evil\x06x0")
|
|
assert_includes result.class_names, "Evil"
|
|
assert_equal ["Evil#_load"], result.sinks.map { |s| "#{s.class_name}##{s.sink_method}" }
|
|
end
|
|
|
|
def tripwires(blob)
|
|
parse(blob).sinks.select { |node| node.class_name == AdversarialCorpus::TRIPWIRE_CLASS }
|
|
end
|
|
|
|
def test_class_name_node_is_traversable
|
|
result = parse(::Marshal.dump(Fixture.new))
|
|
names = result.nodes.select { |node| node.type == :symbol }.map(&:value)
|
|
assert_includes names, :"Rube::Marshal::ParserTest::Fixture"
|
|
end
|
|
|
|
def test_class_name_slot_gadget_is_reachable_in_every_slot
|
|
blind = AdversarialCorpus::CLASS_NAME_SLOTS.reject { |_slot, bytes| tripwires(bytes).any? }
|
|
|
|
assert_empty blind.keys,
|
|
"class-name node discarded, hiding a sink, in: #{blind.keys.join(', ')}"
|
|
end
|
|
|
|
def test_class_name_slot_gadget_is_counted_once_per_slot
|
|
duplicated = AdversarialCorpus::CLASS_NAME_SLOTS.select { |_slot, bytes| tripwires(bytes).length > 1 }
|
|
|
|
assert_empty duplicated.keys, "a node must be traversed exactly once"
|
|
end
|
|
|
|
def test_distinct_instance_variable_names_reach_the_sink
|
|
assert_equal 1, tripwires(AdversarialCorpus::IVAR_DISTINCT_NAMES_CONTROL).length,
|
|
"control failed, so the collision tests below would prove nothing"
|
|
end
|
|
|
|
def test_duplicate_instance_variable_names_do_not_delete_a_sink
|
|
blind = AdversarialCorpus::IVAR_COLLISION_SHAPES.reject { |_shape, bytes| tripwires(bytes).any? }
|
|
|
|
assert_empty blind.keys,
|
|
"duplicate ivar name deleted a subtree in: #{blind.keys.join(', ')}"
|
|
end
|
|
|
|
def test_duplicate_instance_variable_names_retain_both_values
|
|
AdversarialCorpus::IVAR_COLLISION_SHAPES.each do |shape, bytes|
|
|
nils = parse(bytes).nodes.count { |node| node.type == :nil }
|
|
assert_equal 2, nils, "#{shape} lost an instance variable value node"
|
|
end
|
|
end
|
|
|
|
def test_rejects_depth_beyond_limit
|
|
deep = "\x04\x08" + ("[\x06" * (Constants::DEFAULT_MAX_DEPTH + 5)) + "0"
|
|
assert_raises(DepthLimitError) { parse(deep) }
|
|
end
|
|
|
|
def test_parser_defaults_to_bounded_limits_not_permissive
|
|
blob = AdversarialCorpus.stream(AdversarialCorpus.sym("A" * AdversarialCorpus::LONG_NAME_BYTES))
|
|
|
|
assert_raises(LimitExceededError, "a bare Parser.new must not be unbounded") do
|
|
Parser.new(blob).parse
|
|
end
|
|
assert_equal :symbol, Parser.new(blob, limits: Limits.permissive).parse.root.type,
|
|
"control: permissive must admit it, or a ceiling is not what rejected it"
|
|
end
|
|
|
|
def test_default_depth_ceiling_is_the_limits_value_not_the_permissive_one
|
|
deep = AdversarialCorpus.stream(AdversarialCorpus.array_nest(Limits::DEFAULT_MAX_DEPTH + 5) + "0")
|
|
|
|
assert_raises(DepthLimitError) { Parser.new(deep).parse }
|
|
assert_operator Limits::DEFAULT_MAX_DEPTH, :<, Constants::DEFAULT_MAX_DEPTH,
|
|
"control: the two depth constants must differ, or this test cannot discriminate"
|
|
end
|
|
|
|
def test_honours_custom_depth_limit
|
|
blob = ::Marshal.dump([[[1]]])
|
|
assert_raises(DepthLimitError) { Parser.new(blob, max_depth: 2).parse }
|
|
end
|
|
|
|
def test_instance_variable_wrapper_counts_toward_the_depth_limit
|
|
chain = AdversarialCorpus.stream(
|
|
AdversarialCorpus.ivar_chain(Constants::DEFAULT_MAX_DEPTH + 5)
|
|
)
|
|
assert_raises(DepthLimitError) { parse(chain) }
|
|
end
|
|
|
|
def test_deep_instance_variable_chain_rejects_before_the_ruby_stack_runs_out
|
|
chain = AdversarialCorpus.stream(
|
|
AdversarialCorpus.ivar_chain(AdversarialCorpus::IVAR_CHAIN_DEPTH)
|
|
)
|
|
assert_raises(DepthLimitError) { parse(chain) }
|
|
end
|
|
|
|
def parse_class_name_slot_at_ceiling(tail)
|
|
depth = AdversarialCorpus::USERDEF_NEST_DEPTH
|
|
blob = AdversarialCorpus.stream(AdversarialCorpus.array_nest(depth) + tail)
|
|
Parser.new(blob, max_depth: depth + 1).parse
|
|
end
|
|
|
|
def test_object_class_name_slot_is_charged_the_enclosing_depth
|
|
tail = "o#{AdversarialCorpus.sym(AdversarialCorpus::OBJECT_CLASS)}#{AdversarialCorpus.fixnum(0)}"
|
|
assert_raises(DepthLimitError, "control failed, so the userdef test proves nothing") do
|
|
parse_class_name_slot_at_ceiling(tail)
|
|
end
|
|
end
|
|
|
|
def test_userdef_class_name_slot_does_not_reset_the_depth_budget
|
|
tail = "u#{AdversarialCorpus.sym(AdversarialCorpus::OBJECT_CLASS)}#{AdversarialCorpus.fixnum(1)}x"
|
|
assert_raises(DepthLimitError) { parse_class_name_slot_at_ceiling(tail) }
|
|
end
|
|
|
|
def load_watcher
|
|
fired = false
|
|
tracer = TracePoint.new(:call, :c_call) do |tp|
|
|
fired = true if tp.method_id == :load && tp.self.equal?(::Marshal)
|
|
end
|
|
tracer.enable { yield }
|
|
fired
|
|
end
|
|
|
|
def test_load_watcher_oracle_is_live
|
|
assert load_watcher { ::Marshal.load(::Marshal.dump([1, 2])) },
|
|
"oracle failed to observe a real Marshal.load, so the next test would pass vacuously"
|
|
end
|
|
|
|
def test_never_calls_marshal_load
|
|
blob = ::Marshal.dump(UserMarshalFixture.new)
|
|
refute load_watcher { parse(blob) }, "parser invoked Marshal.load"
|
|
end
|
|
|
|
def test_never_calls_marshal_load_on_gadget_shaped_payload
|
|
blob = ::Marshal.dump(Gem::Requirement.new(">= 0"))
|
|
refute load_watcher { parse(blob) }, "parser invoked Marshal.load"
|
|
end
|
|
|
|
FIRED = []
|
|
|
|
module RecordsHash
|
|
def hash
|
|
FIRED << self.class.to_s
|
|
super
|
|
end
|
|
end
|
|
|
|
class PlainKey
|
|
include RecordsHash
|
|
end
|
|
|
|
class StringKey < String
|
|
include RecordsHash
|
|
end
|
|
|
|
class ArrayKey < Array
|
|
include RecordsHash
|
|
end
|
|
|
|
StructKey = Struct.new(:a) { include RecordsHash }
|
|
|
|
def dispatch_probes
|
|
{
|
|
"plain object (o)" => PlainKey.new,
|
|
"struct (S)" => StructKey.new(1),
|
|
"Array subclass (C)" => ArrayKey.new,
|
|
"String subclass (C)" => StringKey.new("x"),
|
|
"extended object (e)" => PlainKey.new.extend(RecordsHash),
|
|
"extended string (e)" => (+"x").extend(RecordsHash),
|
|
"plain string" => "x",
|
|
"symbol" => :x,
|
|
"integer" => 7,
|
|
"regexp" => /ab/
|
|
}
|
|
end
|
|
|
|
def ruby_dispatches?(key)
|
|
FIRED.clear
|
|
::Marshal.load(::Marshal.dump({ key => nil }))
|
|
!FIRED.empty?
|
|
end
|
|
|
|
def parser_predicts_dispatch?(key)
|
|
parse(::Marshal.dump({ key => nil })).dispatching_hash_keys.any?
|
|
end
|
|
|
|
def test_hash_key_dispatch_prediction_matches_real_ruby
|
|
observed = dispatch_probes.to_h { |label, key| [label, ruby_dispatches?(key)] }
|
|
|
|
assert_includes observed.values, true, "no probe dispatched, so the oracle is dead"
|
|
assert_includes observed.values, false, "every probe dispatched, so the oracle proves nothing"
|
|
|
|
mismatches = dispatch_probes.filter_map do |label, key|
|
|
predicted = parser_predicts_dispatch?(key)
|
|
next if predicted == observed.fetch(label)
|
|
|
|
"#{label}: ruby=#{observed.fetch(label)} parser=#{predicted}"
|
|
end
|
|
|
|
assert_empty mismatches, "parser disagrees with Marshal.load:\n #{mismatches.join("\n ")}"
|
|
end
|
|
|
|
def test_the_same_class_is_only_flagged_in_key_position
|
|
in_key = parse(AdversarialCorpus::HASH_KEY_SHAPES_THAT_DISPATCH[:object])
|
|
in_value = parse(AdversarialCorpus::OBJECT_IN_VALUE_POSITION)
|
|
|
|
assert_equal 1, in_key.dispatching_hash_keys.length
|
|
assert_empty in_value.dispatching_hash_keys,
|
|
"position is the whole signal, so a value-position object must not be flagged"
|
|
end
|
|
|
|
def test_every_dispatching_key_shape_is_detected
|
|
blind = AdversarialCorpus::HASH_KEY_SHAPES_THAT_DISPATCH.reject do |_shape, bytes|
|
|
parse(bytes).dispatching_hash_keys.any?
|
|
end
|
|
|
|
assert_empty blind.keys, "key-position dispatch missed in: #{blind.keys.join(', ')}"
|
|
end
|
|
|
|
def test_non_dispatching_key_shapes_are_not_flagged
|
|
noisy = AdversarialCorpus::HASH_KEY_SHAPES_THAT_DO_NOT_DISPATCH.select do |_shape, bytes|
|
|
parse(bytes).dispatching_hash_keys.any?
|
|
end
|
|
|
|
assert_empty noisy.keys, "false positive on: #{noisy.keys.join(', ')}"
|
|
end
|
|
|
|
def test_struct_member_name_slot_is_not_scanned_as_a_hash_key
|
|
blob = AdversarialCorpus.stream(
|
|
"S#{AdversarialCorpus.sym(AdversarialCorpus::OBJECT_CLASS)}" \
|
|
"#{AdversarialCorpus.fixnum(1)}#{AdversarialCorpus::PLAIN_OBJECT}0"
|
|
)
|
|
|
|
assert_equal 1, parse(blob).nodes.count { |node| node.type == :pair },
|
|
"control: the fixture must actually contain a struct pair"
|
|
assert_empty parse(blob).dispatching_hash_keys,
|
|
"read_pair is shared with read_struct, so struct pairs must not be scanned"
|
|
end
|
|
|
|
class Fixture
|
|
@instantiated = false
|
|
|
|
class << self
|
|
attr_accessor :instantiated
|
|
end
|
|
|
|
def initialize
|
|
@marker = "value"
|
|
end
|
|
end
|
|
|
|
class UserMarshalFixture
|
|
def marshal_dump
|
|
["payload"]
|
|
end
|
|
|
|
def marshal_load(data); end
|
|
end
|
|
|
|
class UserDefFixture
|
|
def _dump(_depth)
|
|
"opaque"
|
|
end
|
|
|
|
def self._load(_data)
|
|
new
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|