ruby on rails - cancancan - Proteger los atributos sensibles con la autorización declarativa

cancan gem

Question

¿Cuál es una buena manera de proteger los atributos por rol utilizando la declarative_authorization ? Por ejemplo, un usuario puede editar su información de contacto pero no su función.

Mi primera inclinación fue crear múltiples acciones de controlador para diferentes escenarios. Rápidamente me di cuenta de lo difícil que podría ser esto a medida que el número de atributos protegidos crece. Hacer esto para el rol de usuario es una cosa, pero puedo imaginar múltiples atributos protegidos. Agregar muchas acciones y rutas de control no se siente bien.

Mi segunda inclinación fue crear permisos en torno a atributos sensibles específicos y luego envolver los elementos del formulario con View hepers proporcionados por las autorizaciones declarativas. Sin embargo, el aspecto del modelo y del controlador es un poco confuso en mi mente. Las sugerencias serían impresionantes.

Por favor, aconseje sobre la mejor manera de proteger los atributos por rol utilizando las autorizaciones_certativas.

Answer 1

Evitaría todas las soluciones basadas en el acceso de usuarios en el modelo porque parece potencialmente peligroso. Yo intentaría este enfoque:

class User < ActiveRecord::Base

  def update_attributes_as_user(values, user)
    values.each do |attribute, value|
      # Update the attribute if the user is allowed to
      @user.send("#{attribute}=", value) if user.modifiable_attributes.include?(attribute)
    end
    save
  end

  def modifiable_attributes
    admin? ? [:name, :email, :role] : [:name, :email]
  end
end

Luego en su controlador cambie su acción de actualización desde:

@user.update_attributes(params[:user])

a

@user.update_attributes_as_user(params[:user], current_user)

Answer 2

Para mí, este problema de filtrado es algo que debe aplicarse en el nivel del controlador.

Querrá tener algo en algún lugar que defina cómo decidir qué atributos se pueden escribir para un usuario determinado.

# On the user model
class User < ActiveRecord::Base
  # ...

  # Return a list of symbols representing the accessible attributes
  def self.allowed_params(user)
    if user.admin?
      [:name, :email, :role]
    else
      [:name, email]
    end
  end
end

Luego, en el controlador de la aplicación puede definir un método para filtrar parámetros.

class ApplicationController < ActionController::Base
  # ...
  protected

  def restrict_params(param, model, user)
    params[param].reject! do |k,v|
      !model.allowed_params(user).include?(k)
    end
  end
  # ...
end

Y finalmente, en la acción de tu controlador puedes usar este filtro:

class UserController < ActionController::Base
  # ...
  def update
    restrict_params(:user, User, @current_user)
    # and continue as normal
  end
  # ...
end

La idea es que luego podría definir allowed_params en cada uno de sus modelos, y hacer que los controladores para cada uno de estos utilicen el mismo método de filtro. Usted podría guardar algo de la placa de la caldera si tiene un método en el controlador de la aplicación que emita un filtro anterior, como este:

def self.param_restrictions(param, model)
  before_filter do
    restrict_params(param, model, @current_user) if params[param]
  end
end

# in UserController
param_restrictions :user, User

Estos ejemplos pretenden ser ilustrativos en lugar de definitivos, espero que ayuden con la implementación de esto.

Answer 3

Rails 3.1+ viene con un método + assign_attributes + para este propósito - http://apidock.com/rails/ActiveRecord/AttributeAssignment/assign_attributes .

Answer 4

github.com/thefrontiergroup/scoped_attr_accessible , que se parece a lo que estás buscando. Solo necesita establecer el alcance al inicio de una solicitud para todos los modelos.

Para hacerlo, usa un before_filter en tu application_controller.rb:

before_filter do |controller|
  ScopedAttrAccessible.current_sanitizer_scope = controller.current_user.role
end

Answer 5

EDITAR 2011-05-22
Algo similar está ahora en Rails a partir de 3.1RC https://github.com/rails/rails/blob/master/activerecord/test/cases/mass_assignment_security_test.rb por lo que sugeriría ir esa ruta ahora.

RESPUESTA ORIGINAL
Simplemente tuve que transferir lo que había estado usando anteriormente a Rails 3. Nunca he usado una autorización declarativa específicamente, pero esto es bastante simple y lo suficientemente directo como para que pueda adaptarse a él.

Rails 3 agregó mass_assignment_authorizer , lo que hace que todo esto sea realmente simple. Utilicé ese tutorial vinculado como base y lo hice encajar mejor en mi modelo de dominio, con herencia de clase y agrupando los atributos en roles.

En modelo

acts_as_accessible :admin => :all, :moderator => [:is_spam, :is_featured]
attr_accessible :title, :body # :admin, :moderator, and anyone else can set these

En el controlador

post.accessed_by(current_user.roles.collect(&:code)) # or however yours works
post.attributes = params[:post]

lib / active_record / acts_as_accessible.rb

# A way to have different attr_accessible attributes based on a Role
# @see ActsAsAccessible::ActMethods#acts_as_accessible
module ActiveRecord
  module ActsAsAccessible
    module ActMethods
      # In model
      # acts_as_accessible :admin => :all, :moderator => [:is_spam]
      # attr_accessible :title, :body
      #
      # In controller
      # post.accessed_by(current_user.roles.collect(&:code))
      # post.attributes = params[:post]
      #
      # Warning: This frequently wouldn''t be the concern of the model where this is declared in,
      # but it is so much more useful to have it in there with the attr_accessible declaration.
      # OHWELL.
      #
      # @param [Hash] roles Hash of { :role => [:attr, :attr] }
      # @see acts_as_accessible_attributes
      def acts_as_accessible(*roles)
        roles_attributes_hash = Hash.new {|h,k| h[k] ||= [] }
        roles_attributes_hash = roles_attributes_hash.merge(roles.extract_options!).symbolize_keys

        if !self.respond_to? :acts_as_accessible_attributes
          attr_accessible
          write_inheritable_attribute :acts_as_accessible_attributes, roles_attributes_hash.symbolize_keys
          class_inheritable_reader    :acts_as_accessible_attributes

          # extend ClassMethods unless (class << self; included_modules; end).include?(ClassMethods)
          include InstanceMethods unless included_modules.include?(InstanceMethods)
        else # subclass
          new_acts_as_accessible_attributes = self.acts_as_accessible_attributes.dup
          roles_attributes_hash.each do |role,attrs|
            new_acts_as_accessible_attributes[role] += attrs
          end
          write_inheritable_attribute :acts_as_accessible_attributes, new_acts_as_accessible_attributes.symbolize_keys
        end
      end
    end

    module InstanceMethods
      # @param [Array, NilClass] roles Array of Roles or nil to reset
      # @return [Array, NilClass]
      def accessed_by(*roles)
        if roles.any?
          case roles.first
          when NilClass
            @accessed_by = nil
          when Array
            @accessed_by = roles.first.flatten.collect(&:to_sym)
          else
            @accessed_by = roles.flatten.flatten.collect(&:to_sym)
          end
        end
        @accessed_by
      end

      private
      # This is what really does the work in attr_accessible/attr_protected.
      # This override adds the acts_as_accessible_attributes for the current accessed_by roles.
      # @see http://asciicasts.com/episodes/237-dynamic-attr-accessible
      def mass_assignment_authorizer
        attrs = []
        if self.accessed_by
          self.accessed_by.each do |role|
            if self.acts_as_accessible_attributes.include? role
              if self.acts_as_accessible_attributes[role] == :all
                return self.class.protected_attributes
              else
                attrs += self.acts_as_accessible_attributes[role]
              end
            end
          end
        end
        super + attrs
      end
    end
  end
end

ActiveRecord::Base.send(:extend, ActiveRecord::ActsAsAccessible::ActMethods)

spec / lib / active_record / acts_as_accessible.rb

require ''spec_helper''

class TestActsAsAccessible
  include ActiveModel::MassAssignmentSecurity
  extend ActiveRecord::ActsAsAccessible::ActMethods
  attr_accessor :foo, :bar, :baz, :qux
  acts_as_accessible :dude => [:bar], :bra => [:baz, :qux], :admin => :all
  attr_accessible :foo
  def attributes=(values)
    sanitize_for_mass_assignment(values).each do |k, v|
      send("#{k}=", v)
    end
  end
end

describe TestActsAsAccessible do
  it "should still allow mass assignment to accessible attributes by default" do
    subject.attributes = {:foo => ''fooo''}
    subject.foo.should == ''fooo''
  end
  it "should not allow mass assignment to non-accessible attributes by default" do
    subject.attributes = {:bar => ''baaar''}
    subject.bar.should be_nil
  end
  it "should allow mass assignment to acts_as_accessible attributes when passed appropriate accessed_by" do
    subject.accessed_by :dude
    subject.attributes = {:bar => ''baaar''}
    subject.bar.should == ''baaar''
  end
  it "should allow mass assignment to multiple acts_as_accessible attributes when passed appropriate accessed_by" do
    subject.accessed_by :bra
    subject.attributes = {:baz => ''baaaz'', :qux => ''quuux''}
    subject.baz.should == ''baaaz''
    subject.qux.should == ''quuux''
  end
  it "should allow multiple accessed_by to be specified" do
    subject.accessed_by :dude, :bra
    subject.attributes = {:bar => ''baaar'', :baz => ''baaaz'', :qux => ''quuux''}
    subject.bar.should == ''baaar''
    subject.baz.should == ''baaaz''
    subject.qux.should == ''quuux''
  end
  it "should allow :all access" do
    subject.accessed_by :admin
    subject.attributes = {:bar => ''baaar'', :baz => ''baaaz'', :qux => ''quuux''}
    subject.bar.should == ''baaar''
    subject.baz.should == ''baaaz''
    subject.qux.should == ''quuux''
  end
end