ruby on rails - Autenticación de usuario con uva y diseño

ruby-on-rails api

Question

Tengo dificultades para comprender y también implementar correctamente la Autenticación de usuario en las API. En otras palabras, tengo un serio problema para entender la integración de la API de Grape con frameworks frontales como Backbone.js, AngularJS o Ember.js.

Estoy tratando de hacer pivotar todos los enfoques diferentes y leer mucho sobre eso, pero Google me devuelve recursos realmente malos y me parece que no hay un artículo realmente bueno sobre este tema: Rails y autenticación de usuario con Devise y front-end marcos .

Describiré mi pivote actual y espero que puedan brindarme algunos comentarios sobre mi implementación y tal vez apuntarme en la dirección correcta.

Implementación actual

Tengo la API REST de Rails de respaldo con el siguiente Gemfile (voy a acortar deliberadamente todo el código de archivo)

gem ''rails'', ''4.1.6''
gem ''mongoid'', ''~> 4.0.0''
gem ''devise''
gem ''grape''
gem ''rack-cors'', :require => ''rack/cors''

Mi implementación actual solo tiene API con las siguientes rutas ( routes.rb ):

api_base      /api        API::Base
     GET        /:version/posts(.:format)
     GET        /:version/posts/:id(.:format)
     POST       /:version/posts(.:format)
     DELETE     /:version/posts/:id(.:format)
     POST       /:version/users/authenticate(.:format)
     POST       /:version/users/register(.:format)
     DELETE     /:version/users/logout(.:format)

Creé tener el siguiente modelo user.rb

class User
  include Mongoid::Document
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :trackable, :validatable

  field :email,              type: String, default: ""
  field :encrypted_password, type: String, default: ""

  field :authentication_token,  type: String

  before_save :ensure_authentication_token!

  def ensure_authentication_token!
    self.authentication_token ||= generate_authentication_token
  end

  private

  def generate_authentication_token
    loop do
      token = Devise.friendly_token
      break token unless User.where(authentication_token: token).first
    end
  end   
end

En mis controladores creé la siguiente estructura de carpetas: controladores-> api-> v1 y he creado la siguiente autenticación de módulo compartido ( authentication.rb )

module API
  module V1
    module Authentication
      extend ActiveSupport::Concern

      included do
        before do
           error!("401 Unauthorized", 401) unless authenticated?
         end

         helpers do
           def warden
             env[''warden'']
           end

           def authenticated?
             return true if warden.authenticated?
             params[:access_token] && @user = User.find_by(authentication_token: params[:access_token])
           end

           def current_user
             warden.user || @user
           end
         end
       end
     end
   end
end

Así que cada vez que quiero asegurarme de que se invocará mi recurso con el token de autenticación, simplemente puedo agregarlo llamando al: include API::V1::Authentication al recurso de uva:

module API
  module V1
    class Posts < Grape::API
      include API::V1::Defaults
      include API::V1::Authentication

Ahora tengo otro recurso de Grape llamado Users (users.rb) y aquí implemento métodos para autenticación, registro y cierre de sesión. (Creo que mezclo aquí manzanas con peras, y debería extraer el proceso de inicio de sesión / cierre de sesión en otro recurso de Grape - Sesión).

module API
  module V1
    class Users < Grape::API
      include API::V1::Defaults

      resources :users do
        desc "Authenticate user and return user object, access token"
        params do
           requires :email, :type => String, :desc => "User email"
           requires :password, :type => String, :desc => "User password"
         end
         post ''authenticate'' do
           email = params[:email]
           password = params[:password]

           if email.nil? or password.nil?
             error!({:error_code => 404, :error_message => "Invalid email or password."}, 401)
             return
           end

           user = User.find_by(email: email.downcase)
           if user.nil?
              error!({:error_code => 404, :error_message => "Invalid email or password."}, 401)
              return
           end

           if !user.valid_password?(password)
              error!({:error_code => 404, :error_message => "Invalid email or password."}, 401)
              return
           else
             user.ensure_authentication_token!
             user.save
             status(201){status: ''ok'', token: user.authentication_token }
           end
         end

         desc "Register user and return user object, access token"
         params do
            requires :first_name, :type => String, :desc => "First Name"
            requires :last_name, :type => String, :desc => "Last Name"
            requires :email, :type => String, :desc => "Email"
            requires :password, :type => String, :desc => "Password"
          end
          post ''register'' do
            user = User.new(
              first_name: params[:first_name],
              last_name:  params[:last_name],
              password:   params[:password],
              email:      params[:email]
            )

            if user.valid?
              user.save
              return user
            else
              error!({:error_code => 404, :error_message => "Invalid email or password."}, 401)
            end
          end

          desc "Logout user and return user object, access token"
           params do
              requires :token, :type => String, :desc => "Authenticaiton Token"
            end
            delete ''logout'' do

              user = User.find_by(authentication_token: params[:token])

              if !user.nil?
                user.remove_authentication_token!
                status(200)
                {
                  status: ''ok'',
                  token: user.authentication_token
                }
              else
                error!({:error_code => 404, :error_message => "Invalid token."}, 401)
              end
            end
      end
    end
  end
end

Me doy cuenta de que presento aquí un montón de código y puede que no tenga sentido, pero esto es lo que tengo actualmente y puedo usar el authentication_token para las llamadas en mi API que están protegidas por la Authentication módulo.

Siento que esta solución no es buena, pero realmente busco la forma más fácil de lograr la autenticación de usuario a través de API. Tengo varias preguntas que enumero a continuación.

Preguntas

1. ¿Crees que este tipo de implementación es peligrosa, de ser así, por qué? - Creo que lo es, debido al uso de un token. ¿Hay alguna manera de mejorar este patrón? También he visto la implementación con Token modelo separado que tiene tiempo de vencimiento, etc. Pero creo que esto es casi como reinventar la rueda, porque para este propósito puedo implementar OAuth2. Me gustaría tener una solución más ligera.
2. Es una buena práctica crear un nuevo módulo para Autenticación e incluirlo solo en los recursos donde sea necesario.
3. ¿Conoces algún buen tutorial sobre este tema: implementar Rails + Devise + Grape? Además, ¿conoces algún buen proyecto de código abierto de Rails, que se implementa de esta manera?
4. ¿Cómo puedo implementarlo con un enfoque diferente que sea más seguro?

Me disculpo por una publicación tan larga, pero espero que más personas tengan el mismo problema y pueda ayudarme a encontrar más respuestas a mis preguntas.

Answer 1

Agregue token_authenticable para diseñar módulos (funciona con versiones de diseño <= 3.2)

En user.rb agregue: token_authenticatable a la lista de módulos de diseño, debería verse algo como a continuación:

class User < ActiveRecord::Base
# ..code..
  devise :database_authenticatable,
    :token_authenticatable,
    :invitable,
    :registerable,
    :recoverable,
    :rememberable,
    :trackable,
    :validatable

  attr_accessible :name, :email, :authentication_token

  before_save :ensure_authentication_token
# ..code..
end

Generar un token de autenticación por su cuenta (si es una versión> 3.2)

class User < ActiveRecord::Base
# ..code..
  devise :database_authenticatable,
    :invitable,
    :registerable,
    :recoverable,
    :rememberable,
    :trackable,
    :validatable

  attr_accessible :name, :email, :authentication_token

  before_save :ensure_authentication_token

  def ensure_authentication_token
    self.authentication_token ||= generate_authentication_token
  end

  private

  def generate_authentication_token
    loop do
      token = Devise.friendly_token
      break token unless User.where(authentication_token: token).first
    end
  end

Agregar migración para token de autentificación

rails g migration add_auth_token_to_users
      invoke  active_record
      create    db/migrate/20141101204628_add_auth_token_to_users.rb

Edite el archivo de migración para agregar: columna authentication_token a los usuarios

class AddAuthTokenToUsers < ActiveRecord::Migration
  def self.up
    change_table :users do |t|
      t.string :authentication_token
    end

    add_index  :users, :authentication_token, :unique => true
  end

  def self.down
    remove_column :users, :authentication_token
  end
end

Ejecutar migraciones

rake db:migrate

Generar token para usuarios existentes

Necesitamos llamar a guardar en cada instancia de usuario que garantizará que el token de autenticación esté presente para cada usuario.

User.all.each(&:save)

API segura de uva utilizando token de autenticación

Debe agregar el código siguiente a API :: Root para agregar la autenticación basada en token. Si no está al tanto de API :: Root, por favor lea Building RESTful API using Grape

En el ejemplo siguiente, estamos autenticando al usuario según dos escenarios: si el usuario ha iniciado sesión en la aplicación web, utilice la misma sesión: si la sesión no está disponible y se pasa el token de autorización, busque el usuario en función del token

# lib/api/root.rb
module API
  class Root < Grape::API
    prefix    ''api''
    format    :json

    rescue_from :all, :backtrace => true
    error_formatter :json, API::ErrorFormatter

    before do
      error!("401 Unauthorized", 401) unless authenticated
    end

    helpers do
      def warden
        env[''warden'']
      end

      def authenticated
        return true if warden.authenticated?
        params[:access_token] && @user = User.find_by_authentication_token(params[:access_token])
      end

      def current_user
        warden.user || @user
      end
    end

    mount API::V1::Root
    mount API::V2::Root
  end
end

Answer 2

Aunque me gusta la pregunta y la respuesta de @MZaragoza, creo que vale la pena señalar que token_authentical ha sido eliminado de Devise por algún motivo. El uso de los tokens es vulnerable a los ataques de tiempo. Ver también esta publicación y el blog de Devise. Por lo tanto, no he votado a favor la respuesta de @MZaragoza.

En caso de que use su API en combinación con Doorkeeper, podría hacer algo similar, pero en lugar de buscar el authentication_token en la tabla / modelo de usuario, busca el token en la tabla OauthAccessTokens, es decir,

def authenticated
   return true if warden.authenticated?
   params[:access_token] && @user = OauthAccessToken.find_by_token(params[:access_token]).user
end

Esto es más seguro, porque ese token (es decir, el access_token real) existe solo por una cierta cantidad de tiempo.

Para poder hacer esto, debe tener un modelo de Usuario y un modelo de OauthAccessToken, con:

class User < ActiveRecord::Base

   has_many :oauth_access_tokens

end

class OauthAccessToken < ActiveRecord::Base
    belongs_to :user, foreign_key: ''resource_owner_id''
end

EDITAR: Tenga en cuenta que generalmente no debe incluir access_token en la URL: http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-16#section-2.3