xing_backend_token_auth 0.1.31

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DeviseTokenAuth'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/controllers/devise_token_auth/application_controller.rb

@@ -0,0 +1,22 @@
+module DeviseTokenAuth
+  class ApplicationController < DeviseController
+    include DeviseTokenAuth::Concerns::SetUserByToken
+    respond_to :json
+
+    def success_message(message = nil)
+      serializer = DeviseTokenAuth.success_message_serializer || SuccessMessageSerializer
+      serializer.new(message)
+    end
+
+    def error_messages(*args)
+      serializer = DeviseTokenAuth.error_messages_serializer || ErrorMessagesSerializer
+      serializer.new(*args)
+    end
+
+    def error_serializer(*args)
+      serializer = DeviseTokenAuth.error_serializer || ResourceErrorsSerializer
+      serializer.new(*args)
+    end
+
+  end
+end

data/app/controllers/devise_token_auth/concerns/set_user_by_token.rb

@@ -0,0 +1,110 @@
+module DeviseTokenAuth::Concerns::SetUserByToken
+  extend ActiveSupport::Concern
+  include DeviseTokenAuth::Controllers::Helpers
+
+  included do
+    before_action :set_request_start
+    after_action :update_auth_header
+  end
+
+  # keep track of request duration
+  def set_request_start
+    @request_started_at = Time.now
+  end
+
+  # user auth
+  def set_user_by_token(mapping=nil)
+
+    # determine target authentication class
+    self.mapping = mapping
+    rc = resource_class
+
+    # no default user defined
+    return unless rc
+
+    # user has already been found and authenticated
+    return @user if @user and @user.class == rc
+
+    # parse header for values necessary for authentication
+    uid        = request.headers['uid']
+    @token     = request.headers['access-token']
+    @client_id = request.headers['client']
+
+    return false unless @token
+
+    # client_id isn't required, set to 'default' if absent
+    @client_id ||= 'default'
+
+    # mitigate timing attacks by finding by uid instead of auth token
+    user = uid && rc.find_by_uid(uid)
+
+    if user && user.valid_token?(@token, @client_id)
+      sign_in(resource_name, user, store: false)
+      return @user = user
+    else
+      # zero all values previously set values
+      return @user = nil
+    end
+  end
+
+
+  def update_auth_header
+
+    # cannot save object if model has invalid params
+    return unless @user and @user.valid? and @client_id
+
+    # Lock the user record during any auth_header updates to ensure 
+    # we don't have write contention from multiple threads
+    @user.with_lock do
+      
+      # determine batch request status after request processing, in case 
+      # another processes has updated it during that processing
+      @is_batch_request = is_batch_request?(@user, @client_id)
+
+      auth_header = {}
+
+      if not DeviseTokenAuth.change_headers_on_each_request
+        auth_header = @user.build_auth_header(@token, @client_id)
+
+      # extend expiration of batch buffer to account for the duration of
+      # this request
+      elsif @is_batch_request
+        auth_header = @user.extend_batch_buffer(@token, @client_id)
+
+      # update Authorization response header with new token
+      else
+        auth_header = @user.create_new_auth_token(@client_id)
+      end
+
+      # update the response header
+      response.headers.merge!(auth_header)
+
+    end # end lock
+
+  end
+
+  def mapping
+    @mapping ||= request.env['devise.mapping'] || Devise.mappings.values.first
+  end
+
+  def mapping=(m)
+    @mapping = Devise.mappings[m]
+  end
+
+  def resource_class
+    mapping.to
+  end
+
+  def resource_name
+    mapping.name
+  end
+
+  private
+
+
+  def is_batch_request?(user, client_id)
+    user.tokens[client_id] and
+    user.tokens[client_id]['updated_at'] and
+    Time.parse(user.tokens[client_id]['updated_at']) > @request_started_at - DeviseTokenAuth.batch_request_buffer_throttle
+  end
+end

data/app/controllers/devise_token_auth/confirmations_controller.rb

@@ -0,0 +1,31 @@
+module DeviseTokenAuth
+  class ConfirmationsController < DeviseTokenAuth::ApplicationController
+    def show
+      @user = resource_class.confirm_by_token(params[:confirmation_token])
+
+      if @user and @user.id
+        # create client id
+        client_id  = SecureRandom.urlsafe_base64(nil, false)
+        token      = SecureRandom.urlsafe_base64(nil, false)
+        token_hash = BCrypt::Password.create(token)
+        expiry     = (Time.now + DeviseTokenAuth.token_lifespan).to_i
+
+        @user.tokens[client_id] = {
+          token:  token_hash,
+          expiry: expiry
+        }
+
+        @user.save!
+
+        redirect_to(@user.build_auth_url(params[:redirect_url], {
+          token:                        token,
+          client_id:                    client_id,
+          account_confirmation_success: true,
+          config:                       params[:config]
+        }))
+      else
+        raise ActionController::RoutingError.new('Not Found')
+      end
+    end
+  end
+end

data/app/controllers/devise_token_auth/omniauth_callbacks_controller.rb

@@ -0,0 +1,169 @@
+module DeviseTokenAuth
+  class OmniauthCallbacksController < DeviseTokenAuth::ApplicationController
+    skip_before_filter :set_user_by_token
+    skip_after_filter :update_auth_header
+
+    # intermediary route for successful omniauth authentication. omniauth does
+    # not support multiple models, so we must resort to this terrible hack.
+    def redirect_callbacks
+      # derive target redirect route from 'resource_class' param, which was set
+      # before authentication.
+      devise_mapping = request.env['omniauth.params']['resource_class'].underscore.to_sym
+      redirect_route = "#{Devise.mappings[devise_mapping].as_json["path_prefix"]}/#{params[:provider]}/callback"
+
+      # preserve omniauth info for success route
+      session['dta.omniauth.auth'] = request.env['omniauth.auth']
+      session['dta.omniauth.params'] = request.env['omniauth.params']
+
+      redirect_to redirect_route
+    end
+
+    def omniauth_success
+      # find or create user by provider and provider uid
+      @user = resource_class.where({
+        uid:      auth_hash['uid'],
+        provider: auth_hash['provider']
+      }).first_or_initialize
+
+      # create token info
+      @client_id = SecureRandom.urlsafe_base64(nil, false)
+      @token     = SecureRandom.urlsafe_base64(nil, false)
+      @expiry    = (Time.now + DeviseTokenAuth.token_lifespan).to_i
+
+      @auth_origin_url = generate_url(omniauth_params['auth_origin_url'], {
+        token:     @token,
+        client_id: @client_id,
+        uid:       @user.uid,
+        expiry:    @expiry
+      })
+
+      # set crazy password for new oauth users. this is only used to prevent
+      # access via email sign-in.
+      unless @user.id
+        p = SecureRandom.urlsafe_base64(nil, false)
+        @user.password = p
+        @user.password_confirmation = p
+      end
+
+      @user.tokens[@client_id] = {
+        token: BCrypt::Password.create(@token),
+        expiry: @expiry
+      }
+
+      # sync user info with provider, update/generate auth token
+      assign_provider_attrs(@user, auth_hash)
+
+      # assign any additional (whitelisted) attributes
+      extra_params = whitelisted_params
+      @user.assign_attributes(extra_params) if extra_params
+
+      # don't send confirmation email!!!
+      @user.skip_confirmation!
+
+      @user.save!
+
+      # render user info to javascript postMessage communication window
+      respond_to do |format|
+        format.html { render :layout => "omniauth_response", :template => "devise_token_auth/omniauth_success" }
+      end
+    end
+
+
+    # break out provider attribute assignment for easy method extension
+    def assign_provider_attrs(user, auth_hash)
+      user.assign_attributes({
+        nickname: auth_hash['info']['nickname'],
+        name:     auth_hash['info']['name'],
+        image:    auth_hash['info']['image'],
+        email:    auth_hash['info']['email']
+      })
+    end
+
+
+    def omniauth_failure
+      @error = params[:message]
+
+      respond_to do |format|
+        format.html { render :layout => "omniauth_response", :template => "devise_token_auth/omniauth_failure" }
+      end
+    end
+
+
+    # derive allowed params from the standard devise parameter sanitizer
+    def whitelisted_params
+      whitelist = devise_parameter_sanitizer.for(:sign_up)
+
+      whitelist.inject({}){|coll, key|
+        param = omniauth_params[key.to_s]
+        if param
+          coll[key] = param
+        end
+        coll
+      }
+    end
+
+    # pull resource class from omniauth return
+    def resource_class
+      if omniauth_params
+        omniauth_params['resource_class'].constantize
+      end
+    end
+
+    def resource_name
+      resource_class
+    end
+
+    # this will be determined differently depending on the action that calls
+    # it. redirect_callbacks is called upon returning from successful omniauth
+    # authentication, and the target params live in an omniauth-specific
+    # request.env variable. this variable is then persisted thru the redirect
+    # using our own dta.omniauth.params session var. the omniauth_success
+    # method will access that session var and then destroy it immediately
+    # after use.
+    def omniauth_params
+      if request.env['omniauth.params']
+        request.env['omniauth.params']
+      else
+        @_omniauth_params ||= session.delete('dta.omniauth.params')
+        @_omniauth_params
+      end
+    end
+
+    # this sesison value is set by the redirect_callbacks method. its purpose
+    # is to persist the omniauth auth hash value thru a redirect. the value
+    # must be destroyed immediatly after it is accessed by omniauth_success
+    def auth_hash
+      @_auth_hash ||= session.delete('dta.omniauth.auth')
+      @_auth_hash
+    end
+
+    # ensure that this controller responds to :devise_controller? conditionals.
+    # this is used primarily for access to the parameter sanitizers.
+    def assert_is_devise_resource!
+      true
+    end
+
+    # necessary for access to devise_parameter_sanitizers
+    def devise_mapping
+      if omniauth_params
+        Devise.mappings[omniauth_params['resource_class'].underscore.to_sym]
+      else
+        request.env['devise.mapping']
+      end
+    end
+
+    def generate_url(url, params = {})
+      auth_url = url
+
+      # ensure that hash-bang is present BEFORE querystring for angularjs
+      unless url.match(/#/)
+        auth_url += '#'
+      end
+
+      # add query AFTER hash-bang
+      auth_url += "?#{params.to_query}"
+
+      return auth_url
+    end
+  end
+end

data/app/controllers/devise_token_auth/passwords_controller.rb

@@ -0,0 +1,107 @@
+module DeviseTokenAuth
+  class PasswordsController < DeviseTokenAuth::ApplicationController
+    before_filter :set_user_by_token, :only => [:update]
+    skip_after_filter :update_auth_header, :only => [:create, :edit]
+
+    # this action is responsible for generating password reset tokens and
+    # sending emails
+    def create
+      unless resource_params[:email].present?
+        return render json: error_messages('You must provide an email address.'), status: 401
+      end
+
+      unless params[:redirect_url]
+        return render json: error_messages('Missing redirect url.'), status: 401
+      end
+
+      @user = resource_class.where({
+        email: resource_params[:email]
+      }).first
+
+      errors = nil
+
+      if @user
+        @user.send_reset_password_instructions({
+          email: resource_params[:email],
+          redirect_url: params[:redirect_url],
+          client_config: params[:config_name]
+        })
+
+        if @user.errors.empty?
+          render json: success_message(
+            "An email has been sent to #{@user.email} containing instructions for resetting your password."
+          )
+        else
+          errors = @user.errors
+        end
+      else
+        errors = ["Unable to find user with email '#{resource_params[:email]}'."]
+      end
+
+      if errors
+        render json: error_messages(*errors), status: 400
+      end
+    end
+
+
+    # this is where users arrive after visiting the email confirmation link
+    def edit
+      @user = resource_class.reset_password_by_token({
+        reset_password_token: params[:reset_password_token]
+      })
+
+      if @user and @user.id
+        client_id  = SecureRandom.urlsafe_base64(nil, false)
+        token      = SecureRandom.urlsafe_base64(nil, false)
+        token_hash = BCrypt::Password.create(token)
+        expiry     = (Time.now + DeviseTokenAuth.token_lifespan).to_i
+
+        @user.tokens[client_id] = {
+          token:  token_hash,
+          expiry: expiry
+        }
+
+        # ensure that user is confirmed
+        @user.skip_confirmation! unless @user.confirmed_at
+
+        @user.save!
+
+        redirect_to(@user.build_auth_url(params[:redirect_url], {
+          token:          token,
+          client_id:      client_id,
+          reset_password: true,
+          config:         params[:config]
+        }))
+      else
+        raise ActionController::RoutingError.new('Not Found')
+      end
+    end
+
+    def update
+      # make sure user is authorized
+      unless @user
+        return render json: error_messages('Unauthorized'), status: 401
+      end
+
+      # ensure that password params were sent
+      unless password_resource_params[:password] and password_resource_params[:password_confirmation]
+        return render json: error_messages('You must fill out the fields labeled "password" and "password confirmation".'), status: 422
+      end
+
+      if @user.update_attributes(password_resource_params)
+        return render json: resource_serializer(@user)
+      else
+        return render json: error_serializer(@user), status: 422
+      end
+    end
+
+    def password_resource_params
+      devise_parameter_sanitizer.sanitize(:account_update)
+    end
+
+    def resource_serializer(user)
+      serializer = DeviseTokenAuth.password_serializer || ResourceSerializer
+      serializer.new(user)
+    end
+  end
+end