lib/authoreyes/authorization/engine.rb
module Authoreyes
module Authorization
# Authorization::Engine implements the reference monitor. It may be used
# for querying the permission and retrieving obligations under which
# a certain privilege is granted for the current user.
class Engine
extend Forwardable
attr_reader :reader
def_delegators :@reader, :auth_rules_reader, :privileges_reader, :load, :load!
def_delegators :auth_rules_reader, :auth_rules, :roles, :omnipotent_roles, :role_hierarchy, :role_titles, :role_descriptions
def_delegators :privileges_reader, :privileges, :privilege_hierarchy
# If +reader+ is not given, a new one is created with the default
# authorization configuration of +AUTH_DSL_FILES+. If given, may be either
# a Reader object or a path to a configuration file.
def initialize(options)
options = {
reader: nil
}.merge(options)
# @auth_rules = AuthorizationRuleSet.new reader.auth_rules_reader.auth_rules
@reader = ::Authoreyes::Parser::DSLParser.factory(options[:reader] || AUTH_DSL_FILES)
end
def initialize_copy(from) # :nodoc:
@reader = from.reader.clone
end
# {[priv, ctx] => [priv, ...]}
def rev_priv_hierarchy
if @rev_priv_hierarchy.nil?
@rev_priv_hierarchy = {}
privilege_hierarchy.each do |key, value|
value.each do |val|
@rev_priv_hierarchy[val] ||= []
@rev_priv_hierarchy[val] << key
end
end
end
@rev_priv_hierarchy
end
# {[priv, ctx] => [priv, ...]}
def rev_role_hierarchy
if @rev_role_hierarchy.nil?
@rev_role_hierarchy = {}
role_hierarchy.each do |higher_role, lower_roles|
lower_roles.each do |role|
(@rev_role_hierarchy[role] ||= []) << higher_role
end
end
end
@rev_role_hierarchy
end
# Returns true if privilege is met by the current user. Raises
# AuthorizationError otherwise. +privilege+ may be given with or
# without context. In the latter case, the :+context+ option is
# required.
#
# Options:
# [:+context+]
# The context part of the privilege.
# Defaults either to the tableized +class_name+ of the given :+object+, if given.
# That is, :+users+ for :+object+ of type User.
# Raises AuthorizationUsageError if context is missing and not to be inferred.
# [:+object+] An context object to test attribute checks against.
# [:+skip_attribute_test+]
# Skips those attribute checks in the
# authorization rules. Defaults to false.
# [:+user+]
# The user to check the authorization for.
# Defaults to Authorization#current_user.
# [:+bang+]
# Should NotAuthorized exceptions be raised
# Defaults to true.
#
def permit!(privilege, options = {})
return true if Authorization.ignore_access_control
options = {
object: nil,
skip_attribute_test: false,
context: nil,
bang: true
}.merge(options)
# Make sure we're handling all privileges as symbols.
privilege = privilege.is_a?(Array) ?
privilege.flatten.collect(&:to_sym) :
privilege.to_sym
# Convert context to symbol as well
unless options[:context].nil?
options[:context] = options[:context].to_sym
end
#
# If the object responds to :proxy_reflection, we're probably working with
# an association proxy. Use 'new' to leverage ActiveRecord's builder
# functionality to obtain an object against which we can check permissions.
#
# Example: permit!( :edit, :object => user.posts )
#
if Authorization.is_a_association_proxy?(options[:object]) && options[:object].respond_to?(:new)
options[:object] = (Rails.version < '3.0' ? options[:object] : options[:object].where(nil)).new
end
begin
options[:context] ||= options[:object] && (
options[:object].class.respond_to?(:decl_auth_context) ?
options[:object].class.decl_auth_context :
options[:object].class.name.tableize.to_sym
)
rescue
NoMethodError
end
user, roles, privileges = user_roles_privleges_from_options(privilege, options)
return true if roles.is_a?(Array) && !(roles & omnipotent_roles).empty?
# find a authorization rule that matches for at least one of the roles and
# at least one of the given privileges
attr_validator = AttributeValidator.new(self, user, options[:object], privilege, options[:context])
rules = matching_auth_rules(roles, privileges, options[:context])
# Test each rule in turn to see whether any one of them is satisfied.
rules.each do |rule|
return true if rule.validate?(attr_validator, options[:skip_attribute_test])
end
if options[:bang]
if rules.empty?
raise NotAuthorized, "No matching rules found for #{privilege} for #{user.inspect} " \
"(roles #{roles.inspect}, privileges #{privileges.inspect}, " \
"context #{options[:context].inspect})."
else
raise AttributeAuthorizationError, "#{privilege} not allowed for #{user.inspect} on #{(options[:object] || options[:context]).inspect}."
end
else
false
end
end
# Calls permit! but doesn't raise authorization errors. If no exception is
# raised, permit? returns true and yields to the optional block.
def permit?(privilege, options = {}) # :yields:
if permit!(privilege, options.merge(bang: false))
yield if block_given?
true
else
false
end
end
# Returns the obligations to be met by the current user for the given
# privilege as an array of obligation hashes in form of
# [{:object_attribute => obligation_value, ...}, ...]
# where +obligation_value+ is either (recursively) another obligation hash
# or a value spec, such as
# [operator, literal_value]
# The obligation hashes in the array should be OR'ed, conditions inside
# the hashes AND'ed.
#
# Example
# {:branch => {:company => [:is, 24]}, :active => [:is, true]}
#
# Options
# [:+context+] See permit!
# [:+user+] See permit!
#
def obligations(privilege, options = {})
options = { context: nil }.merge(options)
user, roles, privileges = user_roles_privleges_from_options(privilege, options)
permit!(privilege, skip_attribute_test: true, user: user, context: options[:context])
return [] if roles.is_a?(Array) && !(roles & omnipotent_roles).empty?
attr_validator = AttributeValidator.new(self, user, nil, privilege, options[:context])
matching_auth_rules(roles, privileges, options[:context]).collect do |rule|
rule.obligations(attr_validator)
end.flatten
end
# Returns the description for the given role. The description may be
# specified with the authorization rules. Returns +nil+ if none was
# given.
def description_for(role)
role_descriptions[role]
end
# Returns the title for the given role. The title may be
# specified with the authorization rules. Returns +nil+ if none was
# given.
def title_for(role)
role_titles[role]
end
# Returns the role symbols of the given user.
def roles_for(user)
user ||= Authorization.current_user
raise AuthorizationUsageError, "User object doesn't respond to roles (#{user.inspect})" \
if !user.respond_to?(:role_symbols) && !user.respond_to?(:roles)
Rails.logger.info('The use of user.roles is deprecated. Please add a method ' \
'role_symbols to your User model.') if defined?(Rails) && Rails.respond_to?(:logger) && !user.respond_to?(:role_symbols)
roles = user.respond_to?(:role_symbols) ? user.role_symbols : user.roles
raise AuthorizationUsageError, "User.#{user.respond_to?(:role_symbols) ? 'role_symbols' : 'roles'} " \
"doesn't return an Array of Symbols (#{roles.inspect})" \
if !roles.is_a?(Array) || (!roles.empty? && !roles[0].is_a?(Symbol))
(roles.empty? ? [Authorization.default_role] : roles)
end
# Returns the role symbols and inherritted role symbols for the given user
def roles_with_hierarchy_for(user)
flatten_roles(roles_for(user))
end
def self.development_reload?
if Rails.env.development?
mod_time = AUTH_DSL_FILES.map do |m|
begin
File.mtime(m)
rescue
Time.at(0)
end
end.flatten.max
@@auth_dsl_last_modified ||= mod_time
if mod_time > @@auth_dsl_last_modified
@@auth_dsl_last_modified = mod_time
return true
end
end
end
# Returns an instance of Engine, which is created if there isn't one
# yet. If +dsl_file+ is given, it is passed on to Engine.new and
# a new instance is always created.
def self.instance(dsl_file = nil)
if dsl_file || development_reload?
@@instance = new(dsl_file)
else
@@instance ||= new
end
end
class AttributeValidator # :nodoc:
attr_reader :user, :object, :engine, :context, :privilege
def initialize(engine, user, object = nil, privilege = nil, context = nil)
@engine = engine
@user = user
@object = object
@privilege = privilege
@context = context
end
def evaluate(value_block)
# TODO: cache?
instance_eval(&value_block)
end
end
private
def user_roles_privleges_from_options(privilege, options)
options = {
user: nil,
context: nil,
user_roles: nil
}.merge(options)
user = options[:user] || Authorization.current_user
privileges = privilege.is_a?(Array) ? privilege : [privilege]
raise AuthorizationUsageError, "No user object given (#{user.inspect}) or " \
'set through Authorization.current_user' unless user
roles = options[:user_roles] || flatten_roles(roles_for(user))
privileges = flatten_privileges privileges, options[:context]
[user, roles, privileges]
end
def flatten_roles(roles, flattened_roles = Set.new)
# TODO: caching?
roles.reject { |role| flattened_roles.include?(role) }.each do |role|
flattened_roles << role
flatten_roles(role_hierarchy[role], flattened_roles) if role_hierarchy[role]
end
flattened_roles.to_a
end
# Returns the privilege hierarchy flattened for given privileges in context.
def flatten_privileges(privileges, context = nil, flattened_privileges = Set.new)
# TODO: caching?
raise AuthorizationUsageError, 'No context given or inferable from object' unless context
privileges.reject { |priv| flattened_privileges.include?(priv) }.each do |priv|
flattened_privileges << priv
flatten_privileges(rev_priv_hierarchy[[priv, nil]], context, flattened_privileges) if rev_priv_hierarchy[[priv, nil]]
flatten_privileges(rev_priv_hierarchy[[priv, context]], context, flattened_privileges) if rev_priv_hierarchy[[priv, context]]
end
flattened_privileges.to_a
end
def matching_auth_rules(roles, privileges, context)
auth_rules.matching(roles, privileges, context)
end
end
end
end