safemode 2.0.2 → 2.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 7362759a3432731cdb5b3f8177623fe699b6f78e52922813d0c6af3e280d1b92
4
- data.tar.gz: 1f409d13eb5ca31211503168e667e38413cf5f473dece30d7463a099ad9ec751
3
+ metadata.gz: 8fcb0610067cef4810bfc86b88ad0c317b4e5f8cdfd58ad1ab151f988187c0ef
4
+ data.tar.gz: 36fdc5e97f61fe5b79fd84bc2bf1f57fa69f842036acf24c8ec5bf9d4d66c41a
5
5
  SHA512:
6
- metadata.gz: 7adb149b67b9ddd344203a0360ff70e663effb7a0da5ce5506dbac023b12db34a347a59b976cab62c9cf01cdd8cefd28be02c1c3442df787e599eb82bcad0940
7
- data.tar.gz: 33a099e1f86a7e9f9c0a14425126a36f332921503ee35bc47e686a7c1deeff301b4b40083c96050ab4d2afa0f354d71204b4429828390cffd75248631eee5d80
6
+ metadata.gz: a3069b0cd27363a042a7bd7d5e8e0a543153f5af6ed5f00fa24929ac177bf58369a2b9cbab16489589b3be81eef44c9c60e458753d3eb393c0e4ab923a45a91b
7
+ data.tar.gz: ca169d4812f4f2068666382063903f0f425f45454e2148b6d50d3358c81294f0b94596d0a36fe27300028ceaf133e36924d4142d1d348a04dd071677c63a9725
data/README.markdown CHANGED
@@ -49,6 +49,13 @@ end
49
49
  This will allow your template users to access the name method on your User
50
50
  objects.
51
51
 
52
+ Safemode supports logical compound assignments such as `user.name ||= value`,
53
+ `user&.name &&= value`, and `values[0] ||= value`. Their getters and conditional
54
+ setters are mediated by Jail, so both methods must be allowed when an assignment
55
+ is required. Compound assignments that implicitly invoke another operator, such
56
+ as `user.count += 1`, raise `Safemode::SecurityError`. Compound assignments to
57
+ local variables remain supported and their method calls are mediated by Jail.
58
+
52
59
  Class methods can be whitelisted by calling `allow_class_method :foo` from
53
60
  within the Jail. Note that access to raw constants is not permitted, so the
54
61
  class is only accessible when returned by a method or passed into a template.
@@ -37,7 +37,7 @@ module Safemode
37
37
  # these methods are allowed in all classes if they are present
38
38
  @@default_methods = %w( % & * ** + +@ - -@ / < << <= <=> ! != == === > >= >> ^ | ~
39
39
  eql? equal? new methods is_a? kind_of? nil?
40
- [] []= to_a to_jail to_s inspect to_param not freeze)
40
+ [] []= to_a to_jail to_s inspect to_param not)
41
41
 
42
42
  # whitelisted methods for core classes ... kind of arbitrary selection
43
43
  @@methods_whitelist = {
@@ -24,6 +24,12 @@ module Safemode
24
24
  def process_call(exp, safe_call = false)
25
25
  _, recv, name, *args = exp
26
26
 
27
+ # ERB emits literal template text as string literals. Freezing one only
28
+ # affects that template-generated string, not a string passed in by the caller.
29
+ if name == :freeze && args.empty? && recv && recv.sexp_type == :str
30
+ return "(#{process recv}).freeze"
31
+ end
32
+
27
33
  receiver = jail(process_call_receiver(recv), safe_call: safe_call)
28
34
  arguments = process_call_args(name, args)
29
35
 
@@ -59,9 +65,17 @@ module Safemode
59
65
  end
60
66
  end
61
67
 
68
+ def process_for(exp)
69
+ _, recv, iter, body = exp
70
+ receiver = jail(process(recv), true)
71
+ variable = process(iter)
72
+ body = process(body) || '# do nothing'
73
+ "for #{variable} in #{receiver} do\n#{indent(body)}\nend"
74
+ end
75
+
62
76
  # see http://www.namikilab.tuat.ac.jp/~sasada/prog/rubynodes/nodes.html
63
77
 
64
- allowed = [ :call, :vcall, :evstr,
78
+ ALLOWED_NODES = [ :call, :safe_call, :fcall, :vcall, :evstr, :const, :arglist,
65
79
  :lvar, :dvar, :ivar, :lasgn, :masgn, :dasgn, :dasgn_curr,
66
80
  :lit, :str, :dstr, :dsym, :nil, :true, :false,
67
81
  :array, :zarray, :hash, :dot2, :dot3, :flip2, :flip3,
@@ -76,14 +90,22 @@ module Safemode
76
90
  :colon2,
77
91
  # unnecessarily advanced?
78
92
  :argscat, :argspush, :splat, :kwsplat,
79
- # NOTE: op_asgn*/safe_op_asgn* do not insert .to_jail on the
80
- # receiver. Setters are called directly on the real object, bypassing Jail.
81
- :op_asgn, :op_asgn1, :op_asgn2, :op_asgn_and, :op_asgn_or,
93
+ # local variable logical assignments
94
+ :op_asgn_and, :op_asgn_or,
95
+ # object logical assignments; handlers below reject other operators
96
+ :op_asgn, :op_asgn1, :op_asgn2,
82
97
  :safe_op_asgn, :safe_op_asgn2,
83
98
  # pattern matching (Ruby 3.0+)
84
99
  :in, :array_pat, :hash_pat, :find_pat, :kwrest,
85
100
  # needed for haml
86
- :block ]
101
+ :block ].freeze
102
+
103
+ def process(exp)
104
+ if exp && !ALLOWED_NODES.include?(exp.sexp_type)
105
+ raise_security_error(exp.sexp_type, nil)
106
+ end
107
+ super
108
+ end
87
109
 
88
110
  disallowed = [ # :self, # self doesn't seem to be needed for vcalls?
89
111
  # see below for :const handling
@@ -134,6 +156,52 @@ module Safemode
134
156
  raise Safemode::SecurityError.new(type, info)
135
157
  end
136
158
 
159
+ LOGICAL_ASSIGNMENT_OPERATORS = [:"||", :"&&"].freeze
160
+
161
+ def process_op_asgn(exp)
162
+ return raise_security_error(:op_asgn, super(exp)) unless LOGICAL_ASSIGNMENT_OPERATORS.include?(exp[4])
163
+
164
+ _, receiver, rhs, name, operator = exp
165
+ process_logical_attribute_assignment(receiver, name, operator, rhs)
166
+ end
167
+
168
+ def process_safe_op_asgn(exp)
169
+ return raise_security_error(:safe_op_asgn, super(exp)) unless LOGICAL_ASSIGNMENT_OPERATORS.include?(exp[4])
170
+
171
+ _, receiver, rhs, name, operator = exp
172
+ process_logical_attribute_assignment(receiver, name, operator, rhs, true)
173
+ end
174
+
175
+ def process_op_asgn2(exp)
176
+ return raise_security_error(:op_asgn2, super(exp)) unless LOGICAL_ASSIGNMENT_OPERATORS.include?(exp[3])
177
+
178
+ _, receiver, name, operator, rhs = exp
179
+ process_logical_attribute_assignment(receiver, name, operator, rhs)
180
+ end
181
+
182
+ def process_safe_op_asgn2(exp)
183
+ return raise_security_error(:safe_op_asgn2, super(exp)) unless LOGICAL_ASSIGNMENT_OPERATORS.include?(exp[3])
184
+
185
+ _, receiver, name, operator, rhs = exp
186
+ process_logical_attribute_assignment(receiver, name, operator, rhs, true)
187
+ end
188
+
189
+ def process_op_asgn1(exp)
190
+ return raise_security_error(:op_asgn1, super(exp)) unless LOGICAL_ASSIGNMENT_OPERATORS.include?(exp[3])
191
+
192
+ _, receiver, index, operator, rhs = exp
193
+ receiver = jail(process_call_receiver(receiver))
194
+ "#{receiver}[#{process index}] #{operator}= #{process rhs}"
195
+ end
196
+
197
+ def process_logical_attribute_assignment(receiver, name, operator, rhs, safe_call = false)
198
+ receiver = jail(process_call_receiver(receiver), safe_call: safe_call)
199
+ name = name.to_s.sub(/=$/, "")
200
+ dot = safe_call ? "&." : "."
201
+
202
+ "#{receiver}#{dot}#{name} #{operator}= #{process rhs}"
203
+ end
204
+
137
205
  # split up Ruby2Ruby#process_call monster method so we can hook into it
138
206
  # in a more readable manner
139
207
 
data/safemode.gemspec CHANGED
@@ -4,7 +4,7 @@ require 'date'
4
4
 
5
5
  Gem::Specification.new do |s|
6
6
  s.name = "safemode".freeze
7
- s.version = "2.0.2"
7
+ s.version = "2.0.4"
8
8
  s.date = Date.today
9
9
 
10
10
  s.summary = "A library for safe evaluation of Ruby code based on Prism and Ruby2Ruby"
@@ -49,7 +49,9 @@ Gem::Specification.new do |s|
49
49
  "test/test_helper.rb",
50
50
  "test/test_jail.rb",
51
51
  "test/test_safemode_eval.rb",
52
- "test/test_safemode_parser.rb"
52
+ "test/test_safemode_parser.rb",
53
+ "test/test_for_loop_jail.rb",
54
+ "test/test_parser_node_allowlist.rb"
53
55
  ]
54
56
 
55
57
  s.required_ruby_version = ">= 3.0", "< 3.4"
@@ -0,0 +1,27 @@
1
+ # frozen_string_literal: true
2
+ require_relative 'test_helper'
3
+
4
+ class TestForLoopJail < Test::Unit::TestCase
5
+ class Host
6
+ attr_reader :calls
7
+
8
+ def initialize
9
+ @calls = []
10
+ end
11
+
12
+ def each
13
+ @calls << :each
14
+ yield 'secret'
15
+ end
16
+ end
17
+
18
+ def test_for_loop_checks_each_permission
19
+ host = Host.new
20
+ assert_raise(Safemode::NoMethodError) do
21
+ Safemode::Box.new.eval('for x in @host; x; end', host: host)
22
+ end
23
+ assert_empty host.calls
24
+ assert_equal 3, Safemode::Box.new.eval('sum = 0; for x in [1, 2]; sum += x; end; sum')
25
+ assert_equal 2, Safemode::Box.new.eval('for x in [1, 2]; end; x')
26
+ end
27
+ end
@@ -0,0 +1,13 @@
1
+ # frozen_string_literal: true
2
+ require_relative 'test_helper'
3
+
4
+ class TestParserNodeAllowlist < Test::Unit::TestCase
5
+ def test_new_dependency_node_handlers_are_not_implicitly_trusted
6
+ parser = Class.new(Safemode::Parser) do
7
+ def process_unreviewed_node(exp)
8
+ '42'
9
+ end
10
+ end
11
+ assert_raise(Safemode::SecurityError) { parser.new.process(Sexp.new(:unreviewed_node)) }
12
+ end
13
+ end
@@ -5,6 +5,128 @@ require File.join(File.dirname(__FILE__), 'test_helper')
5
5
  class TestSafemodeEval < Test::Unit::TestCase
6
6
  include TestHelper
7
7
 
8
+ class CompoundAssignmentProbe
9
+ attr_reader :calls
10
+
11
+ def initialize(status: nil)
12
+ @calls = []
13
+ @target = Target.new(@calls, status)
14
+ end
15
+
16
+ def record(value)
17
+ @calls << value
18
+ end
19
+
20
+ def receiver
21
+ @calls << :receiver
22
+ @target
23
+ end
24
+
25
+ def nil_receiver
26
+ @calls << :nil_receiver
27
+ nil
28
+ end
29
+
30
+ def index
31
+ @calls << :index
32
+ 0
33
+ end
34
+
35
+ def rhs
36
+ @calls << :rhs
37
+ 1
38
+ end
39
+
40
+ def operator_value
41
+ @calls << :operator_value
42
+ OperatorValue.new(@calls)
43
+ end
44
+
45
+ def operator_target
46
+ @calls << :operator_target
47
+ Target.new(@calls, OperatorValue.new(@calls))
48
+ end
49
+
50
+ def denied_receiver
51
+ @calls << :denied_receiver
52
+ DeniedTarget.new(@calls)
53
+ end
54
+
55
+ class Target
56
+ def initialize(calls, status)
57
+ @calls = calls
58
+ @status = status
59
+ @values = {}
60
+ end
61
+
62
+ def status
63
+ @calls << :getter
64
+ @status
65
+ end
66
+
67
+ def status=(value)
68
+ @calls << :setter
69
+ @status = value
70
+ end
71
+
72
+ def [](index)
73
+ @calls << :index_getter
74
+ @values[index]
75
+ end
76
+
77
+ def []=(index, value)
78
+ @calls << :index_setter
79
+ @values[index] = value
80
+ end
81
+
82
+ class Jail < Safemode::Jail
83
+ allow :status, :status=, :[], :[]=
84
+ end
85
+ end
86
+
87
+ class OperatorValue
88
+ def initialize(calls)
89
+ @calls = calls
90
+ end
91
+
92
+ def +(_value)
93
+ @calls << :operator
94
+ 2
95
+ end
96
+ end
97
+
98
+ class DeniedTarget
99
+ def initialize(calls)
100
+ @calls = calls
101
+ end
102
+
103
+ def status
104
+ @calls << :denied_getter
105
+ end
106
+
107
+ def status=(_value)
108
+ @calls << :denied_setter
109
+ end
110
+
111
+ def [](_index)
112
+ @calls << :denied_index_getter
113
+ end
114
+
115
+ def []=(_index, _value)
116
+ @calls << :denied_index_setter
117
+ end
118
+
119
+ class Jail < Safemode::Jail
120
+ allow :status=, :[]=
121
+ end
122
+ end
123
+
124
+ class Jail < Safemode::Jail
125
+ allow :record, :receiver, :nil_receiver, :index, :rhs, :operator_value,
126
+ :operator_target, :denied_receiver
127
+ end
128
+ end
129
+
8
130
  def setup
9
131
  @box = Safemode::Box.new
10
132
  @locals = { :article => Article.new }
@@ -178,21 +300,155 @@ class TestSafemodeEval < Test::Unit::TestCase
178
300
  assert_raise(Safemode::SecurityError) { @box.eval('@article&.status = "new_value"', @assigns) }
179
301
  end
180
302
 
181
- # op_asgn2 (@article.status ||= val) is NOT blocked at parse time.
182
- # NOTE: .to_jail is not inserted on the receiver, so the setter is called
183
- # directly on the real object, bypassing the Jail whitelist.
184
- def test_op_asgn2_bypasses_jail
303
+ def test_index_assignment_is_blocked
304
+ assert_raise(Safemode::SecurityError) { @box.eval('@article[0] = "new_value"', @assigns) }
305
+ end
306
+
307
+ def test_attribute_logical_compound_assignment_requires_an_allowed_setter
185
308
  article = Article.new
309
+ assert_raise(Safemode::NoMethodError) do
310
+ @box.eval('@article.status ||= "new_value"', { article: article })
311
+ end
186
312
  assert_nil article.status
187
- @box.eval('@article.status ||= "new_value"', { article: article })
188
- assert_equal "new_value", article.status
189
313
  end
190
314
 
191
- def test_safe_op_asgn2_bypasses_jail
315
+ def test_attribute_logical_compound_assignment_requires_an_allowed_getter
316
+ probe = CompoundAssignmentProbe.new
317
+
318
+ assert_raise(Safemode::NoMethodError) do
319
+ @box.eval('@probe.denied_receiver.status ||= "default"', { probe: probe })
320
+ end
321
+ assert_equal [:denied_receiver], probe.calls
322
+ end
323
+
324
+ def test_index_logical_compound_assignment_requires_an_allowed_getter
325
+ probe = CompoundAssignmentProbe.new
326
+
327
+ assert_raise(Safemode::NoMethodError) do
328
+ @box.eval('@probe.denied_receiver[0] ||= "default"', { probe: probe })
329
+ end
330
+ assert_equal [:denied_receiver], probe.calls
331
+ end
332
+
333
+ def test_attribute_logical_compound_assignment_uses_jail
334
+ probe = CompoundAssignmentProbe.new
335
+
336
+ assert_equal 'default', @box.eval('@probe.receiver.status ||= "default"', { probe: probe })
337
+ assert_equal [:receiver, :getter, :setter], probe.calls
338
+ end
339
+
340
+ def test_attribute_and_assignment_uses_jail
341
+ probe = CompoundAssignmentProbe.new(status: 'existing')
342
+
343
+ assert_equal 'replacement', @box.eval('@probe.receiver.status &&= "replacement"', { probe: probe })
344
+ assert_equal [:receiver, :getter, :setter], probe.calls
345
+ end
346
+
347
+ def test_attribute_logical_compound_assignment_short_circuits_setter
192
348
  article = Article.new
193
- assert_nil article.status
194
- @box.eval('@article&.status ||= "new_value"', { article: article })
195
- assert_equal "new_value", article.status
349
+ article.status = 'existing'
350
+
351
+ assert_equal 'existing', @box.eval('@article.status ||= "default"', { article: article })
352
+ assert_equal 'existing', article.status
353
+ end
354
+
355
+ def test_safe_attribute_logical_compound_assignment_uses_jail
356
+ probe = CompoundAssignmentProbe.new
357
+
358
+ assert_equal 'default', @box.eval('@probe.receiver&.status ||= "default"', { probe: probe })
359
+ assert_equal [:receiver, :getter, :setter], probe.calls
360
+ end
361
+
362
+ def test_safe_attribute_logical_compound_assignment_short_circuits_nil_receiver
363
+ probe = CompoundAssignmentProbe.new
364
+
365
+ assert_nil @box.eval('@probe.nil_receiver&.status ||= @probe.rhs', { probe: probe })
366
+ assert_equal [:nil_receiver], probe.calls
367
+ end
368
+
369
+ def test_index_logical_compound_assignment_uses_jail
370
+ probe = CompoundAssignmentProbe.new
371
+
372
+ assert_equal 1, @box.eval('@probe.receiver[@probe.index] ||= @probe.rhs', { probe: probe })
373
+ assert_equal [:receiver, :index, :index_getter, :rhs, :index_setter], probe.calls
374
+ end
375
+
376
+ def test_object_logical_compound_assignment_rhs_uses_jail
377
+ probe = CompoundAssignmentProbe.new
378
+
379
+ assert_raise(Safemode::NoMethodError) do
380
+ @box.eval('@probe.receiver.status ||= @article.system', { probe: probe, article: Article.new })
381
+ end
382
+ assert_equal [:receiver, :getter], probe.calls
383
+ end
384
+
385
+ def test_attribute_operator_compound_assignment_is_blocked
386
+ assert_raise(Safemode::SecurityError) do
387
+ @box.eval('@article.status += 1', @assigns)
388
+ end
389
+ end
390
+
391
+ def test_safe_attribute_operator_compound_assignment_is_blocked
392
+ assert_raise(Safemode::SecurityError) do
393
+ @box.eval('@article&.status += 1', @assigns)
394
+ end
395
+ end
396
+
397
+ def test_compound_assignment_is_rejected_before_template_execution
398
+ [
399
+ '@probe.record(:earlier); @probe.operator_target.status += @probe.rhs',
400
+ '@probe.receiver[@probe.index] += @probe.rhs',
401
+ 'false && (@probe.receiver.status += @probe.rhs)',
402
+ '@probe.nil_receiver&.status += @probe.rhs',
403
+ ].each do |code|
404
+ probe = CompoundAssignmentProbe.new
405
+
406
+ assert_raise(Safemode::SecurityError, code) do
407
+ @box.eval(code, { probe: probe })
408
+ end
409
+ assert_empty(probe.calls, code)
410
+ end
411
+ end
412
+
413
+ def test_local_logical_compound_assignments_are_preserved
414
+ assert_equal 1, @box.eval('x = nil; x ||= 1; x')
415
+ assert_equal 1, @box.eval('x = false; x ||= 1; x')
416
+ assert_equal 2, @box.eval('x = 2; x ||= 1; x')
417
+ assert_equal 1, @box.eval('x = 2; x &&= 1; x')
418
+ assert_equal false, @box.eval('x = false; x &&= 1; x')
419
+ end
420
+
421
+ def test_local_logical_compound_assignments_short_circuit
422
+ probe = CompoundAssignmentProbe.new
423
+
424
+ assert_equal 1, @box.eval('x = nil; x ||= @probe.rhs; x', { probe: probe })
425
+ assert_equal [:rhs], probe.calls
426
+
427
+ probe = CompoundAssignmentProbe.new
428
+ assert_equal 2, @box.eval('x = 2; x ||= @probe.rhs; x', { probe: probe })
429
+ assert_equal false, @box.eval('x = false; x &&= @probe.rhs; x', { probe: probe })
430
+ assert_empty probe.calls
431
+ end
432
+
433
+ def test_evaluated_local_compound_assignment_rhs_uses_jail
434
+ assert_raise(Safemode::NoMethodError) do
435
+ @box.eval('x = nil; x ||= @article.system', @assigns)
436
+ end
437
+ end
438
+
439
+ def test_local_operator_compound_assignments_are_preserved
440
+ assert_equal 3, @box.eval('x = 2; x += 1; x')
441
+ assert_equal 8, @box.eval('x = 2; x **= 3; x')
442
+ assert_equal 4, @box.eval('x = 2; x <<= 1; x')
443
+ end
444
+
445
+ def test_local_operator_compound_assignment_uses_jail
446
+ probe = CompoundAssignmentProbe.new
447
+
448
+ assert_raise(Safemode::NoMethodError) do
449
+ @box.eval('x = @probe.operator_value; x += 1', { probe: probe })
450
+ end
451
+ assert_equal [:operator_value], probe.calls
196
452
  end
197
453
 
198
454
  def test_instance_variable_get_blocked_on_jail
@@ -201,6 +457,20 @@ class TestSafemodeEval < Test::Unit::TestCase
201
457
  end
202
458
  end
203
459
 
460
+ def test_freeze_on_jailed_object_is_blocked
461
+ string = String.new('host value')
462
+ assert_raise(Safemode::NoMethodError) { @box.eval('@value.freeze', value: string) }
463
+ assert_false string.frozen?
464
+ assert_raise(Safemode::NoMethodError) do
465
+ @box.eval('@arr.freeze', { arr: [1, 2, 3] })
466
+ end
467
+ end
468
+
469
+ def test_freeze_on_literal_strings_supports_erb
470
+ assert_predicate @box.eval('"literal".freeze'), :frozen?
471
+ assert_equal 'Hello world', @box.eval(ERB.new('Hello <%= @name %>').src, name: 'world')
472
+ end
473
+
204
474
  def test_lambda_is_blocked
205
475
  assert_raise(Safemode::SecurityError) { @box.eval('-> { 1 }') }
206
476
  end
@@ -73,9 +73,46 @@ class TestSafemodeParser < Test::Unit::TestCase
73
73
  end
74
74
  end
75
75
 
76
- def test_safe_op_asgn2_is_allowed
77
- assert_nothing_raised do
78
- jail('@article&.title ||= "new_value"')
76
+ def test_attribute_operator_compound_assignments_are_disabled
77
+ operators = %w[+ - * / % ** & | ^ << >>]
78
+
79
+ operators.each do |operator|
80
+ assert_raise(Safemode::SecurityError, "#{operator}= should be disabled") do
81
+ jail("@article.title #{operator}= 1")
82
+ end
83
+ end
84
+ end
85
+
86
+ def test_all_object_operator_compound_assignment_nodes_are_disabled
87
+ [
88
+ '@article.title += 1',
89
+ '@article&.title += 1',
90
+ '@article[0] += 1',
91
+ '@article.title += helper 1',
92
+ '@article&.title += helper 1',
93
+ '@article::title += 1',
94
+ '[1][0] += 1',
95
+ ].each do |code|
96
+ assert_raise(Safemode::SecurityError, "#{code} should be disabled") do
97
+ jail(code)
98
+ end
99
+ end
100
+ end
101
+
102
+ def test_object_logical_compound_assignments_are_allowed
103
+ [
104
+ '@article.title ||= 1',
105
+ '@article.title &&= 1',
106
+ '@article&.title ||= 1',
107
+ '@article&.title &&= 1',
108
+ '@article[0] ||= 1',
109
+ '@article[0] &&= 1',
110
+ '@article.title ||= helper 1',
111
+ '@article&.title ||= helper 1',
112
+ '[nil][0] ||= 1',
113
+ '({ key: nil })[:key] ||= 1',
114
+ ].each do |code|
115
+ assert_nothing_raised("#{code} should be allowed") { jail(code) }
79
116
  end
80
117
  end
81
118
 
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: safemode
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.0.2
4
+ version: 2.0.4
5
5
  platform: ruby
6
6
  authors:
7
7
  - Sven Fuchs
@@ -12,7 +12,7 @@ authors:
12
12
  - Dmitri Dolguikh
13
13
  bindir: bin
14
14
  cert_chain: []
15
- date: 2026-10-01 00:00:00.000000000 Z
15
+ date: 2026-11-19 00:00:00.000000000 Z
16
16
  dependencies:
17
17
  - !ruby/object:Gem::Dependency
18
18
  name: ruby2ruby
@@ -140,8 +140,10 @@ files:
140
140
  - lib/safemode/scope.rb
141
141
  - safemode.gemspec
142
142
  - test/test_erb_eval.rb
143
+ - test/test_for_loop_jail.rb
143
144
  - test/test_helper.rb
144
145
  - test/test_jail.rb
146
+ - test/test_parser_node_allowlist.rb
145
147
  - test/test_safemode_eval.rb
146
148
  - test/test_safemode_parser.rb
147
149
  homepage: https://github.com/svenfuchs/safemode