safemode 1.3.1 → 2.0.3
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 +5 -5
- data/Gemfile +3 -16
- data/README.markdown +16 -18
- data/Rakefile +5 -36
- data/demo.rb +2 -0
- data/lib/action_view/template_handlers/safe_erb.rb +2 -2
- data/lib/action_view/template_handlers/safe_haml.rb +1 -1
- data/lib/action_view/template_handlers/safemode_handler.rb +5 -5
- data/lib/haml/safemode.rb +11 -11
- data/lib/safemode/blankslate.rb +8 -2
- data/lib/safemode/core_ext.rb +4 -4
- data/lib/safemode/core_jails.rb +21 -24
- data/lib/safemode/exceptions.rb +3 -3
- data/lib/safemode/jail.rb +8 -13
- data/lib/safemode/parser.rb +159 -68
- data/lib/safemode/scope.rb +28 -20
- data/lib/safemode.rb +12 -20
- data/safemode.gemspec +33 -62
- data/test/test_erb_eval.rb +17 -17
- data/test/test_for_loop_jail.rb +27 -0
- data/test/test_helper.rb +45 -22
- data/test/test_jail.rb +29 -4
- data/test/test_parser_node_allowlist.rb +13 -0
- data/test/test_safemode_eval.rb +184 -23
- data/test/test_safemode_parser.rb +145 -8
- metadata +42 -101
- data/VERSION +0 -1
- data/lib/ruby_parser_string_io_patch.diff +0 -194
- data/lib/rubyparser_bug.rb +0 -8
- /data/{LICENCSE → LICENSE} +0 -0
data/lib/safemode/parser.rb
CHANGED
|
@@ -1,45 +1,41 @@
|
|
|
1
1
|
module Safemode
|
|
2
2
|
class Parser < Ruby2Ruby
|
|
3
|
-
# @@parser = defined?(RubyParser) ? 'RubyParser' : 'ParseTree'
|
|
4
|
-
@@parser = 'RubyParser'
|
|
5
|
-
|
|
6
3
|
class << self
|
|
7
4
|
def jail(code, allowed_fcalls = [])
|
|
8
5
|
@@allowed_fcalls = allowed_fcalls
|
|
9
6
|
tree = parse code
|
|
10
7
|
self.new.process(tree)
|
|
11
8
|
end
|
|
12
|
-
|
|
9
|
+
|
|
13
10
|
def parse(code)
|
|
14
|
-
|
|
15
|
-
# when 'ParseTree'
|
|
16
|
-
# ParseTree.translate(code)
|
|
17
|
-
when 'RubyParser'
|
|
18
|
-
RubyParser.new.parse(code)
|
|
19
|
-
else
|
|
20
|
-
raise "unknown parser #{@@parser}"
|
|
21
|
-
end
|
|
22
|
-
end
|
|
23
|
-
|
|
24
|
-
def parser=(parser)
|
|
25
|
-
@@parser = parser
|
|
11
|
+
Prism::Translation::RubyParser.parse(code)
|
|
26
12
|
end
|
|
27
13
|
end
|
|
28
|
-
|
|
29
|
-
def jail(str, parentheses = false)
|
|
30
|
-
str =
|
|
14
|
+
|
|
15
|
+
def jail(str, parentheses = false, safe_call: false)
|
|
16
|
+
str = if str
|
|
17
|
+
dot = safe_call ? "&." : "."
|
|
18
|
+
parentheses ? "(#{str})#{dot}" : "#{str}#{dot}"
|
|
19
|
+
end
|
|
31
20
|
"#{str}to_jail"
|
|
32
21
|
end
|
|
33
22
|
|
|
34
23
|
# split up #process_call. see below ...
|
|
35
|
-
def process_call(exp)
|
|
36
|
-
|
|
37
|
-
name = exp.shift
|
|
38
|
-
args = process_call_args(exp)
|
|
24
|
+
def process_call(exp, safe_call = false)
|
|
25
|
+
_, recv, name, *args = exp
|
|
39
26
|
|
|
40
|
-
|
|
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
|
+
|
|
33
|
+
receiver = jail(process_call_receiver(recv), safe_call: safe_call)
|
|
34
|
+
arguments = process_call_args(name, args)
|
|
35
|
+
|
|
36
|
+
process_call_code(receiver, name, arguments, safe_call)
|
|
41
37
|
end
|
|
42
|
-
|
|
38
|
+
|
|
43
39
|
def process_fcall(exp)
|
|
44
40
|
# using haml we probably never arrive here because :lasgn'ed :fcalls
|
|
45
41
|
# somehow seem to change to :calls somewhere during processing
|
|
@@ -69,9 +65,17 @@ module Safemode
|
|
|
69
65
|
end
|
|
70
66
|
end
|
|
71
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
|
+
|
|
72
76
|
# see http://www.namikilab.tuat.ac.jp/~sasada/prog/rubynodes/nodes.html
|
|
73
77
|
|
|
74
|
-
|
|
78
|
+
ALLOWED_NODES = [ :call, :safe_call, :fcall, :vcall, :evstr, :const, :arglist,
|
|
75
79
|
:lvar, :dvar, :ivar, :lasgn, :masgn, :dasgn, :dasgn_curr,
|
|
76
80
|
:lit, :str, :dstr, :dsym, :nil, :true, :false,
|
|
77
81
|
:array, :zarray, :hash, :dot2, :dot3, :flip2, :flip3,
|
|
@@ -85,29 +89,48 @@ module Safemode
|
|
|
85
89
|
# :colon2 is used for module constants
|
|
86
90
|
:colon2,
|
|
87
91
|
# unnecessarily advanced?
|
|
88
|
-
:argscat, :argspush, :splat, :
|
|
89
|
-
|
|
92
|
+
:argscat, :argspush, :splat, :kwsplat,
|
|
93
|
+
# NOTE: op_asgn*/safe_op_asgn* do not insert .to_jail on the
|
|
94
|
+
# receiver. Setters are called directly on the real object, bypassing Jail.
|
|
95
|
+
:op_asgn, :op_asgn1, :op_asgn2, :op_asgn_and, :op_asgn_or,
|
|
96
|
+
:safe_op_asgn, :safe_op_asgn2,
|
|
97
|
+
# pattern matching (Ruby 3.0+)
|
|
98
|
+
:in, :array_pat, :hash_pat, :find_pat, :kwrest,
|
|
90
99
|
# needed for haml
|
|
91
|
-
:block ]
|
|
100
|
+
:block ].freeze
|
|
101
|
+
|
|
102
|
+
def process(exp)
|
|
103
|
+
if exp && !ALLOWED_NODES.include?(exp.sexp_type)
|
|
104
|
+
raise_security_error(exp.sexp_type, nil)
|
|
105
|
+
end
|
|
106
|
+
super
|
|
107
|
+
end
|
|
92
108
|
|
|
93
109
|
disallowed = [ # :self, # self doesn't seem to be needed for vcalls?
|
|
94
110
|
# see below for :const handling
|
|
95
111
|
:defn, :defs, :alias, :valias, :undef, :class, :attrset,
|
|
96
112
|
:module, :sclass, :colon3,
|
|
97
|
-
:fbody, :scope, :block_arg, :postexe,
|
|
113
|
+
:fbody, :scope, :block_arg, :postexe, :preexe,
|
|
98
114
|
:redo, :retry, :begin, :rescue, :resbody, :ensure,
|
|
99
115
|
:defined, :super, :zsuper, :return,
|
|
100
116
|
:dmethod, :bmethod, :to_ary, :svalue, :match,
|
|
101
|
-
:attrasgn, :
|
|
117
|
+
:attrasgn, :safe_attrasgn,
|
|
118
|
+
:cdecl, :cvasgn, :cvdecl, :cvar, :gvar, :gasgn,
|
|
102
119
|
:xstr, :dxstr,
|
|
103
120
|
# not sure how secure ruby regexp is, so leave it out for now
|
|
104
|
-
:dregx, :dregx_once, :match2, :match3, :nth_ref, :back_ref
|
|
121
|
+
:dregx, :dregx_once, :match2, :match3, :nth_ref, :back_ref,
|
|
122
|
+
# block_pass represents &:method, which would bypass the whitelist e.g. by array.each(&:destroy)
|
|
123
|
+
# at this point we don't know the receiver so we rather disable it completely,
|
|
124
|
+
# use array.each { |item| item.destroy } instead
|
|
125
|
+
:block_pass,
|
|
126
|
+
# lambda creates Proc objects
|
|
127
|
+
:lambda ]
|
|
105
128
|
|
|
106
|
-
# SexpProcessor bails when we overwrite these ... but they are listed as
|
|
129
|
+
# SexpProcessor bails when we overwrite these ... but they are listed as
|
|
107
130
|
# "internal nodes that you can't get to" in sexp_processor.rb
|
|
108
131
|
# :ifunc, :method, :last, :opt_n, :cfunc, :newline, :alloca, :memo, :cref
|
|
109
|
-
|
|
110
|
-
disallowed.each do |name|
|
|
132
|
+
|
|
133
|
+
disallowed.each do |name|
|
|
111
134
|
define_method "process_#{name}" do |arg|
|
|
112
135
|
code = super(arg)
|
|
113
136
|
raise_security_error(name, code)
|
|
@@ -115,74 +138,142 @@ module Safemode
|
|
|
115
138
|
end
|
|
116
139
|
|
|
117
140
|
def process_const(arg)
|
|
118
|
-
|
|
119
|
-
|
|
141
|
+
sexp_type = arg.sexp_body.sexp_type # constants are encoded as: "s(:const, :Encoding)"
|
|
142
|
+
if sexp_type == :Encoding
|
|
143
|
+
# handling of Encoding constants.
|
|
120
144
|
# Note: ruby_parser evaluates __ENCODING__ to s(:colon2, s(:const, :Encoding), :UTF_8)
|
|
121
145
|
"#{super(arg).gsub('-', '_')}"
|
|
122
|
-
elsif
|
|
146
|
+
elsif sexp_type == :String
|
|
123
147
|
# Allow String.new as used in ERB in Ruby 2.4+ to create a string buffer
|
|
124
148
|
super(arg).to_s
|
|
125
149
|
else
|
|
126
150
|
raise_security_error("constant", super(arg))
|
|
127
151
|
end
|
|
128
152
|
end
|
|
129
|
-
|
|
153
|
+
|
|
130
154
|
def raise_security_error(type, info)
|
|
131
155
|
raise Safemode::SecurityError.new(type, info)
|
|
132
156
|
end
|
|
133
|
-
|
|
157
|
+
|
|
134
158
|
# split up Ruby2Ruby#process_call monster method so we can hook into it
|
|
135
159
|
# in a more readable manner
|
|
136
160
|
|
|
137
|
-
def process_call_receiver(
|
|
138
|
-
receiver_node_type =
|
|
139
|
-
receiver = process
|
|
140
|
-
receiver = "(#{receiver})" if
|
|
141
|
-
Ruby2Ruby::ASSIGN_NODES.include? receiver_node_type
|
|
161
|
+
def process_call_receiver(recv)
|
|
162
|
+
receiver_node_type = recv && recv.sexp_type
|
|
163
|
+
receiver = process recv
|
|
164
|
+
receiver = "(#{receiver})" if ASSIGN_NODES.include? receiver_node_type
|
|
142
165
|
receiver
|
|
143
166
|
end
|
|
144
167
|
|
|
145
|
-
def process_call_args(
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
168
|
+
def process_call_args(name, args)
|
|
169
|
+
in_context :arglist do
|
|
170
|
+
max = args.size - 1
|
|
171
|
+
args = args.map.with_index { |arg, i|
|
|
172
|
+
arg_type = arg.sexp_type
|
|
173
|
+
is_empty_hash = arg == s(:hash)
|
|
174
|
+
arg = process arg
|
|
175
|
+
|
|
176
|
+
next if arg.empty?
|
|
177
|
+
|
|
178
|
+
strip_hash = (arg_type == :hash and
|
|
179
|
+
not BINARY.include? name and
|
|
180
|
+
not is_empty_hash and
|
|
181
|
+
(i == max or args[i + 1].sexp_type == :splat))
|
|
182
|
+
wrap_arg = Ruby2Ruby::ASSIGN_NODES.include? arg_type
|
|
183
|
+
|
|
184
|
+
arg = arg[2..-3] if strip_hash
|
|
185
|
+
arg = "(#{arg})" if wrap_arg
|
|
186
|
+
|
|
187
|
+
arg
|
|
188
|
+
}.compact
|
|
155
189
|
end
|
|
156
|
-
args.empty? ? nil : args.join(", ")
|
|
157
190
|
end
|
|
158
191
|
|
|
159
|
-
def process_call_code(receiver, name, args)
|
|
192
|
+
def process_call_code(receiver, name, args, safe_call)
|
|
160
193
|
case name
|
|
161
|
-
when
|
|
162
|
-
|
|
194
|
+
when *BINARY then
|
|
195
|
+
if safe_call
|
|
196
|
+
"#{receiver}&.#{name}(#{args.join(", ")})"
|
|
197
|
+
elsif args.length > 1
|
|
198
|
+
"#{receiver}.#{name}(#{args.join(", ")})"
|
|
199
|
+
else
|
|
200
|
+
"(#{receiver} #{name} #{args.join(", ")})"
|
|
201
|
+
end
|
|
163
202
|
when :[] then
|
|
164
|
-
|
|
203
|
+
receiver ||= "self"
|
|
204
|
+
"#{receiver}[#{args.join(", ")}]"
|
|
205
|
+
when :[]= then
|
|
206
|
+
receiver ||= "self"
|
|
207
|
+
rhs = args.pop
|
|
208
|
+
"#{receiver}[#{args.join(", ")}] = #{rhs}"
|
|
209
|
+
when :"!" then
|
|
210
|
+
"(not #{receiver})"
|
|
165
211
|
when :"-@" then
|
|
166
212
|
"-#{receiver}"
|
|
167
213
|
when :"+@" then
|
|
168
214
|
"+#{receiver}"
|
|
169
215
|
else
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
216
|
+
args = nil if args.empty?
|
|
217
|
+
args = "(#{args.join(", ")})" if args
|
|
218
|
+
receiver = "#{receiver}." if receiver and not safe_call
|
|
219
|
+
receiver = "#{receiver}&." if receiver and safe_call
|
|
220
|
+
|
|
221
|
+
"#{receiver}#{name}#{args}"
|
|
222
|
+
end
|
|
223
|
+
end
|
|
224
|
+
|
|
225
|
+
# Ruby2Ruby bug: __var adds ^ (pin) to all lvars inside :in context,
|
|
226
|
+
# including the body after "then" where ^ is invalid syntax.
|
|
227
|
+
# Fix: process body outside the :in context.
|
|
228
|
+
def process_in(exp)
|
|
229
|
+
_, pattern, *body = exp
|
|
230
|
+
|
|
231
|
+
guard = extract_guard(pattern)
|
|
232
|
+
cond = process pattern
|
|
233
|
+
body = body.compact.map { |sexp|
|
|
234
|
+
in_context :in_body do
|
|
235
|
+
indent process sexp
|
|
174
236
|
end
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
body << indent("# do nothing") if body.empty?
|
|
240
|
+
body = body.join "\n"
|
|
241
|
+
|
|
242
|
+
header = "in #{cond}"
|
|
243
|
+
header << " #{guard}" if guard
|
|
244
|
+
"#{header} then\n#{body.chomp}"
|
|
245
|
+
end
|
|
246
|
+
|
|
247
|
+
# Prism translates guard clauses (in pattern if cond / in pattern unless cond)
|
|
248
|
+
# as s(:if, guard, pattern, nil) / s(:if, guard, nil, pattern). We detect this
|
|
249
|
+
# and rewrite the sexp in-place so process_if renders only the pattern, then
|
|
250
|
+
# return the guard string for process_in to append.
|
|
251
|
+
def extract_guard(pattern)
|
|
252
|
+
return unless pattern.sexp_type == :if
|
|
253
|
+
|
|
254
|
+
_, guard_sexp, if_body, else_body = pattern
|
|
255
|
+
if if_body && !else_body
|
|
256
|
+
guard_str = in_context(:in_body) { "if #{process guard_sexp.deep_clone}" }
|
|
257
|
+
pattern.clear
|
|
258
|
+
if_body.each { |node| pattern << node }
|
|
259
|
+
elsif else_body && !if_body
|
|
260
|
+
guard_str = in_context(:in_body) { "unless #{process guard_sexp.deep_clone}" }
|
|
261
|
+
pattern.clear
|
|
262
|
+
else_body.each { |node| pattern << node }
|
|
175
263
|
end
|
|
264
|
+
|
|
265
|
+
guard_str
|
|
176
266
|
end
|
|
177
|
-
|
|
267
|
+
|
|
178
268
|
# Ruby2Ruby process_if rewrites if and unless statements in a way that
|
|
179
269
|
# makes the result unusable for evaluation in, e.g. ERB which appends a
|
|
180
|
-
# call to to_s when using <%= %> tags. We'd need to either enclose the
|
|
270
|
+
# call to to_s when using <%= %> tags. We'd need to either enclose the
|
|
181
271
|
# result from process_if into parentheses like (1 if true) and
|
|
182
272
|
# (true ? (1) : (2)) or just use the plain if-then-else-end syntax (so
|
|
183
273
|
# that ERB can safely append to_s to the resulting block).
|
|
184
274
|
|
|
185
275
|
def process_if(exp)
|
|
276
|
+
exp.shift # remove ":if" symbol from exp
|
|
186
277
|
expand = Ruby2Ruby::ASSIGN_NODES.include? exp.first.first
|
|
187
278
|
c = process exp.shift
|
|
188
279
|
t = process exp.shift
|
|
@@ -212,6 +303,6 @@ module Safemode
|
|
|
212
303
|
# end
|
|
213
304
|
"unless #{c} then\n#{indent(f)}\nend"
|
|
214
305
|
end
|
|
215
|
-
end
|
|
216
|
-
end
|
|
306
|
+
end
|
|
307
|
+
end
|
|
217
308
|
end
|
data/lib/safemode/scope.rb
CHANGED
|
@@ -1,58 +1,66 @@
|
|
|
1
1
|
module Safemode
|
|
2
2
|
class Scope < Blankslate
|
|
3
|
-
def initialize(delegate = nil, delegate_methods = [])
|
|
4
|
-
@delegate = delegate
|
|
3
|
+
def initialize(delegate = nil, delegate_methods = [], instance_vars: {}, locals: {}, &block)
|
|
4
|
+
@delegate = delegate
|
|
5
5
|
@delegate_methods = delegate_methods
|
|
6
|
-
@locals = {}
|
|
7
|
-
end
|
|
8
|
-
|
|
9
|
-
def bind(instance_vars = {}, locals = {}, &block)
|
|
10
6
|
@locals = symbolize_keys(locals) # why can't I just pull them to local scope in the same way like instance_vars?
|
|
11
7
|
instance_vars = symbolize_keys(instance_vars)
|
|
12
8
|
instance_vars.each {|key, obj| eval "@#{key} = instance_vars[:#{key}]" }
|
|
13
9
|
@_safemode_output = ''
|
|
14
|
-
binding
|
|
10
|
+
@binding = binding
|
|
11
|
+
end
|
|
12
|
+
|
|
13
|
+
def get_binding
|
|
14
|
+
@binding
|
|
15
15
|
end
|
|
16
|
-
|
|
16
|
+
|
|
17
17
|
def to_jail
|
|
18
18
|
self
|
|
19
19
|
end
|
|
20
|
-
|
|
20
|
+
|
|
21
21
|
def puts(*args)
|
|
22
22
|
print args.to_s + "\n"
|
|
23
23
|
end
|
|
24
24
|
|
|
25
|
-
def print(*args)
|
|
25
|
+
def print(*args)
|
|
26
26
|
@_safemode_output += args.to_s
|
|
27
27
|
end
|
|
28
|
-
|
|
28
|
+
|
|
29
29
|
def output
|
|
30
30
|
@_safemode_output
|
|
31
31
|
end
|
|
32
32
|
|
|
33
|
-
def method_missing(method, *args, &block)
|
|
33
|
+
def method_missing(method, *args, **kwargs, &block)
|
|
34
34
|
if @locals.has_key?(method)
|
|
35
35
|
@locals[method]
|
|
36
36
|
elsif @delegate_methods.include?(method)
|
|
37
|
-
@delegate.send method, *unjail_args(args), &block
|
|
37
|
+
@delegate.send method, *unjail_args(args), **unjail_kwargs(kwargs), &block
|
|
38
38
|
else
|
|
39
39
|
raise Safemode::SecurityError.new(method, "#<Safemode::ScopeObject>")
|
|
40
40
|
end
|
|
41
41
|
end
|
|
42
|
-
|
|
42
|
+
|
|
43
43
|
private
|
|
44
|
-
|
|
44
|
+
|
|
45
45
|
def symbolize_keys(hash)
|
|
46
|
-
hash.inject({}) do |hash, (key, value)|
|
|
46
|
+
hash.inject({}) do |hash, (key, value)|
|
|
47
47
|
hash[key.to_s.intern] = value
|
|
48
48
|
hash
|
|
49
49
|
end
|
|
50
50
|
end
|
|
51
|
-
|
|
51
|
+
|
|
52
|
+
IVAR_GET = Object.instance_method(:instance_variable_get)
|
|
53
|
+
|
|
54
|
+
def unjail(arg)
|
|
55
|
+
arg.class.name.end_with?('::Jail') ? IVAR_GET.bind_call(arg, :@source) : arg
|
|
56
|
+
end
|
|
57
|
+
|
|
52
58
|
def unjail_args(args)
|
|
53
|
-
args.collect
|
|
54
|
-
|
|
55
|
-
|
|
59
|
+
args.collect { |arg| unjail(arg) }
|
|
60
|
+
end
|
|
61
|
+
|
|
62
|
+
def unjail_kwargs(kwargs)
|
|
63
|
+
kwargs.map { |key, value| [unjail(key), unjail(value)] }.to_h
|
|
56
64
|
end
|
|
57
65
|
end
|
|
58
66
|
end
|
data/lib/safemode.rb
CHANGED
|
@@ -1,17 +1,8 @@
|
|
|
1
1
|
require 'rubygems'
|
|
2
2
|
|
|
3
3
|
require 'ruby2ruby'
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
rescue LoadError => e
|
|
7
|
-
end
|
|
8
|
-
# this doesn't work somehow. Maybe something changed inside
|
|
9
|
-
# ParseTree or sexp_processor or so.
|
|
10
|
-
# (the require itself works, but ParseTree doesn't play nice)
|
|
11
|
-
# begin
|
|
12
|
-
# require 'parse_tree'
|
|
13
|
-
# rescue LoadError => e
|
|
14
|
-
# end
|
|
4
|
+
require 'prism'
|
|
5
|
+
require 'prism/translation/ruby_parser'
|
|
15
6
|
|
|
16
7
|
require 'safemode/core_ext'
|
|
17
8
|
require 'safemode/blankslate'
|
|
@@ -26,7 +17,7 @@ module Safemode
|
|
|
26
17
|
def jail(obj)
|
|
27
18
|
find_jail_class(obj.is_a?(Class) ? obj : obj.class).new obj
|
|
28
19
|
end
|
|
29
|
-
|
|
20
|
+
|
|
30
21
|
def find_jail_class(klass)
|
|
31
22
|
while klass != Object
|
|
32
23
|
return klass.const_get('Jail') if klass.const_defined?('Jail')
|
|
@@ -35,24 +26,25 @@ module Safemode
|
|
|
35
26
|
Jail
|
|
36
27
|
end
|
|
37
28
|
end
|
|
38
|
-
|
|
29
|
+
|
|
39
30
|
define_core_jail_classes
|
|
40
|
-
|
|
31
|
+
|
|
41
32
|
class Box
|
|
42
33
|
def initialize(delegate = nil, delegate_methods = [], filename = nil, line = nil)
|
|
43
|
-
@
|
|
34
|
+
@delegate = delegate
|
|
35
|
+
@delegate_methods = delegate_methods
|
|
44
36
|
@filename = filename
|
|
45
37
|
@line = line
|
|
46
|
-
end
|
|
38
|
+
end
|
|
47
39
|
|
|
48
40
|
def eval(code, assigns = {}, locals = {}, &block)
|
|
49
41
|
code = Parser.jail(code)
|
|
50
|
-
|
|
51
|
-
|
|
42
|
+
@scope = Scope.new(@delegate, @delegate_methods, instance_vars: assigns, locals: locals, &block)
|
|
43
|
+
Kernel.eval(code, @scope.get_binding, @filename || __FILE__, @line || __LINE__)
|
|
52
44
|
end
|
|
53
|
-
|
|
45
|
+
|
|
54
46
|
def output
|
|
55
47
|
@scope.output
|
|
56
|
-
end
|
|
48
|
+
end
|
|
57
49
|
end
|
|
58
50
|
end
|
data/safemode.gemspec
CHANGED
|
@@ -1,36 +1,41 @@
|
|
|
1
|
-
#
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
# -*- encoding: utf-8 -*-
|
|
5
|
-
# stub: safemode 1.3.1 ruby lib
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require 'date'
|
|
6
4
|
|
|
7
5
|
Gem::Specification.new do |s|
|
|
8
6
|
s.name = "safemode".freeze
|
|
9
|
-
s.version = "
|
|
7
|
+
s.version = "2.0.3"
|
|
8
|
+
s.date = Date.today
|
|
9
|
+
|
|
10
|
+
s.summary = "A library for safe evaluation of Ruby code based on Prism and Ruby2Ruby"
|
|
11
|
+
s.description = "A library for safe evaluation of Ruby code based on RubyParser and Ruby2Ruby. Provides Rails ActionView template handlers for ERB and Haml."
|
|
12
|
+
s.homepage = "https://github.com/svenfuchs/safemode"
|
|
13
|
+
s.licenses = ["MIT"]
|
|
14
|
+
|
|
15
|
+
s.authors = [
|
|
16
|
+
"Sven Fuchs",
|
|
17
|
+
"Peter Cooper",
|
|
18
|
+
"Matthias Viehweger",
|
|
19
|
+
"Kingsley Hendrickse",
|
|
20
|
+
"Ohad Levy",
|
|
21
|
+
"Dmitri Dolguikh",
|
|
22
|
+
]
|
|
10
23
|
|
|
11
|
-
s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
|
|
12
|
-
s.require_paths = ["lib".freeze]
|
|
13
|
-
s.authors = ["Sven Fuchs".freeze, "Peter Cooper".freeze, "Matthias Viehweger".freeze, "Kingsley Hendrickse".freeze, "Ohad Levy".freeze, "Dmitri Dolguikh".freeze]
|
|
14
|
-
s.date = "2017-02-13"
|
|
15
|
-
s.description = "A library for safe evaluation of Ruby code based on RubyParser and Ruby2Ruby. Provides Rails ActionView template handlers for ERB and Haml.".freeze
|
|
16
|
-
s.email = "ohadlevy@gmail.com".freeze
|
|
17
24
|
s.extra_rdoc_files = [
|
|
25
|
+
"LICENSE",
|
|
18
26
|
"README.markdown"
|
|
19
27
|
]
|
|
20
28
|
s.files = [
|
|
21
29
|
"Gemfile",
|
|
22
|
-
"
|
|
30
|
+
"LICENSE",
|
|
23
31
|
"README.markdown",
|
|
24
32
|
"Rakefile",
|
|
25
|
-
"VERSION",
|
|
26
33
|
"demo.rb",
|
|
27
34
|
"init.rb",
|
|
28
35
|
"lib/action_view/template_handlers/safe_erb.rb",
|
|
29
36
|
"lib/action_view/template_handlers/safe_haml.rb",
|
|
30
37
|
"lib/action_view/template_handlers/safemode_handler.rb",
|
|
31
38
|
"lib/haml/safemode.rb",
|
|
32
|
-
"lib/ruby_parser_string_io_patch.diff",
|
|
33
|
-
"lib/rubyparser_bug.rb",
|
|
34
39
|
"lib/safemode.rb",
|
|
35
40
|
"lib/safemode/blankslate.rb",
|
|
36
41
|
"lib/safemode/core_ext.rb",
|
|
@@ -44,53 +49,19 @@ Gem::Specification.new do |s|
|
|
|
44
49
|
"test/test_helper.rb",
|
|
45
50
|
"test/test_jail.rb",
|
|
46
51
|
"test/test_safemode_eval.rb",
|
|
47
|
-
"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"
|
|
48
55
|
]
|
|
49
|
-
s.homepage = "http://github.com/svenfuchs/safemode".freeze
|
|
50
|
-
s.licenses = ["MIT".freeze]
|
|
51
|
-
s.rubygems_version = "2.6.10".freeze
|
|
52
|
-
s.summary = "A library for safe evaluation of Ruby code based on ParseTree/RubyParser and Ruby2Ruby".freeze
|
|
53
56
|
|
|
54
|
-
|
|
55
|
-
s.specification_version = 4
|
|
57
|
+
s.required_ruby_version = ">= 3.0", "< 3.4"
|
|
56
58
|
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
s.add_runtime_dependency(%q<ruby_parser>.freeze, [">= 3.2.0"])
|
|
61
|
-
s.add_development_dependency(%q<shoulda>.freeze, [">= 0"])
|
|
62
|
-
s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
|
|
63
|
-
s.add_development_dependency(%q<bundler>.freeze, ["~> 1.0"])
|
|
64
|
-
s.add_development_dependency(%q<jeweler>.freeze, [">= 0"])
|
|
65
|
-
s.add_development_dependency(%q<rcov>.freeze, [">= 0"])
|
|
66
|
-
s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
|
|
67
|
-
s.add_development_dependency(%q<test-unit>.freeze, [">= 0"])
|
|
68
|
-
s.add_development_dependency(%q<rake>.freeze, [">= 0"])
|
|
69
|
-
else
|
|
70
|
-
s.add_dependency(%q<sexp_processor>.freeze, [">= 4.3.0"])
|
|
71
|
-
s.add_dependency(%q<ruby2ruby>.freeze, [">= 2.0.6"])
|
|
72
|
-
s.add_dependency(%q<ruby_parser>.freeze, [">= 3.2.0"])
|
|
73
|
-
s.add_dependency(%q<shoulda>.freeze, [">= 0"])
|
|
74
|
-
s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
|
|
75
|
-
s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
|
|
76
|
-
s.add_dependency(%q<jeweler>.freeze, [">= 0"])
|
|
77
|
-
s.add_dependency(%q<rcov>.freeze, [">= 0"])
|
|
78
|
-
s.add_dependency(%q<simplecov>.freeze, [">= 0"])
|
|
79
|
-
s.add_dependency(%q<test-unit>.freeze, [">= 0"])
|
|
80
|
-
s.add_dependency(%q<rake>.freeze, [">= 0"])
|
|
81
|
-
end
|
|
82
|
-
else
|
|
83
|
-
s.add_dependency(%q<sexp_processor>.freeze, [">= 4.3.0"])
|
|
84
|
-
s.add_dependency(%q<ruby2ruby>.freeze, [">= 2.0.6"])
|
|
85
|
-
s.add_dependency(%q<ruby_parser>.freeze, [">= 3.2.0"])
|
|
86
|
-
s.add_dependency(%q<shoulda>.freeze, [">= 0"])
|
|
87
|
-
s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
|
|
88
|
-
s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
|
|
89
|
-
s.add_dependency(%q<jeweler>.freeze, [">= 0"])
|
|
90
|
-
s.add_dependency(%q<rcov>.freeze, [">= 0"])
|
|
91
|
-
s.add_dependency(%q<simplecov>.freeze, [">= 0"])
|
|
92
|
-
s.add_dependency(%q<test-unit>.freeze, [">= 0"])
|
|
93
|
-
s.add_dependency(%q<rake>.freeze, [">= 0"])
|
|
94
|
-
end
|
|
95
|
-
end
|
|
59
|
+
s.add_runtime_dependency "ruby2ruby", "~> 2.4"
|
|
60
|
+
s.add_runtime_dependency "prism", "~> 1.0"
|
|
61
|
+
s.add_runtime_dependency "sexp_processor", "~> 4.10"
|
|
96
62
|
|
|
63
|
+
s.add_development_dependency "rake", "~> 13.4"
|
|
64
|
+
s.add_development_dependency "rdoc", "~> 7.2"
|
|
65
|
+
s.add_development_dependency "simplecov", "~> 0.22"
|
|
66
|
+
s.add_development_dependency "test-unit", "~> 3.7"
|
|
67
|
+
end
|