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 👇
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
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/Rakefileindex 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 = trueend-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.rbindex 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 RubeREASON_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.freezeSECURITY LIMITATION@@ -105,8 +109,17 @@ module Rubedef violation_for(result)sink = result.sinks.firstreturn 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.rbindex 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 RubeBIGNUM_SIGN_POSITIVE = "+"BIGNUM_SIGN_NEGATIVE = "-"+ BIGNUM_SIGNS = [BIGNUM_SIGN_POSITIVE, BIGNUM_SIGN_NEGATIVE].freezeBIGNUM_WORD_BYTES = 2FIXNUM_INLINE_OFFSET = 5@@ -56,6 +57,10 @@ module RubeROLE_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].freezeSINK_METHODS = {diff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/errors.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/errors.rbindex 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 Rubeclass MalformedCountError < StreamError; end+ class MalformedValueError < StreamError; end+class LimitExceededError < StreamError; endclass InputTypeError < StreamError; enddiff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/limits.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/limits.rbindex 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 RubeDEFAULT_MAX_SCALAR_BYTES = 262_144DEFAULT_MAX_TOTAL_SCALAR_BYTES = 524_288DEFAULT_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 = 256ROLE_BYTES = "stream bytes"ROLE_NODES = "nodes"@@ -22,10 +27,19 @@ module RubeROLE_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::INFINITYattr_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_membersdef initialize(max_bytes: DEFAULT_MAX_BYTES,@@ -36,7 +50,12 @@ module Rubemax_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_membersend- 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)endend@@ -71,6 +100,7 @@ module Rube@registered = 0@symbols = 0@links = 0+ @symbol_references = 0@scalar_total = 0end@@ -94,6 +124,27 @@ module Rubecheck(@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)enddiff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/node.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/node.rbindex 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 Rubemodule Marshalclass 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_targetdef initialize(type:, tag: nil, value: nil, class_name: nil)@type = type@@ -29,6 +32,25 @@ module RubeConstants::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 Rubeendclass 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_VERSIONenddef nodes@@ -60,6 +88,17 @@ module Rubedef gated_sinkssinks.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?)+ endendendenddiff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/parser.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/marshal/parser.rbindex 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 Rubeclass Parserinclude 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_depthenforce_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 Ruberoot = read_value(1)raise TrailingBytesError, "#{remaining} unread bytes" unless remaining.zero?- Result.new(root)+ Result.new(root, major: @major, minor: @minor)endprivate@@ -32,7 +32,6 @@ module Rubeattr_reader :source, :max_depth, :symbols, :objects, :budget, :limitsdef enforce_size(candidate)- return unless limitsreturn if candidate.bytesize <= limits.max_bytesraise LimitExceededError, "#{Limits::ROLE_BYTES} #{candidate.bytesize} exceeds #{limits.max_bytes}"@@ -68,11 +67,10 @@ module Rubeenddef 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}"enddef read_fixnum@@ -133,7 +131,7 @@ module Rubewhen 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 Rubedef 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.valuenodeenddef read_symlink(tag)+ budget.symbol_reference!index = read_fixnumraise InvalidLinkError, "symlink #{index} of #{symbols.length}" unless symbols[index] && index >= 0@@ -163,13 +165,20 @@ module Rubeindex = read_fixnumraise 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]+ nodeenddef 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)enddef read_float(tag)@@ -210,13 +219,20 @@ module Rubedef 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_snode.auxiliary << class_nodenodeenddef read_instance_variables(node, depth)- read_entry_count(ROLE_IVAR).times do+ count = read_entry_count(ROLE_IVAR)+ budget.instance_variables!(count)+ count.times doname = read_value(depth + 1)value = read_value(depth + 1)node.auxiliary << name@@ -227,7 +243,7 @@ module Rubeenddef read_ivar(tag, depth)- read_instance_variables(read_value(depth), depth)+ read_instance_variables(read_value(depth + 1), depth)enddef read_object(tag, depth)@@ -239,13 +255,15 @@ module Rubedef 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) }nodeend- 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_bytesnodeend@@ -258,14 +276,18 @@ module Rubeenddef 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)nodeenddef 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))endendenddiff --git a/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/scanner.rb b/PROJECTS/beginner/deserialization-gadget-lab/lib/rube/scanner.rbindex 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 Rubedef reachablecandidates.select(&:reachable?)end++ def prism_available?+ PRISM_AVAILABLE+ endenddef initialize(namespace: nil)diff --git a/PROJECTS/beginner/deserialization-gadget-lab/scripts/render_matrix.rb b/PROJECTS/beginner/deserialization-gadget-lab/scripts/render_matrix.rbindex 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.rbrequire "json"+require "rube"TRACKED_CLASSES = %w[Gem::SpecFetcher Gem::Source::Git Gem::URI Net::WriteAdapter].freezeMARK_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)+endrows = 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") doputs 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"] }.uniqguard_states = rows.map { |r| r["erb_guard"]["guarded"] }.uniqagreements = 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"])]enddisagreements = 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.shindex 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[@]}"; doprintf ' %-18s ' "${image}"if ! docker image inspect "${image}" >/dev/null 2>&1; thenif ! docker pull -q "${image}" >/dev/null 2>&1; thenecho "UNAVAILABLE"+ incomplete+=("${image} unavailable")continuefifi@@ -46,11 +49,29 @@ for image in "${IMAGES[@]}"; doecho "ok"elseecho "PROBE FAILED"+ incomplete+=("${image} probe failed")fidoneecho+render_status=0docker 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.rbindex 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 RubeALLOWED_CLASSES = %w[Hash String Symbol Integer Array].freezeBENIGN_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::Baseset :host_authorization, permitted_hosts: []@@ -63,10 +67,10 @@ module Rubeblob = 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))endget "/canary" do@@ -93,20 +97,6 @@ module Rubetemplate.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)- endendendenddiff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/chains_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/chains_test.rbindex 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 Rubeassert_match(/\A#\nend\n/, chain.src)end- def test_serialize_produces_a_loadable_marshal_stream+ def test_serialize_produces_a_parseable_marshal_streamblob = 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.typeenddef test_payload_is_visible_to_the_parser_without_deserializingdiff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/control_check.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/control_check.rbindex 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 @@ putsputs "=== 5 payload inspection ==="result = Rube::Marshal::Parser.new(Marshal.dump(Gem::Requirement.new(">= 0"))).parsefrom_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(", "))putsputs "=== 6 parser and scanner agreement ==="scanned = Rube::Scanner.new(namespace: "Gem").scan.gated.map(&:to_s).sortmissing = 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)putsputs "=== 7 scanner precision ==="@@ -93,9 +104,13 @@ full = Rube::Scanner.new.scanungated = full.ungated.lengthreachable = full.reachable.reject(&:gated?).lengthkept = 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.rbindex 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 Rubeleaks = AdversarialCorpus::CASES.filter_map do |kase|detector(kase[:allowed]).inspect_stream(kase[:bytes])nil- rescue StandardError => e+ rescue Exception => e"#{kase[:name]}: #{e.class}"enddiff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/boundary_detector_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/boundary_detector_test.rbindex 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.rbrequire_relative "../test_helper"+require_relative "../support/adversarial_corpus"module Rubemodule Marshal@@ -108,6 +109,28 @@ module Rubeassert_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_policyassert_raises(ArgumentError) { detector(policy: :yolo) }end@@ -130,36 +153,132 @@ module Ruberefute_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)enddef test_enforces_a_depth_ceilingdeep = "\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"enddef 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)enddef 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)enddef 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"enddef test_never_exposes_a_safety_claiming_apidiff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/parser_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/marshal/parser_test.rbindex 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 Rubeassert_equal :nil, parse("\x04\x07\x30").root.typeend+ 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_tagassert_raises(UnknownTagError) { parse("\x04\x08\x00") }end@@ -65,6 +144,55 @@ module Rubeendend+ 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_floatassert_in_delta 3.5, roundtrip(3.5).value, 0.0end@@ -105,6 +233,40 @@ module Rubeassert_equal 0, link.valueend+ 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_linkassert_raises(InvalidLinkError) { parse("\x04\x08@\x0a") }end@@ -184,9 +346,35 @@ module Rubeassert_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_cursorparser = 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.valueenddef test_every_malformed_count_stays_inside_the_stream_error_hierarchy@@ -261,11 +449,61 @@ module Rubeassert_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_limitblob = ::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_watcherfired = falsetracer = TracePoint.new(:call, :c_call) do |tp|@@ -290,6 +528,107 @@ module Ruberefute 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 = falsediff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/scanner_test.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/scanner_test.rbindex 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 Rubedef test_report_partitions_gated_and_ungatedreport = 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.lengthassert_empty(report.gated & report.ungated)end@@ -123,9 +125,14 @@ module Rubeassert_equal first, secondend- 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"enddef test_scanning_does_not_instantiate_anythingdiff --git a/PROJECTS/beginner/deserialization-gadget-lab/test/support/adversarial_corpus.rb b/PROJECTS/beginner/deserialization-gadget-lab/test/support/adversarial_corpus.rbindex 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 Rubeallowed: allowed.freeze }.freezeend+ 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 = 80WIDE_COUNT = 4_096MANY_SYMBOLS = 400HUGE_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"].freezeTRIPWIRE_CLASS = "Tripwire"HOST_CLASS = "Comparable"@@ -95,6 +135,27 @@ module RubeIVAR_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 Rubeallowed: [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")].freezeendend