Rails de l'api et de l'application mobile native d'authentification

Essentiel d'une solution à partir de mes recherches. N'hésitez pas à modifier, de corriger, d'invalider, etc.

SessionsController < ApplicationController
  skip_before_filter :authenticate_user, :only => [:create]
  def create
    user = User.where("username = ? OR email = ?", params[:username_or_email], params[:username_or_email]).first
    if user && user.authenticate(params[:password])
      api_key = user.find_api_key
      if !api_key.secret_key || api_key.is_expired?
        api_key.set_expiry_date
        api_key.generate_secret_key
      end
      api_key.save
      render json: api_key, status: 201     
    else
      status: 401
    end
  end

Note le ApiAuth.authentique? la méthode et l'objet de la requête. La demande doit être signée avec un algorithme HMAC sur le client.

ApplicationController < ActionController::Base
  respond_to :json
  force_ssl
  protect_from_forgery with: :null_session 
  before_filter :authenticate_user
  private
  def authenticate_user
    if authenticate_user_from_secret_key
      return true
    else
      head :unauthorized 
    end
  end
  def authenticate_user_from_secret_key
    userid = ApiAuth.access_id(request)
    currentuser = userid && User.find_by_id(userid)
    if ApiAuth.authentic?(request, currentuser.find_api_key.secret_key)
      return true
    else
      return false
    end
    false
  end

La création d'un utilisateur/enregistrement

UsersController < ApplicationController
  skip_before_filter :authenticate_user, :only => [:create]
  def create
      user = User.create(user_params)
      if !user.new_record?
        render json: user.find_apit_key, status: 201

      else
       # error
      end
  end

Clé Api de modèle. Semblable à la clé api de modèle à #352 railscast seule différence est ApiAuth la génération de clés.

class ApiKey < ActiveRecord::Base
  before_create :generate_secret_key, :set_expiry_date
  belongs_to :user   
  def generate_secret_key
    begin
    self.secret_key = ApiAuth.generate_secret_key
    end while self.class.exists?(secret_key: secret_key)
  end

Modèle utilisateur.

class User < ActiveRecord::Base
  has_secure_password
  before_save :ensure_api_key 
  has_many :api_keys 
  def find_api_key
   self.api_keys.active.ios.first_or_create
  end

Sur le côté client, la HMAC algorithme doit être utilisé pour signer des demandes.

Le code est:
[HMAC SHA1 de génération de la Clé et authentification] https://github.com/mgomes/api_auth
[Contrôleurs & Modèles] https://github.com/danahartweg/authenticatable_rest_api

Vous êtes sur la bonne voie, mais le jeton de l'utilisateur doit uniquement être utilisés pour identifier l'utilisateur qui effectue la demande. Vous avez encore besoin d'un certain type d'authentification, puisque, comme vous spéculer avec l'évolution de l'jeton sur chaque demande, un pirate peut intercepter le flux de données, récupérer le jeton, puis "être" que de l'utilisateur dans les demandes ultérieures.

En changeant le jeton sur chaque demande, vous éliminez l'interception problème, mais une fois que quelqu'un a intercepté le jeton, ils peuvent ensuite exploiter davantage le système en continuant de les intercepter et même la modification de la réponse. Une solution à ce problème est l'utilisation de HMAC (qui est utilisé par Amazon Web Services). C'est un algorithme qui fournit une signature (hash) pour votre demande qui est unique pour chaque demande, ne nécessite pas un changement de clé, et ne peut pas être prévue pour les demandes futures.

Il y a un rubis gemme pour les rails qui implémente l'algorithme HMAC sur le côté serveur pour la signature HMAC demandes ainsi que de générer lors de serveur-à-serveur de communications. Pour les client-serveur de requêtes comme dans votre cas, vous avez besoin de générer la signature sur l'iOS ou Android de côté et de s'authentifier sur le serveur.

Envisager la ApiAuth joyau de faire le travail sur le côté serveur. Sur l'iOS côté client, examiner les HBHMAC bibliothèque de génération de la signature. Jetez un oeil à la ApiAuth spécifiques de mise en œuvre, car il ajoute un horodatage de données pour prévenir les attaques de relecture, de sorte que vous pouvez avoir besoin d'ajouter un champ à vos données avant de les passer à HBHMAC.

En résumé, à l'aide de l'authentification HMAC permettra d'éviter de l'homme dans le milieu attaques et les attaques replay en utilisant un algorithme de hachage qui empêche les attaquants de la génération authentique demandes, même si elles sont en mesure d'intercepter les requêtes valides.