Command injection from untrusted input in Ruby backtick subshell

require 'open3'

# SECURE: Replace backticks with Open3
def get_user_files_safe(username)
  # Validate username
  return [] unless valid_username?(username)
  
  # SECURE: Open3 with argument array
  stdout, stderr, status = Open3.capture3('ls', "/home/#{username}")
  
  if status.success?
    stdout.split("\n")
  else
    []
  end
rescue => e
  []
end

def search_logs_safe(pattern)
  # Validate search pattern
  return "" unless valid_search_pattern?(pattern)
  
  # SECURE: grep with separate arguments
  stdout, stderr, status = Open3.capture3('grep', pattern, '/var/log/app.log')
  
  status.success? ? stdout : ""
rescue => e
  ""
end

def valid_username?(username)
  username.match?(/\A[a-zA-Z0-9_-]+\z/) && username.length <= 32
end

def valid_search_pattern?(pattern)
  # Allow alphanumeric and basic regex chars
  pattern.match?(/\A[a-zA-Z0-9\s.*+?\[\]()-]+\z/) && pattern.length <= 100
end

require 'open3'
require 'shellwords'

# SECURE: Command allowlisting with safe execution
class SecureCommandRunner
  ALLOWED_COMMANDS = {
    'list_files' => {
      command: 'ls',
      args: ['-la'],
      max_args: 1
    },
    'file_info' => {
      command: 'file',
      args: [],
      max_args: 1
    },
    'word_count' => {
      command: 'wc',
      args: ['-l'],
      max_args: 1
    },
    'search_text' => {
      command: 'grep',
      args: ['-n'],
      max_args: 2  # pattern and file
    }
  }.freeze
  
  SAFE_DIRECTORIES = ['/safe/uploads', '/safe/documents'].freeze
  
  def execute_command(operation, *user_args)
    # Validate operation
    config = ALLOWED_COMMANDS[operation]
    raise ArgumentError, 'Operation not allowed' unless config
    
    # Validate argument count
    if user_args.length > config[:max_args]
      raise ArgumentError, 'Too many arguments'
    end
    
    # Validate and sanitize arguments
    safe_args = validate_arguments(user_args)
    
    # Build command array
    command_array = [config[:command]] + config[:args] + safe_args
    
    # Execute safely
    stdout, stderr, status = Open3.capture3(*command_array, 
                                           timeout: 30,
                                           chdir: '/safe/workspace')
    
    {
      success: status.success?,
      output: stdout,
      error: stderr,
      command: command_array.join(' ')
    }
  rescue Timeout::Error
    { success: false, error: 'Command timeout' }
  rescue => e
    { success: false, error: e.message }
  end
  
  private
  
  def validate_arguments(args)
    args.map do |arg|
      # Basic validation
      raise ArgumentError, 'Invalid argument format' unless arg.is_a?(String)
      raise ArgumentError, 'Argument too long' if arg.length > 255
      
      # Check for dangerous characters
      if arg.match?(/[;&|`$(){}\[\]<>]|\\\\|\\.\./)
        raise ArgumentError, 'Argument contains dangerous characters'
      end
      
      # Validate file paths are in safe directories
      if arg.start_with?('/')
        validate_file_path(arg)
      else
        arg
      end
    end
  end
  
  def validate_file_path(path)
    resolved_path = File.expand_path(path)
    
    # Check if path is in safe directories
    safe = SAFE_DIRECTORIES.any? do |safe_dir|
      resolved_path.start_with?(File.expand_path(safe_dir))
    end
    
    raise ArgumentError, 'Path not in safe directory' unless safe
    
    resolved_path
  end
end

# Usage example
runner = SecureCommandRunner.new
result = runner.execute_command('list_files', '/safe/uploads')
puts result[:output] if result[:success]

require 'digest'
require 'find'

# SECURE: Native Ruby file operations
class NativeFileOperations
  SAFE_DIRECTORIES = ['/safe/uploads', '/safe/documents'].freeze
  
  def list_files(directory)
    safe_dir = validate_directory(directory)
    
    files = []
    Find.find(safe_dir) do |path|
      next unless File.file?(path)
      
      stat = File.stat(path)
      files << {
        name: File.basename(path),
        path: path,
        size: stat.size,
        modified: stat.mtime,
        permissions: sprintf('%o', stat.mode)[-3..-1]
      }
    end
    
    files
  rescue => e
    []
  end
  
  def search_in_file(filename, pattern)
    file_path = validate_file_path(filename)
    
    matches = []
    File.foreach(file_path).with_index(1) do |line, line_num|
      if line.match?(Regexp.new(Regexp.escape(pattern)))
        matches << {
          line_number: line_num,
          content: line.chomp,
          match: pattern
        }
      end
    end
    
    matches
  rescue => e
    []
  end
  
  def get_file_info(filename)
    file_path = validate_file_path(filename)
    stat = File.stat(file_path)
    
    {
      name: File.basename(file_path),
      size: stat.size,
      size_human: format_size(stat.size),
      modified: stat.mtime,
      type: File.extname(file_path),
      readable: File.readable?(file_path),
      writable: File.writable?(file_path)
    }
  end
  
  def calculate_checksum(filename)
    file_path = validate_file_path(filename)
    
    File.open(file_path, 'rb') do |file|
      content = file.read
      {
        md5: Digest::MD5.hexdigest(content),
        sha1: Digest::SHA1.hexdigest(content),
        sha256: Digest::SHA256.hexdigest(content),
        size: content.length
      }
    end
  end
  
  def count_lines(filename)
    file_path = validate_file_path(filename)
    
    line_count = 0
    word_count = 0
    char_count = 0
    
    File.foreach(file_path) do |line|
      line_count += 1
      char_count += line.length
      word_count += line.split.length
    end
    
    {
      lines: line_count,
      words: word_count,
      characters: char_count
    }
  end
  
  private
  
  def validate_directory(directory)
    # Basic validation
    raise ArgumentError, 'Invalid directory' unless directory.is_a?(String)
    
    resolved_dir = File.expand_path(directory)
    
    # Check if directory is safe
    safe = SAFE_DIRECTORIES.any? do |safe_dir|
      resolved_dir.start_with?(File.expand_path(safe_dir))
    end
    
    raise ArgumentError, 'Directory not allowed' unless safe
    raise ArgumentError, 'Directory does not exist' unless Dir.exist?(resolved_dir)
    
    resolved_dir
  end
  
  def validate_file_path(filename)
    # Filename validation
    raise ArgumentError, 'Invalid filename' unless filename.match?(/\A[a-zA-Z0-9._-]+\z/)
    raise ArgumentError, 'Filename too long' if filename.length > 255
    
    # Find file in safe directories
    SAFE_DIRECTORIES.each do |dir|
      candidate_path = File.join(dir, filename)
      resolved_path = File.expand_path(candidate_path)
      
      next unless resolved_path.start_with?(File.expand_path(dir))
      
      if File.exist?(resolved_path) && File.file?(resolved_path)
        return resolved_path
      end
    end
    
    raise ArgumentError, 'File not found in safe directories'
  end
  
  def format_size(size)
    units = %w[B KB MB GB TB]
    unit_index = 0
    
    while size >= 1024 && unit_index < units.length - 1
      size /= 1024.0
      unit_index += 1
    end
    
    "#{size.round(2)} #{units[unit_index]}"
  end
end

# Usage
file_ops = NativeFileOperations.new
files = file_ops.list_files('/safe/uploads')
info = file_ops.get_file_info('document.txt')
matches = file_ops.search_in_file('log.txt', 'ERROR')