mirror of
https://github.com/waybarrios/opencode-power-pack.git
synced 2026-11-18 18:03:43 +00:00
Code quality, design patterns, paper summarization, plus 5 security review skills (supply-chain risk, sharp edges, insecure defaults, false-positive check, vuln reporting). Full UPSTREAMS.json provenance, skill count 11 -> 19.
274 lines
6.1 KiB
Markdown
274 lines
6.1 KiB
Markdown
# Ruby Sharp Edges
|
|
|
|
## Dynamic Code Execution
|
|
|
|
```ruby
|
|
# DANGEROUS: eval executes arbitrary code
|
|
eval(user_input)
|
|
|
|
# DANGEROUS: send calls arbitrary method
|
|
object.send(user_input, *args)
|
|
object.public_send(user_input) # Only public, still dangerous
|
|
|
|
# DANGEROUS: constantize gets arbitrary class
|
|
user_input.constantize # Rails
|
|
Object.const_get(user_input)
|
|
|
|
# DANGEROUS: instance_variable_get/set
|
|
obj.instance_variable_set("@#{user_input}", value)
|
|
```
|
|
|
|
**Real Vulnerabilities**:
|
|
- CVE-2013-0156: Rails XML parameter parsing led to code execution
|
|
- Countless Rails apps vulnerable to controller#action injection
|
|
|
|
**Fix**: Whitelist allowed values:
|
|
```ruby
|
|
ALLOWED_METHODS = %w[create update delete].freeze
|
|
raise unless ALLOWED_METHODS.include?(user_input)
|
|
object.send(user_input)
|
|
```
|
|
|
|
## YAML.load RCE
|
|
|
|
```ruby
|
|
# DANGEROUS: Like pickle, instantiates arbitrary objects
|
|
YAML.load(user_input)
|
|
|
|
# Attacker payload:
|
|
# --- !ruby/object:Gem::Installer
|
|
# i: x
|
|
# --- !ruby/object:Gem::SpecFetcher
|
|
# i: y
|
|
# --- !ruby/object:Gem::Requirement
|
|
# requirements:
|
|
# !ruby/object:Gem::Package::TarReader
|
|
# io: &1 !ruby/object:Net::BufferedIO
|
|
# ...
|
|
|
|
# Chains through multiple classes to achieve RCE
|
|
```
|
|
|
|
**Fix**: Use `YAML.safe_load`:
|
|
```ruby
|
|
YAML.safe_load(user_input)
|
|
YAML.safe_load(user_input, permitted_classes: [Date, Time])
|
|
```
|
|
|
|
## Mass Assignment
|
|
|
|
```ruby
|
|
# DANGEROUS: All params assigned to model (Rails < 4)
|
|
User.new(params[:user])
|
|
# If params includes {admin: true, role: "superuser"}...
|
|
|
|
# Also dangerous with update_attributes
|
|
user.update_attributes(params[:user])
|
|
```
|
|
|
|
**Fix**: Strong Parameters (Rails 4+):
|
|
```ruby
|
|
def user_params
|
|
params.require(:user).permit(:name, :email) # Allowlist
|
|
end
|
|
|
|
User.new(user_params)
|
|
```
|
|
|
|
## SQL Injection
|
|
|
|
```ruby
|
|
# DANGEROUS: String interpolation in queries
|
|
User.where("name = '#{params[:name]}'")
|
|
User.where("name = '" + params[:name] + "'")
|
|
|
|
# DANGEROUS: Array form with interpolation
|
|
User.where(["name = ?", params[:name]]) # Safe
|
|
User.where(["name = #{params[:name]}"]) # NOT safe!
|
|
|
|
# DANGEROUS: order() with user input
|
|
User.order(params[:sort]) # Can inject: "name; DROP TABLE users--"
|
|
```
|
|
|
|
**Fix**: Use parameterized queries:
|
|
```ruby
|
|
User.where(name: params[:name])
|
|
User.where("name = ?", params[:name])
|
|
User.order(Arel.sql(sanitize(params[:sort]))) # With validation
|
|
```
|
|
|
|
## Command Injection
|
|
|
|
```ruby
|
|
# DANGEROUS: Backticks and system with interpolation
|
|
`ls #{params[:dir]}`
|
|
system("ls #{params[:dir]}")
|
|
exec("ls #{params[:dir]}")
|
|
%x(ls #{params[:dir]})
|
|
|
|
# Attacker: dir="; rm -rf /"
|
|
```
|
|
|
|
**Fix**: Use array form:
|
|
```ruby
|
|
system("ls", params[:dir]) # Argument passed safely
|
|
Open3.capture3("ls", params[:dir])
|
|
```
|
|
|
|
## Regex Injection
|
|
|
|
```ruby
|
|
# DANGEROUS: User input in regex
|
|
pattern = Regexp.new(params[:pattern])
|
|
string.match(pattern)
|
|
|
|
# ReDoS attack: pattern = "(a+)+"
|
|
# Denial of service
|
|
|
|
# Also: Anchors don't work as expected
|
|
/^admin$/.match("admin\nuser") # Matches! ^ and $ match line boundaries
|
|
```
|
|
|
|
**Fix**: Use `\A` and `\z` for string boundaries:
|
|
```ruby
|
|
/\Aadmin\z/ # Only matches exactly "admin"
|
|
Regexp.escape(user_input) # Escape special characters
|
|
```
|
|
|
|
## Symbol DoS (Ruby < 2.2)
|
|
|
|
```ruby
|
|
# DANGEROUS in Ruby < 2.2: Symbols never garbage collected
|
|
params[:key].to_sym # Each unique key creates permanent symbol
|
|
|
|
# Attacker sends millions of unique parameter names
|
|
# Memory exhaustion - symbols fill memory
|
|
```
|
|
|
|
**Note**: Fixed in Ruby 2.2+ with symbol GC, but still worth avoiding unnecessary `to_sym` on user input.
|
|
|
|
## Method Visibility
|
|
|
|
```ruby
|
|
# DANGEROUS: private/protected don't prevent send()
|
|
class Secret
|
|
private
|
|
def sensitive_data
|
|
"secret"
|
|
end
|
|
end
|
|
|
|
obj.send(:sensitive_data) # Works!
|
|
obj.sensitive_data # NoMethodError (as expected)
|
|
```
|
|
|
|
## Default Mutable Arguments
|
|
|
|
```ruby
|
|
# DANGEROUS: Same pattern as Python
|
|
def add_item(item, list = [])
|
|
list << item
|
|
list
|
|
end
|
|
|
|
add_item(1) # [1]
|
|
add_item(2) # [1, 2] - same array!
|
|
```
|
|
|
|
**Fix**: Use nil default:
|
|
```ruby
|
|
def add_item(item, list = nil)
|
|
list ||= []
|
|
list << item
|
|
end
|
|
```
|
|
|
|
## ERB Template Injection
|
|
|
|
```ruby
|
|
# DANGEROUS: User input in ERB template
|
|
template = ERB.new(params[:template])
|
|
template.result(binding)
|
|
|
|
# Attacker template: <%= `whoami` %>
|
|
# Executes shell command
|
|
|
|
# Also via:
|
|
template = params[:template]
|
|
eval("\"#{template}\"") # If template contains #{}
|
|
```
|
|
|
|
## File Operations
|
|
|
|
```ruby
|
|
# DANGEROUS: Path traversal
|
|
File.read("uploads/#{params[:filename]}")
|
|
# Attacker: filename=../../../etc/passwd
|
|
|
|
# DANGEROUS: File.open with pipe
|
|
File.open("|#{params[:cmd]}") # Executes command!
|
|
|
|
# The | prefix runs a command and opens pipe to it
|
|
File.read("|whoami") # Returns output of whoami
|
|
```
|
|
|
|
**Fix**: Validate and sanitize paths:
|
|
```ruby
|
|
path = File.expand_path(params[:filename], uploads_dir)
|
|
raise unless path.start_with?(uploads_dir)
|
|
```
|
|
|
|
## Comparison Gotchas
|
|
|
|
```ruby
|
|
# DANGEROUS: == vs eql? vs equal?
|
|
a = "hello"
|
|
b = "hello"
|
|
|
|
a == b # true - value comparison
|
|
a.eql?(b) # true - value + type comparison
|
|
a.equal?(b) # false - identity comparison
|
|
|
|
# Array comparison
|
|
[1, 2] == [1, 2] # true
|
|
[1, 2].eql?([1, 2]) # true
|
|
[1, 2].equal?([1, 2]) # false
|
|
```
|
|
|
|
## Thread Safety
|
|
|
|
```ruby
|
|
# DANGEROUS: Ruby global interpreter lock (GIL) doesn't protect everything
|
|
@counter = 0
|
|
|
|
threads = 10.times.map do
|
|
Thread.new { 1000.times { @counter += 1 } }
|
|
end
|
|
threads.each(&:join)
|
|
|
|
@counter # May not be 10000! Read-modify-write isn't atomic
|
|
```
|
|
|
|
**Fix**: Use Mutex or atomic operations:
|
|
```ruby
|
|
mutex = Mutex.new
|
|
mutex.synchronize { @counter += 1 }
|
|
```
|
|
|
|
## Detection Patterns
|
|
|
|
| Pattern | Risk |
|
|
|---------|------|
|
|
| `eval(`, `instance_eval(` | Code execution |
|
|
| `.send(user_input`, `.public_send(` | Method injection |
|
|
| `.constantize`, `const_get(` | Class injection |
|
|
| `YAML.load(` | Deserialization RCE |
|
|
| `.new(params[` without strong params | Mass assignment |
|
|
| `where("... #{` | SQL injection |
|
|
| `` `...#{` ``, `system("...#{` | Command injection |
|
|
| `Regexp.new(user_input)` | ReDoS |
|
|
| `params[:x].to_sym` | Symbol DoS (old Ruby) |
|
|
| `ERB.new(user_input)` | Template injection |
|
|
| `File.read("|...` or `File.open("|...` | Command execution |
|
|
| `File.read(params[` without path validation | Path traversal |
|