Skip to content

Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company 👇

fix(rube): clear the entire S1 backlog tier - depth, budgets, gates, fidelity

CarterPerez-dev582e032cc013
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/Rakefile b/PROJECTS/beginner/deserialization-gadget-lab/Rakefile
index 2b78c541..032347ee 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/Rakefile
+++ b/PROJECTS/beginner/deserialization-gadget-lab/Rakefile
@@ -9,4 +9,9 @@ Rake::TestTask.new(:test) do |t|
t.warning = true
end
-task default: :test
+desc "run the standalone control checks that the minitest suite cannot express"
+task :control do
+ ruby "-Ilib -Itest test/control_check.rb"
+end
+
+task default: %i[test control]
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/boundary_detector.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/boundary_detector.rb
index f908bb8b..34f42117 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/boundary_detector.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/boundary_detector.rb
@@ -18,6 +18,10 @@ module Rube
REASON_MALFORMED = "stream is not canonical Marshal: %s"
REASON_SINK = "stream reaches %s#%s during load, before any allowlist can run"
REASON_UNAPPROVED = "stream references unapproved class %s"
+ REASON_KEY_DISPATCH = "stream puts %s in a hash key, so its #hash and #eql? run during " \
+ "load, before any allowlist can act"
+ REASON_NONCANONICAL_VERSION = "stream declares Marshal %d.%d; every Ruby that can produce " \
+ "this format emits %d.%d"
LIMITATION_NOTICE = <<~NOTICE.freeze
SECURITY LIMITATION
@@ -105,8 +109,17 @@ module Rube
def violation_for(result)
sink = result.sinks.first
return format(REASON_SINK, sink.class_name, sink.sink_method) if sink
+
+ key = result.dispatching_hash_keys.first
+ return format(REASON_KEY_DISPATCH, key.effective_class_name) if key
+
return nil if policy == POLICY_DENY_SINKS_ONLY
+ unless result.canonical_version?
+ return format(REASON_NONCANONICAL_VERSION, result.major, result.minor,
+ Constants::MAJOR_VERSION, Constants::MINOR_VERSION)
+ end
+
unapproved = result.class_names.reject { |name| allowed_class_names.include?(name) }
return format(REASON_UNAPPROVED, unapproved.join(", ")) unless unapproved.empty?
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/constants.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/constants.rb
index 8f0302ba..096e7a1b 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/constants.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/constants.rb
@@ -36,6 +36,7 @@ module Rube
BIGNUM_SIGN_POSITIVE = "+"
BIGNUM_SIGN_NEGATIVE = "-"
+ BIGNUM_SIGNS = [BIGNUM_SIGN_POSITIVE, BIGNUM_SIGN_NEGATIVE].freeze
BIGNUM_WORD_BYTES = 2
FIXNUM_INLINE_OFFSET = 5
@@ -56,6 +57,10 @@ module Rube
ROLE_STRUCT = "struct member"
ROLE_BIGNUM = "bignum word"
+ CLASS_NAME_TYPES = %i[symbol symlink].freeze
+
+ REGISTERED_WRAPPER_TYPES = %i[data].freeze
+
SINK_TAGS = [TAG_USERDEF, TAG_USERMARSHAL, TAG_DATA].freeze
SINK_METHODS = {
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/errors.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/errors.rb
index 15d95320..21c31542 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/errors.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/errors.rb
@@ -19,6 +19,8 @@ module Rube
class MalformedCountError < StreamError; end
+ class MalformedValueError < StreamError; end
+
class LimitExceededError < StreamError; end
class InputTypeError < StreamError; end
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/limits.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/limits.rb
index dbb898ec..60065c21 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/limits.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/limits.rb
@@ -13,6 +13,11 @@ module Rube
DEFAULT_MAX_SCALAR_BYTES = 262_144
DEFAULT_MAX_TOTAL_SCALAR_BYTES = 524_288
DEFAULT_MAX_OBJECT_LINKS = 2_048
+ DEFAULT_MAX_SYMBOL_REFERENCES = 2_048
+ DEFAULT_MAX_SYMBOL_NAME_BYTES = 1_024
+ DEFAULT_MAX_CLASS_NAME_BYTES = 1_024
+ DEFAULT_MAX_INSTANCE_VARIABLES = 256
+ DEFAULT_MAX_STRUCT_MEMBERS = 256
ROLE_BYTES = "stream bytes"
ROLE_NODES = "nodes"
@@ -22,10 +27,19 @@ module Rube
ROLE_SCALAR = "scalar bytes"
ROLE_TOTAL_SCALAR = "total scalar bytes"
ROLE_LINKS = "object links"
+ ROLE_SYMBOL_REFERENCES = "symbol references"
+ ROLE_SYMBOL_NAME = "symbol name bytes"
+ ROLE_CLASS_NAME = "class name bytes"
+ ROLE_INSTANCE_VARIABLES = "instance variables"
+ ROLE_STRUCT_MEMBERS = "struct members"
+
+ UNBOUNDED = Float::INFINITY
attr_reader :max_bytes, :max_depth, :max_nodes, :max_registered_objects,
:max_symbol_definitions, :max_collection_entries,
- :max_scalar_bytes, :max_total_scalar_bytes, :max_object_links
+ :max_scalar_bytes, :max_total_scalar_bytes, :max_object_links,
+ :max_symbol_references, :max_symbol_name_bytes, :max_class_name_bytes,
+ :max_instance_variables, :max_struct_members
def initialize(
max_bytes: DEFAULT_MAX_BYTES,
@@ -36,7 +50,12 @@ module Rube
max_collection_entries: DEFAULT_MAX_COLLECTION_ENTRIES,
max_scalar_bytes: DEFAULT_MAX_SCALAR_BYTES,
max_total_scalar_bytes: DEFAULT_MAX_TOTAL_SCALAR_BYTES,
- max_object_links: DEFAULT_MAX_OBJECT_LINKS
+ max_object_links: DEFAULT_MAX_OBJECT_LINKS,
+ max_symbol_references: DEFAULT_MAX_SYMBOL_REFERENCES,
+ max_symbol_name_bytes: DEFAULT_MAX_SYMBOL_NAME_BYTES,
+ max_class_name_bytes: DEFAULT_MAX_CLASS_NAME_BYTES,
+ max_instance_variables: DEFAULT_MAX_INSTANCE_VARIABLES,
+ max_struct_members: DEFAULT_MAX_STRUCT_MEMBERS
)
@max_bytes = max_bytes
@max_depth = max_depth
@@ -47,19 +66,29 @@ module Rube
@max_scalar_bytes = max_scalar_bytes
@max_total_scalar_bytes = max_total_scalar_bytes
@max_object_links = max_object_links
+ @max_symbol_references = max_symbol_references
+ @max_symbol_name_bytes = max_symbol_name_bytes
+ @max_class_name_bytes = max_class_name_bytes
+ @max_instance_variables = max_instance_variables
+ @max_struct_members = max_struct_members
end
- def permissive
- self.class.new(
- max_bytes: Float::INFINITY,
+ def self.permissive
+ new(
+ max_bytes: UNBOUNDED,
max_depth: Constants::DEFAULT_MAX_DEPTH,
- max_nodes: Float::INFINITY,
- max_registered_objects: Float::INFINITY,
- max_symbol_definitions: Float::INFINITY,
- max_collection_entries: Float::INFINITY,
- max_scalar_bytes: Float::INFINITY,
- max_total_scalar_bytes: Float::INFINITY,
- max_object_links: Float::INFINITY
+ max_nodes: UNBOUNDED,
+ max_registered_objects: UNBOUNDED,
+ max_symbol_definitions: UNBOUNDED,
+ max_collection_entries: UNBOUNDED,
+ max_scalar_bytes: UNBOUNDED,
+ max_total_scalar_bytes: UNBOUNDED,
+ max_object_links: UNBOUNDED,
+ max_symbol_references: UNBOUNDED,
+ max_symbol_name_bytes: UNBOUNDED,
+ max_class_name_bytes: UNBOUNDED,
+ max_instance_variables: UNBOUNDED,
+ max_struct_members: UNBOUNDED
)
end
end
@@ -71,6 +100,7 @@ module Rube
@registered = 0
@symbols = 0
@links = 0
+ @symbol_references = 0
@scalar_total = 0
end
@@ -94,6 +124,27 @@ module Rube
check(@links, limits.max_object_links, Limits::ROLE_LINKS)
end
+ def symbol_reference!
+ @symbol_references += 1
+ check(@symbol_references, limits.max_symbol_references, Limits::ROLE_SYMBOL_REFERENCES)
+ end
+
+ def symbol_name!(size)
+ check(size, limits.max_symbol_name_bytes, Limits::ROLE_SYMBOL_NAME)
+ end
+
+ def class_name!(size)
+ check(size, limits.max_class_name_bytes, Limits::ROLE_CLASS_NAME)
+ end
+
+ def instance_variables!(count)
+ check(count, limits.max_instance_variables, Limits::ROLE_INSTANCE_VARIABLES)
+ end
+
+ def struct_members!(count)
+ check(count, limits.max_struct_members, Limits::ROLE_STRUCT_MEMBERS)
+ end
+
def entries!(count)
check(count, limits.max_collection_entries, Limits::ROLE_ENTRIES)
end
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/node.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/node.rb
index cfd80bea..637beb59 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/node.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/node.rb
@@ -4,8 +4,11 @@
module Rube
module Marshal
class Node
+ STRING_BACKED_TYPES = %i[string regexp].freeze
+ WRAPPER_TYPES = %i[user_class extended].freeze
+
attr_reader :type, :tag, :children, :instance_variables_map, :auxiliary
- attr_accessor :value, :class_name
+ attr_accessor :value, :class_name, :link_target
def initialize(type:, tag: nil, value: nil, class_name: nil)
@type = type
@@ -29,6 +32,25 @@ module Rube
Constants::GATED_SINK_TAGS.include?(tag)
end
+ def dispatches_key_methods?
+ return link_target ? link_target.dispatches_key_methods? : false if type == :object_link
+ return false unless class_name
+ return !string_backed? if WRAPPER_TYPES.include?(type)
+
+ true
+ end
+
+ def effective_class_name
+ link_target ? link_target.class_name : class_name
+ end
+
+ def string_backed?
+ wrapped = children.first
+ return false unless wrapped
+
+ STRING_BACKED_TYPES.include?(wrapped.type)
+ end
+
def each(&block)
return enum_for(:each) unless block
@@ -39,10 +61,16 @@ module Rube
end
class Result
- attr_reader :root
+ attr_reader :root, :major, :minor
- def initialize(root)
+ def initialize(root, major:, minor:)
@root = root
+ @major = major
+ @minor = minor
+ end
+
+ def canonical_version?
+ major == Constants::MAJOR_VERSION && minor == Constants::MINOR_VERSION
end
def nodes
@@ -60,6 +88,17 @@ module Rube
def gated_sinks
sinks.select(&:gated?)
end
+
+ def hash_keys
+ nodes.select { |node| node.type == :hash }
+ .flat_map(&:children)
+ .select { |child| child.type == :pair }
+ .filter_map { |pair| pair.children.first }
+ end
+
+ def dispatching_hash_keys
+ hash_keys.select(&:dispatches_key_methods?)
+ end
end
end
end
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/parser.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/parser.rb
index 4e8dd949..d10dabdb 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/parser.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/parser.rb
@@ -6,14 +6,14 @@ module Rube
class Parser
include Constants
- def initialize(source, max_depth: DEFAULT_MAX_DEPTH, limits: nil)
+ def initialize(source, max_depth: nil, limits: Limits.new)
raise InputTypeError, "expected String, got #{source.class}" unless source.is_a?(String)
@limits = limits
- @max_depth = limits ? limits.max_depth : max_depth
+ @max_depth = max_depth || limits.max_depth
enforce_size(source)
@source = source.dup.force_encoding(Encoding::BINARY)
- @budget = Budget.new(limits || Limits.new.permissive)
+ @budget = Budget.new(limits)
@position = 0
@symbols = []
@objects = []
@@ -24,7 +24,7 @@ module Rube
root = read_value(1)
raise TrailingBytesError, "#{remaining} unread bytes" unless remaining.zero?
- Result.new(root)
+ Result.new(root, major: @major, minor: @minor)
end
private
@@ -32,7 +32,6 @@ module Rube
attr_reader :source, :max_depth, :symbols, :objects, :budget, :limits
def enforce_size(candidate)
- return unless limits
return if candidate.bytesize <= limits.max_bytes
raise LimitExceededError, "#{Limits::ROLE_BYTES} #{candidate.bytesize} exceeds #{limits.max_bytes}"
@@ -68,11 +67,10 @@ module Rube
end
def read_header
- header = take(HEADER_LENGTH)
- major, minor = header.unpack("CC")
- return if major == MAJOR_VERSION && minor <= MINOR_VERSION
+ @major, @minor = take(HEADER_LENGTH).unpack("CC")
+ return if @major == MAJOR_VERSION && @minor <= MINOR_VERSION
- raise UnsupportedVersionError, "stream declares #{major}.#{minor}"
+ raise UnsupportedVersionError, "stream declares #{@major}.#{@minor}"
end
def read_fixnum
@@ -133,7 +131,7 @@ module Rube
when TAG_IVAR then read_ivar(tag, depth)
when TAG_OBJECT then read_object(tag, depth)
when TAG_STRUCT then read_struct(tag, depth)
- when TAG_USERDEF then register(read_userdef(tag))
+ when TAG_USERDEF then register(read_userdef(tag, depth))
when TAG_USERMARSHAL then read_usermarshal(tag, depth)
when TAG_DATA then read_wrapped(tag, :data, depth)
when TAG_USERCLASS then read_wrapped(tag, :user_class, depth)
@@ -146,12 +144,16 @@ module Rube
def read_symbol(tag)
budget.symbol!
- node = Node.new(type: :symbol, tag: tag, value: read_counted_bytes.to_sym)
+ size = read_count(ROLE_LENGTH)
+ budget.symbol_name!(size)
+ budget.scalar!(size)
+ node = Node.new(type: :symbol, tag: tag, value: take(size).to_sym)
symbols << node.value
node
end
def read_symlink(tag)
+ budget.symbol_reference!
index = read_fixnum
raise InvalidLinkError, "symlink #{index} of #{symbols.length}" unless symbols[index] && index >= 0
@@ -163,13 +165,20 @@ module Rube
index = read_fixnum
raise InvalidLinkError, "object link #{index} of #{objects.length}" unless objects[index] && index >= 0
- Node.new(type: :object_link, tag: tag, value: index)
+ node = Node.new(type: :object_link, tag: tag, value: index)
+ node.link_target = objects[index]
+ node
end
def read_bignum(tag)
- negative = take(1) == BIGNUM_SIGN_NEGATIVE
- magnitude = little_endian(take(read_count(ROLE_BIGNUM) * BIGNUM_WORD_BYTES))
- Node.new(type: :bignum, tag: tag, value: negative ? -magnitude : magnitude)
+ sign = take(1)
+ raise MalformedValueError, "bignum sign #{sign.inspect}" unless BIGNUM_SIGNS.include?(sign)
+
+ size = read_count(ROLE_BIGNUM) * BIGNUM_WORD_BYTES
+ budget.scalar!(size)
+ magnitude = little_endian(take(size))
+ Node.new(type: :bignum, tag: tag,
+ value: sign == BIGNUM_SIGN_NEGATIVE ? -magnitude : magnitude)
end
def read_float(tag)
@@ -210,13 +219,20 @@ module Rube
def read_class_name(node, depth)
class_node = read_value(depth)
+ unless CLASS_NAME_TYPES.include?(class_node.type)
+ raise MalformedValueError,
+ "class name slot holds #{class_node.type}, not a symbol"
+ end
+
node.class_name = class_node.value.to_s
node.auxiliary << class_node
node
end
def read_instance_variables(node, depth)
- read_entry_count(ROLE_IVAR).times do
+ count = read_entry_count(ROLE_IVAR)
+ budget.instance_variables!(count)
+ count.times do
name = read_value(depth + 1)
value = read_value(depth + 1)
node.auxiliary << name
@@ -227,7 +243,7 @@ module Rube
end
def read_ivar(tag, depth)
- read_instance_variables(read_value(depth), depth)
+ read_instance_variables(read_value(depth + 1), depth)
end
def read_object(tag, depth)
@@ -239,13 +255,15 @@ module Rube
def read_struct(tag, depth)
node = register(Node.new(type: :struct, tag: tag))
read_class_name(node, depth + 1)
- read_entry_count(ROLE_STRUCT).times { node.children << read_pair(depth) }
+ count = read_entry_count(ROLE_STRUCT)
+ budget.struct_members!(count)
+ count.times { node.children << read_pair(depth) }
node
end
- def read_userdef(tag)
+ def read_userdef(tag, depth)
node = Node.new(type: :userdef, tag: tag)
- read_class_name(node, 1)
+ read_class_name(node, depth + 1)
node.value = read_counted_bytes
node
end
@@ -258,14 +276,18 @@ module Rube
end
def read_wrapped(tag, type, depth)
- node = register(Node.new(type: type, tag: tag))
+ node = Node.new(type: type, tag: tag)
+ register(node) if REGISTERED_WRAPPER_TYPES.include?(type)
read_class_name(node, depth + 1)
node.children << read_value(depth + 1)
node
end
def read_named(tag, type)
- Node.new(type: type, tag: tag, class_name: read_counted_bytes)
+ size = read_count(ROLE_LENGTH)
+ budget.class_name!(size)
+ budget.scalar!(size)
+ Node.new(type: type, tag: tag, class_name: take(size))
end
end
end
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/scanner.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/scanner.rb
index 616e20cc..8edaf2ef 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/scanner.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/scanner.rb
@@ -79,6 +79,10 @@ module Rube
def reachable
candidates.select(&:reachable?)
end
+
+ def prism_available?
+ PRISM_AVAILABLE
+ end
end
def initialize(namespace: nil)
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/scripts/render_matrix.rb b/PROJECTS/beginner/deserialization-gadget-lab/scripts/render_matrix.rb
index 58b73b9f..a804aba0 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/scripts/render_matrix.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/scripts/render_matrix.rb
@@ -2,6 +2,7 @@
# render_matrix.rb
require "json"
+require "rube"
TRACKED_CLASSES = %w[Gem::SpecFetcher Gem::Source::Git Gem::URI Net::WriteAdapter].freeze
MARK_YES = "yes"
@@ -9,7 +10,11 @@ MARK_NO = "no"
MARK_UNKNOWN = "?"
RULE_WIDTH = 78
-CVE_PATCHED_ERB = ["4.0.3.1", "4.0.4.1", "6.0.1.1", "6.0.4"].freeze
+CHAIN = Rube::Chains::ErbDefMethod
+
+def cve_patched?(version)
+ !CHAIN.affects?(version)
+end
rows = File.readlines(ARGV.fetch(0)).reject { |line| line.strip.empty? }.map { |line| JSON.parse(line) }
abort "no probe results" if rows.empty?
@@ -54,7 +59,7 @@ section("ERB @_init GUARD (CVE-2026-41316), anchor = def_method") do
puts format(" %-14s %-9s %-9s %-24s %s", "image", "erb", "guarded", "delegating", "cve says")
rows.each do |r|
guard = r["erb_guard"]
- expected = CVE_PATCHED_ERB.include?(r["erb"]) ? "patched" : "affected"
+ expected = cve_patched?(r["erb"]) ? "patched" : "affected"
puts format(" %-14s %-9s %-9s %-24s %s",
short(r["image"]), r["erb"], mark(guard["guarded"]),
guard["delegating"].join(","), expected)
@@ -65,8 +70,7 @@ git_states = rows.map { |r| r["git_gadget"] }.uniq
guard_states = rows.map { |r| r["erb_guard"]["guarded"] }.uniq
agreements = rows.map do |r|
- expected_patched = CVE_PATCHED_ERB.include?(r["erb"])
- [short(r["image"]), r["erb_guard"]["guarded"] == expected_patched]
+ [short(r["image"]), r["erb_guard"]["guarded"] == cve_patched?(r["erb"])]
end
disagreements = agreements.reject { |_, ok| ok }.map(&:first)
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/scripts/version-matrix.sh b/PROJECTS/beginner/deserialization-gadget-lab/scripts/version-matrix.sh
index d81a026e..36677690 100755
--- a/PROJECTS/beginner/deserialization-gadget-lab/scripts/version-matrix.sh
+++ b/PROJECTS/beginner/deserialization-gadget-lab/scripts/version-matrix.sh
@@ -28,12 +28,15 @@ mkdir -p "${HERE}/tmp"
echo "probing ${#IMAGES[@]} images"
+incomplete=()
+
for image in "${IMAGES[@]}"; do
printf ' %-18s ' "${image}"
if ! docker image inspect "${image}" >/dev/null 2>&1; then
if ! docker pull -q "${image}" >/dev/null 2>&1; then
echo "UNAVAILABLE"
+ incomplete+=("${image} unavailable")
continue
fi
fi
@@ -46,11 +49,29 @@ for image in "${IMAGES[@]}"; do
echo "ok"
else
echo "PROBE FAILED"
+ incomplete+=("${image} probe failed")
fi
done
echo
+render_status=0
docker run --rm --network none \
-v "${OUT}:/matrix.jsonl:ro" \
-v "${RENDER}:/render.rb:ro" \
- "${RENDER_IMAGE}" ruby /render.rb /matrix.jsonl
+ -v "${HERE}/lib:/app/lib:ro" \
+ -w /app \
+ "${RENDER_IMAGE}" ruby -Ilib /render.rb /matrix.jsonl || render_status=$?
+
+echo
+if [[ ${#incomplete[@]} -gt 0 ]]; then
+ echo "GATE FAILED - ${#incomplete[@]} of ${#IMAGES[@]} images produced no probe result:"
+ printf ' %s\n' "${incomplete[@]}"
+ echo " a matrix built from a subset cannot certify a version boundary"
+ exit 1
+fi
+
+if [[ ${render_status} -ne 0 ]]; then
+ echo "GATE FAILED - renderer rejected the matrix"
+fi
+
+exit ${render_status}
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/target/app.rb b/PROJECTS/beginner/deserialization-gadget-lab/target/app.rb
index 95ca7696..9ca7c8f1 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/target/app.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/target/app.rb
@@ -19,11 +19,15 @@ module Rube
ALLOWED_CLASSES = %w[Hash String Symbol Integer Array].freeze
BENIGN_TEMPLATE = "hello"
- REJECTED_SINK = "rejected: payload reaches %s#%s before any allowlist can run"
- REJECTED_CLASS = "rejected: payload references %s"
+ DETECTOR = Rube::Marshal::BoundaryDetector.new(
+ policy: Rube::Marshal::BoundaryDetector::POLICY_STRICT_ALLOWLIST,
+ allowed_class_names: ALLOWED_CLASSES,
+ limits: Rube::Marshal::Limits.new
+ )
+
+ REJECTED = "rejected: %s"
RENDERED = "rendered template for %s"
NO_SESSION = "no session cookie"
- MALFORMED = "rejected: malformed stream (%s)"
class App < Sinatra::Base
set :host_authorization, permitted_hosts: []
@@ -63,10 +67,10 @@ module Rube
blob = decode(request.cookies[COOKIE_NAME])
halt STATUS_BAD_REQUEST, NO_SESSION unless blob
- verdict = inspect_stream(blob)
- halt STATUS_BAD_REQUEST, verdict if verdict
+ decision = DETECTOR.inspect_stream(blob)
+ halt STATUS_BAD_REQUEST, format(REJECTED, decision.reason) if decision.rejected?
- compile(::Marshal.load(blob))
+ compile(::Marshal.load(decision.snapshot))
end
get "/canary" do
@@ -93,20 +97,6 @@ module Rube
template.def_method(Module.new, "render_it") if template.respond_to?(:def_method)
format(RENDERED, state[:user])
end
-
- def inspect_stream(blob)
- result = Rube::Marshal::Parser.new(blob).parse
-
- sink = result.sinks.first
- return format(REJECTED_SINK, sink.class_name, sink.sink_method) if sink
-
- unknown = result.class_names.reject { |name| ALLOWED_CLASSES.include?(name) }
- return format(REJECTED_CLASS, unknown.join(", ")) unless unknown.empty?
-
- nil
- rescue Rube::Marshal::StreamError => e
- format(MALFORMED, e.class.name.split("::").last)
- end
end
end
end
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/chains_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/chains_test.rb
index 8c54043b..01118e22 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/test/chains_test.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/test/chains_test.rb
@@ -65,10 +65,11 @@ module Rube
assert_match(/\A#\nend\n/, chain.src)
end
- def test_serialize_produces_a_loadable_marshal_stream
+ def test_serialize_produces_a_parseable_marshal_stream
blob = chain.serialize
- assert_equal 4, blob.getbyte(0)
- assert_equal 8, blob.getbyte(1)
+ assert_equal [Rube::Marshal::Constants::MAJOR_VERSION, Rube::Marshal::Constants::MINOR_VERSION],
+ [blob.getbyte(0), blob.getbyte(1)]
+ assert_equal :object, Rube::Marshal::Parser.new(blob).parse.root.type
end
def test_payload_is_visible_to_the_parser_without_deserializing
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/control_check.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/control_check.rb
index 41f902d2..1a334c90 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/test/control_check.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/test/control_check.rb
@@ -1,7 +1,9 @@
# ©AngelaMos | 2026
# control_check.rb
-require_relative "test_helper"
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "rube"
Pair = Struct.new(:x, :y)
@@ -77,15 +79,24 @@ puts
puts "=== 5 payload inspection ==="
result = Rube::Marshal::Parser.new(Marshal.dump(Gem::Requirement.new(">= 0"))).parse
from_stream = result.gated_sinks.map { |s| "#{s.class_name}##{s.sink_method}" }.uniq.sort
-check("classes extracted", !result.class_names.empty?, result.class_names.join(", "))
-check("gated sinks flagged", !from_stream.empty?, from_stream.join(", "))
+failures << "class names" unless check("classes extracted", !result.class_names.empty?,
+ result.class_names.join(", "))
+failures << "gated sinks" unless check("gated sinks flagged", !from_stream.empty?,
+ from_stream.join(", "))
puts
puts "=== 6 parser and scanner agreement ==="
scanned = Rube::Scanner.new(namespace: "Gem").scan.gated.map(&:to_s).sort
missing = from_stream - scanned
-failures << "agreement" unless check("parser sinks located by reflection", missing.empty?,
- missing.empty? ? "#{from_stream.length}/#{from_stream.length}" : "missing #{missing.join(', ')}")
+located = !from_stream.empty? && missing.empty?
+agreement_detail = if from_stream.empty?
+ "vacuous, section 5 produced no sinks to locate"
+ elsif missing.empty?
+ "#{from_stream.length}/#{from_stream.length}"
+ else
+ "missing #{missing.join(', ')}"
+ end
+failures << "agreement" unless check("parser sinks located by reflection", located, agreement_detail)
puts
puts "=== 7 scanner precision ==="
@@ -93,9 +104,13 @@ full = Rube::Scanner.new.scan
ungated = full.ungated.length
reachable = full.reachable.reject(&:gated?).length
kept = ungated.zero? ? 0 : (100.0 * reachable / ungated).round(1)
-failures << "precision" unless check("reachability filter discriminates", reachable < ungated,
+failures << "prism" unless check("prism backend live, so reachability is real", full.prism_available?,
+ full.prism_available? ? "Prism.parse_file in use" : "ABSENT, touches_state? is always false")
+failures << "precision" unless check("reachability filter discriminates",
+ reachable.positive? && reachable < ungated,
"#{ungated} ungated -> #{reachable} reachable, #{kept}% kept")
-check("gated sinks located", !full.gated.empty?, full.gated.map(&:to_s).join(", "))
+failures << "gated located" unless check("gated sinks located", !full.gated.empty?,
+ full.gated.map(&:to_s).join(", "))
puts format(" %-6s %-46s %s", "INFO", "ObjectSpace coverage is load-bounded",
"#{full.scanned_modules} modules loaded")
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/corpus_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/corpus_test.rb
index 0def6ce4..9249d559 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/test/corpus_test.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/test/corpus_test.rb
@@ -37,7 +37,7 @@ module Rube
leaks = AdversarialCorpus::CASES.filter_map do |kase|
detector(kase[:allowed]).inspect_stream(kase[:bytes])
nil
- rescue StandardError => e
+ rescue Exception => e
"#{kase[:name]}: #{e.class}"
end
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/boundary_detector_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/boundary_detector_test.rb
index 0386f627..81219758 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/boundary_detector_test.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/boundary_detector_test.rb
@@ -2,6 +2,7 @@
# boundary_detector_test.rb
require_relative "../test_helper"
+require_relative "../support/adversarial_corpus"
module Rube
module Marshal
@@ -108,6 +109,28 @@ module Rube
assert_predicate decision, :rejected?
end
+ def test_rejects_a_version_the_parser_accepts_but_no_ruby_emits
+ older = "\x04\x07\x30".b
+
+ assert_predicate Parser.new(older).parse, :root,
+ "control: the parser must still accept it, it is a forensic tool"
+ decision = detector.inspect_stream(older)
+ assert_predicate decision, :rejected?
+ assert_includes decision.reason, "4.7"
+ end
+
+ def test_canonical_version_is_accepted
+ assert_predicate detector.inspect_stream(benign_blob), :accepted?
+ end
+
+ def test_deny_sinks_only_does_not_police_the_version
+ decision = detector(policy: BoundaryDetector::POLICY_DENY_SINKS_ONLY)
+ .inspect_stream("\x04\x07\x30".b)
+ assert_predicate decision, :accepted?,
+ "version canonicality runs no code during load, so it belongs with " \
+ "the allowlist, not with the sink checks"
+ end
+
def test_rejects_unknown_policy
assert_raises(ArgumentError) { detector(policy: :yolo) }
end
@@ -130,36 +153,132 @@ module Rube
refute_includes decision.snapshot, "tampered"
end
- def test_enforces_a_byte_ceiling_before_parsing
- limits = Limits.new(max_bytes: 8)
- decision = detector(limits: limits).inspect_stream(benign_blob)
+ def assert_ceiling_rejects(blob, error_name, allowed: [], **narrow)
+ assert_predicate detector(allowed_class_names: allowed).inspect_stream(blob), :accepted?,
+ "control: this payload must be accepted under default limits, " \
+ "or the ceiling is not what rejected it"
+
+ decision = detector(allowed_class_names: allowed, limits: Limits.new(**narrow)).inspect_stream(blob)
assert_predicate decision, :rejected?
- assert_includes decision.reason, "LimitExceededError"
+ assert_includes decision.reason, error_name
+ decision
+ end
+
+ def test_enforces_a_byte_ceiling_before_parsing
+ assert_ceiling_rejects(benign_blob, "LimitExceededError", max_bytes: 8)
end
def test_enforces_a_depth_ceiling
deep = "\x04\x08" + ("[\x06" * 80) + "0"
+ shallow = "\x04\x08" + ("[\x06" * 8) + "0"
+
+ assert_predicate detector.inspect_stream(shallow), :accepted?,
+ "control: nesting inside the ceiling must be accepted"
decision = detector.inspect_stream(deep)
assert_predicate decision, :rejected?
+ assert_includes decision.reason, "DepthLimitError"
end
def test_enforces_a_collection_entry_ceiling
- limits = Limits.new(max_collection_entries: 2)
- decision = detector(limits: limits).inspect_stream(::Marshal.dump([1, 2, 3, 4, 5]))
- assert_predicate decision, :rejected?
+ assert_ceiling_rejects(::Marshal.dump([1, 2, 3, 4, 5]), "LimitExceededError",
+ max_collection_entries: 2)
end
def test_enforces_a_symbol_ceiling
- limits = Limits.new(max_symbol_definitions: 2)
- blob = ::Marshal.dump(%i[a b c d e f])
- decision = detector(limits: limits).inspect_stream(blob)
- assert_predicate decision, :rejected?
+ assert_ceiling_rejects(::Marshal.dump(%i[a b c d e f]), "LimitExceededError",
+ max_symbol_definitions: 2)
end
def test_enforces_a_node_ceiling
- limits = Limits.new(max_nodes: 5)
- decision = detector(limits: limits).inspect_stream(::Marshal.dump((1..50).to_a))
- assert_predicate decision, :rejected?
+ assert_ceiling_rejects(::Marshal.dump((1..50).to_a), "LimitExceededError",
+ max_nodes: 5)
+ end
+
+ def test_enforces_a_bignum_magnitude_ceiling
+ words = AdversarialCorpus::BIGNUM_HUGE_WORDS
+ blob = AdversarialCorpus.stream(AdversarialCorpus.bignum("+", words))
+ decision = detector.inspect_stream(blob)
+
+ assert_predicate decision, :rejected?,
+ "#{words * AdversarialCorpus::BIGNUM_WORD_BYTES} magnitude bytes must be " \
+ "charged the same budget a string of that size is charged"
+ assert_includes decision.reason, "LimitExceededError"
+ end
+
+ def test_enforces_a_symbol_reference_ceiling
+ count = AdversarialCorpus::BULK_ENTRY_COUNT
+ blob = AdversarialCorpus.stream(
+ "[#{AdversarialCorpus.fixnum(count + 1)}#{AdversarialCorpus.symlink_run(count)}"
+ )
+ assert_ceiling_rejects(blob, "LimitExceededError", max_symbol_references: 8)
+ end
+
+ def test_enforces_a_symbol_name_byte_ceiling
+ blob = AdversarialCorpus.stream(AdversarialCorpus.sym("A" * AdversarialCorpus::MODEST_NAME_BYTES))
+ assert_ceiling_rejects(blob, "LimitExceededError", max_symbol_name_bytes: 32)
+ end
+
+ def test_enforces_a_class_name_byte_ceiling
+ name = "A" * AdversarialCorpus::MODEST_NAME_BYTES
+ blob = AdversarialCorpus.stream("c#{AdversarialCorpus.fixnum(name.bytesize)}#{name}")
+ assert_ceiling_rejects(blob, "LimitExceededError", allowed: [name], max_class_name_bytes: 32)
+ end
+
+ def test_enforces_an_instance_variable_ceiling
+ blob = AdversarialCorpus.stream(
+ "o#{AdversarialCorpus.sym('F')}#{AdversarialCorpus.ivar_run(AdversarialCorpus::MODEST_ENTRY_COUNT)}"
+ )
+ assert_ceiling_rejects(blob, "LimitExceededError", allowed: %w[F], max_instance_variables: 8)
+ end
+
+ def test_enforces_a_struct_member_ceiling
+ blob = AdversarialCorpus.stream(
+ "S#{AdversarialCorpus.sym('F')}#{AdversarialCorpus.ivar_run(AdversarialCorpus::MODEST_ENTRY_COUNT)}"
+ )
+ assert_ceiling_rejects(blob, "LimitExceededError", allowed: %w[F], max_struct_members: 8)
+ end
+
+ def default_limit_probes
+ long = "A" * AdversarialCorpus::LONG_NAME_BYTES
+ bulk = AdversarialCorpus::BULK_ENTRY_COUNT
+
+ {
+ "bignum magnitude" =>
+ [AdversarialCorpus.stream(AdversarialCorpus.bignum("+", AdversarialCorpus::BIGNUM_HUGE_WORDS)), []],
+ "symbol references" =>
+ [AdversarialCorpus.stream(
+ AdversarialCorpus.symlink_groups(AdversarialCorpus::SYMLINK_BULK_GROUPS,
+ AdversarialCorpus::SYMLINK_BULK_PER_GROUP)
+ ), []],
+ "symbol name bytes" =>
+ [AdversarialCorpus.stream(AdversarialCorpus.sym(long)), []],
+ "class name bytes" =>
+ [AdversarialCorpus.stream("c#{AdversarialCorpus.fixnum(long.bytesize)}#{long}"), [long]],
+ "instance variables" =>
+ [AdversarialCorpus.stream("o#{AdversarialCorpus.sym('F')}#{AdversarialCorpus.ivar_run(bulk)}"), %w[F]],
+ "struct members" =>
+ [AdversarialCorpus.stream("S#{AdversarialCorpus.sym('F')}#{AdversarialCorpus.ivar_run(bulk)}"), %w[F]]
+ }
+ end
+
+ def test_default_limits_bound_every_axis_without_being_asked
+ admitted = default_limit_probes.reject do |_axis, (blob, allowed)|
+ decision = detector(allowed_class_names: allowed).inspect_stream(blob)
+ decision.rejected? && decision.reason.include?("LimitExceededError")
+ end
+
+ assert_empty admitted.keys,
+ "Limits.new must bound these without a caller opting in: #{admitted.keys.join(', ')}"
+ end
+
+ def test_permissive_limits_admit_what_the_defaults_reject
+ admitted = default_limit_probes.count do |_axis, (blob, allowed)|
+ detector(allowed_class_names: allowed, limits: Limits.permissive).inspect_stream(blob).accepted?
+ end
+
+ assert_operator admitted, :>, 0,
+ "control: permissive must actually differ from the defaults, " \
+ "otherwise the previous test proves nothing about the ceilings"
end
def test_never_exposes_a_safety_claiming_api
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/parser_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/parser_test.rb
index a831c361..9fa8c87c 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/parser_test.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/parser_test.rb
@@ -35,6 +35,85 @@ module Rube
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
@@ -65,6 +144,55 @@ module Rube
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
@@ -105,6 +233,40 @@ module Rube
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
@@ -184,9 +346,35 @@ module Rube
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
@@ -261,11 +449,61 @@ module Rube
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|
@@ -290,6 +528,107 @@ module Rube
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
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/scanner_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/scanner_test.rb
index 701250f8..86c64ab9 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/test/scanner_test.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/test/scanner_test.rb
@@ -113,6 +113,8 @@ module Rube
def test_report_partitions_gated_and_ungated
report = local_scan
+ refute_empty report.gated, "a partition test proves nothing if one side is empty"
+ refute_empty report.ungated, "a partition test proves nothing if one side is empty"
assert_equal report.candidates.length, report.gated.length + report.ungated.length
assert_empty(report.gated & report.ungated)
end
@@ -123,9 +125,14 @@ module Rube
assert_equal first, second
end
- def test_anonymous_classes_are_skipped
- Class.new { def marshal_load(data); end }
- refute(local_scan.candidates.any? { |c| c.class_name.nil? || c.class_name.empty? })
+ def test_anonymous_classes_contribute_no_candidate
+ anonymous = Class.new { def marshal_load(data); end }
+ location = anonymous.instance_method(:marshal_load).source_location.join(":")
+
+ report = scan
+ refute_empty report.gated, "the global scan found nothing, so absence proves nothing"
+ refute_includes report.candidates.map(&:source_location), location,
+ "a class with no name reached the report"
end
def test_scanning_does_not_instantiate_anything
diff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/support/adversarial_corpus.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/support/adversarial_corpus.rb
index c3c863db..b945a5b8 100644
--- a/PROJECTS/beginner/deserialization-gadget-lab/test/support/adversarial_corpus.rb
+++ b/PROJECTS/beginner/deserialization-gadget-lab/test/support/adversarial_corpus.rb
@@ -52,10 +52,50 @@ module Rube
allowed: allowed.freeze }.freeze
end
+ def ivar_chain(depth)
+ (("I" * depth) + "0" + ("\x00" * depth)).b
+ end
+
+ def array_nest(depth)
+ ("[#{fixnum(1)}" * depth).b
+ end
+
+ def regexp(source)
+ "/#{fixnum(source.bytesize)}#{source}\x00".b
+ end
+
+ def bignum(sign, word_count, fill = "\x01")
+ "l#{sign}#{fixnum(word_count)}#{fill * (word_count * BIGNUM_WORD_BYTES)}".b
+ end
+
+ def symlink_run(count)
+ (sym("s") + (symlink(0) * count)).b
+ end
+
+ def symlink_groups(groups, per_group)
+ inner = "[#{fixnum(per_group)}#{symlink(0) * per_group}"
+ "[#{fixnum(groups + 1)}#{sym('s')}#{inner * groups}".b
+ end
+
+ def ivar_run(count)
+ "#{fixnum(count)}#{sym('@a')}0#{"#{symlink(1)}0" * (count - 1)}".b
+ end
+
NESTED_DEPTH = 80
WIDE_COUNT = 4_096
MANY_SYMBOLS = 400
HUGE_SCALAR = 300_000
+ IVAR_CHAIN_DEPTH = 6_000
+ USERDEF_NEST_DEPTH = 3
+ BIGNUM_WORD_BYTES = 2
+ BIGNUM_HUGE_WORDS = 200_000
+ LONG_NAME_BYTES = 100_000
+ BULK_ENTRY_COUNT = 1_000
+ MODEST_NAME_BYTES = 64
+ MODEST_ENTRY_COUNT = 16
+ SYMLINK_BULK_GROUPS = 3
+ SYMLINK_BULK_PER_GROUP = 1_000
+ BIGNUM_SIGNS = ["-", "+", "!", "\x00", "\xFF", "0"].freeze
TRIPWIRE_CLASS = "Tripwire"
HOST_CLASS = "Comparable"
@@ -95,6 +135,27 @@ module Rube
IVAR_DISTINCT_NAMES_CONTROL =
stream("I#{str('hello')}#{fixnum(2)}#{sym(COLLIDING_IVAR)}#{TRIPWIRE}#{sym(HIDDEN_IVAR)}0")
+ PLAIN_OBJECT = "o#{sym(OBJECT_CLASS)}#{fixnum(0)}".b
+
+ HASH_KEY_SHAPES_THAT_DISPATCH = {
+ object: stream("{#{fixnum(1)}#{PLAIN_OBJECT}0"),
+ object_link: stream("[#{fixnum(2)}#{PLAIN_OBJECT}{#{fixnum(1)}@#{fixnum(1)}0"),
+ struct: stream("{#{fixnum(1)}S#{sym(OBJECT_CLASS)}#{fixnum(0)}0"),
+ extended: stream("{#{fixnum(1)}e#{sym(HOST_CLASS)}#{PLAIN_OBJECT}0"),
+ user_class_over_array: stream("{#{fixnum(1)}C#{sym(OBJECT_CLASS)}[#{fixnum(0)}0")
+ }.freeze
+
+ HASH_KEY_SHAPES_THAT_DO_NOT_DISPATCH = {
+ user_class_over_string: stream("{#{fixnum(1)}C#{sym(OBJECT_CLASS)}#{str('x')}0"),
+ extended_over_string: stream("{#{fixnum(1)}e#{sym(HOST_CLASS)}#{str('x')}0"),
+ regexp: stream("{#{fixnum(1)}#{regexp('ab')}0"),
+ symbol: stream("{#{fixnum(1)}#{sym('k')}0"),
+ string: stream("{#{fixnum(1)}#{str('k')}0")
+ }.freeze
+
+ OBJECT_IN_VALUE_POSITION =
+ stream("{#{fixnum(1)}#{sym('k')}#{PLAIN_OBJECT}")
+
CASES = [
entry(:nil_literal, stream("0"), VERDICT_ACCEPT,
"the smallest legal stream"),
@@ -161,6 +222,9 @@ module Rube
"declares a three-byte integer and supplies one byte"),
entry(:deep_nesting, stream(("[\x06" * NESTED_DEPTH) + "0"), VERDICT_REJECT,
"nesting past the boundary depth ceiling"),
+ entry(:deep_instance_variable_chain, stream(ivar_chain(IVAR_CHAIN_DEPTH)), VERDICT_REJECT,
+ "the I wrapper must charge depth, or a 12 KB cookie exhausts the Ruby stack " \
+ "with a SystemStackError that no rescue StreamError can catch"),
entry(:wide_collection, stream("[#{fixnum(WIDE_COUNT)}#{'0' * WIDE_COUNT}"), VERDICT_REJECT,
"one collection consuming the whole node budget"),
entry(:many_symbols, stream("[#{fixnum(MANY_SYMBOLS)}#{(0...MANY_SYMBOLS).map { |i| sym("s#{i}") }.join}"),
@@ -207,7 +271,41 @@ module Rube
allowed: [HOST_CLASS]),
entry(:class_name_slot_extended, CLASS_NAME_SLOTS[:extended], VERDICT_REJECT,
"byte-identical gadget in an extend wrapper slot",
- allowed: [HOST_CLASS])
+ allowed: [HOST_CLASS]),
+
+ entry(:object_in_value_position_control, OBJECT_IN_VALUE_POSITION, VERDICT_ACCEPT,
+ "control: an allowlisted class is fine as a hash VALUE, which is what makes the " \
+ "key-position cases below a statement about position rather than about the class",
+ allowed: [OBJECT_CLASS]),
+
+ entry(:hash_key_object, HASH_KEY_SHAPES_THAT_DISPATCH[:object], VERDICT_REJECT,
+ "an allowlisted class in KEY position runs its #hash during load",
+ allowed: [OBJECT_CLASS]),
+ entry(:hash_key_object_link, HASH_KEY_SHAPES_THAT_DISPATCH[:object_link], VERDICT_REJECT,
+ "the same dispatch reached through an object link instead of a fresh object",
+ allowed: [OBJECT_CLASS]),
+ entry(:hash_key_struct, HASH_KEY_SHAPES_THAT_DISPATCH[:struct], VERDICT_REJECT,
+ "a struct in key position dispatches too",
+ allowed: [OBJECT_CLASS]),
+ entry(:hash_key_extended, HASH_KEY_SHAPES_THAT_DISPATCH[:extended], VERDICT_REJECT,
+ "an extended object in key position dispatches the module's #hash",
+ allowed: [OBJECT_CLASS, HOST_CLASS]),
+ entry(:hash_key_user_class_over_array, HASH_KEY_SHAPES_THAT_DISPATCH[:user_class_over_array],
+ VERDICT_REJECT,
+ "an Array subclass in key position dispatches the subclass #hash",
+ allowed: [OBJECT_CLASS]),
+
+ entry(:hash_key_user_class_over_string, HASH_KEY_SHAPES_THAT_DO_NOT_DISPATCH[:user_class_over_string],
+ VERDICT_ACCEPT,
+ "precision control: rb_any_hash keys on T_STRING, so a String subclass never " \
+ "reaches a user #hash and rejecting it would be a false positive",
+ allowed: [OBJECT_CLASS]),
+ entry(:hash_key_extended_over_string, HASH_KEY_SHAPES_THAT_DO_NOT_DISPATCH[:extended_over_string],
+ VERDICT_ACCEPT,
+ "same exemption when the string is reached through an extend wrapper",
+ allowed: [HOST_CLASS]),
+ entry(:hash_key_regexp, HASH_KEY_SHAPES_THAT_DO_NOT_DISPATCH[:regexp], VERDICT_ACCEPT,
+ "a regexp key names no class, so the payload cannot choose whose #hash runs")
].freeze
end
end