door_mat 0.0.5

data/lib/door_mat/process/actor_sign_in.rb

@@ -0,0 +1,38 @@
+module DoorMat
+  module Process
+    class ActorSignIn
+
+      def self.with(email, password, is_public, remember_me, request, cookies)
+        # Destroy any session linked to existing cookies before
+        # replacing it by a new session
+        DoorMat::Session.destroy_if_linked_to(cookies)
+
+        actor = DoorMat::Actor.authenticate_with(email, password)
+        return false if actor.blank?
+
+        DoorMat::Session.for(actor, password, request)
+        return false unless DoorMat::Session.current_session.valid?
+
+        if is_public
+          DoorMat::Session.current_session.public_computer!
+        else
+          DoorMat::Session.current_session.private_computer!
+        end
+
+        # User requested to be remembered
+        if DoorMat.configuration.allow_remember_me_feature && remember_me
+          DoorMat::Session.current_session.remember_me! unless (
+            DoorMat.configuration.remember_me_require_private_computer_confirmation &&
+              DoorMat::Session.current_session.public_computer?
+          )
+        end
+
+        actor.sessions << DoorMat::Session.current_session
+        DoorMat::Session.current_session.set_up(cookies)
+        true
+      end
+
+    end
+  end
+end
+

data/lib/door_mat/process/actor_sign_up.rb

@@ -0,0 +1,39 @@
+module DoorMat
+  module Process
+    class ActorSignUp
+
+      def self.with(address, password, request, cookies, controller)
+        # Destroy any session linked to existing cookies before
+        # replacing it by a new session
+        DoorMat::Session.destroy_if_linked_to(cookies)
+
+        # Sign up with the credentials of
+        # an existing account fails
+        return false if DoorMat::Actor.authenticate_with(address, password)
+
+        actor = DoorMat::Actor.create_with(password)
+        return false if actor.blank?
+
+        email = DoorMat::Email.for(address)
+        email.status = :not_available if DoorMat::Email.count_matching(address) >= DoorMat::configuration.plausible_deniability_count
+        actor.current_email = email
+        DoorMat::Session.for(actor, password, request)
+        return false unless DoorMat::Session.current_session.valid?
+
+        actor.sessions << DoorMat::Session.current_session
+        actor.emails << email
+
+        # setup public key pairs
+        actor.setup_public_key_pairs(DoorMat::Session.current_session)
+
+        return false unless actor.save
+
+        DoorMat::Session.current_session.set_up(cookies)
+        DoorMat::ActivityConfirmEmail.for(email, controller)
+        DoorMat::ActivityDownloadRecoveryKey.for(actor)
+        true
+      end
+
+    end
+  end
+end

data/lib/door_mat/process/create_new_anonymous_actor.rb

@@ -0,0 +1,36 @@
+module DoorMat
+  module Process
+    class CreateNewAnonymousActor
+
+      def self.owned_by(owner)
+        password = DoorMat::Crypto::SymmetricStore.random_key
+        anonymous_actor = Actor.create_with(password)
+        return nil if anonymous_actor.blank?
+
+        sub_session = DoorMat::Session.new_sub_session_for_actor(anonymous_actor, password)
+        anonymous_actor.setup_public_key_pairs(sub_session)
+
+        owner.with_lock do
+          anonymous_actor.save!
+
+          if DoorMat::Session.current_session.append_sub_session(sub_session)
+            membership = DoorMat::Membership.new
+            membership.member = owner
+            membership.member_of = anonymous_actor
+            membership.sponsor = DoorMat::Membership.sponsors[:sponsor_true]
+            membership.owner = DoorMat::Membership.owners[:owner_true]
+            membership.permission = DoorMat::Membership.permissions[:no_permission]
+            membership.key = password
+            membership.save!
+          end
+        end
+
+        anonymous_actor
+      rescue Exception => e
+        DoorMat.configuration.logger.error "ERROR: CreateNewAnonymousActor failed to with error - #{e}"
+        nil
+      end
+
+    end
+  end
+end

data/lib/door_mat/process/manage_email.rb

@@ -0,0 +1,42 @@
+module DoorMat
+  module Process
+    class ManageEmail
+
+      def self.add(email, actor, controller)
+        return false unless email.valid?
+
+        actor.with_lock do
+          return false unless actor.can_add_email? email
+
+          email.status = :not_available if DoorMat::Email.count_matching(email.address) > DoorMat::configuration.plausible_deniability_count
+
+          actor.emails << email
+
+          DoorMat::ActivityConfirmEmail.for(email, controller)
+        end
+
+        true
+      end
+
+      def self.set_primary(encoded_address, actor)
+        actor.with_lock do
+          email = actor.email_from_urlsafe_encoded(encoded_address)
+          return false if email.blank?
+
+          return true if email.primary?
+
+          return false unless email.confirmed?
+
+          actor.emails.primary.each do |e|
+            e.confirmed!
+          end
+
+          email.primary!
+        end
+
+        true
+      end
+
+    end
+  end
+end

data/lib/door_mat/process/reset_password.rb

@@ -0,0 +1,50 @@
+module DoorMat
+  module Process
+    class ResetPassword
+
+      def self.for(address, controller)
+        emails = DoorMat::Email.confirmed_matching(address)
+        return false if emails.blank?
+
+        # Several DoorMat::Email could match the address
+        # pick the first one for now.
+        # They will all be tested at reset time to apply the reset to the proper one
+        email = emails.first
+
+        # Because email was loaded without a valid session
+        # the address attribute is still encrypted.
+        # Temporarily update it here with the plain text.
+        # The reason it is trusted is because the hash
+        # of the user input matched a previously confirmed email address
+        # hash already in the system.
+        email.address = address
+
+        DoorMat::ActivityResetPassword.for(email, controller)
+        true
+      end
+
+      def self.with(forgot_password)
+        emails = DoorMat::Email.confirmed_matching(forgot_password.email)
+        return false if emails.blank?
+
+        activity = DoorMat::ActivityResetPassword.with(forgot_password.token, emails)
+        return false if activity.blank?
+
+        return false if forgot_password.recovery_key.blank?
+        recovery_key = forgot_password.recovery_key.read
+
+        emails.each do |email|
+          if DoorMat::Process::ActorPasswordChange.after_password_reset(email.actor, forgot_password.password, recovery_key)
+            DoorMat::ActivityDownloadRecoveryKey.for(email.actor)
+            activity.done!
+            return true
+          end
+        end
+
+        activity.failed!
+        return false
+      end
+
+    end
+  end
+end

data/lib/door_mat/regex.rb

@@ -0,0 +1,17 @@
+module DoorMat
+  module Regex
+
+    def self.simple_email
+      # http://tools.ietf.org/html/rfc3696#section-3
+      # min 1 char local part and min 2 char domain part
+      # max 64 char local part and max 255 char domain part
+      # first and last char can not be blank
+      /\A\S.{0,63}@.{1,254}\S\z/
+    end
+
+    def self.session_guid
+      /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
+    end
+
+  end
+end

data/lib/door_mat/test_helper.rb

@@ -0,0 +1,58 @@
+module DoorMat
+  module TestHelper
+
+    def self.create_signed_up_actor_with_confirmed_email_address(address="me@example.com", password="n7f3d;3#)")
+      actor, _ = create_signed_in_actor_with_confirmed_email_address(address, password)
+      DoorMat::Session.clear_current_session
+      actor
+    end
+
+    def self.create_signed_in_actor_with_confirmed_email_address(address="me@example.com", password="n7f3d;3#)")
+      DoorMat::Session.clear_current_session
+      actor = DoorMat::Actor.create_with(password)
+
+      email = DoorMat::Email.for(address)
+      email.status = :primary
+
+      session = DoorMat::Session.new
+      session.ip = "request.remote_ip"
+      session.agent = "request.user_agent"
+      actor.current_email = email
+
+      RequestStore.store[:current_session] = session.initialize_with(actor, password)
+
+      actor.sessions << DoorMat::Session.current_session
+      actor.emails << email
+
+      # setup public key pairs
+      actor.setup_public_key_pairs(DoorMat::Session.current_session)
+
+      actor.save!
+
+      DoorMat::ActivityDownloadRecoveryKey.for(actor)
+      [actor, RequestStore.store[:current_session]]
+    end
+
+    def self.sign_in_existing_actor(address="me@example.com", password="n7f3d;3#)")
+      DoorMat::Session.clear_current_session
+      actor = DoorMat::Actor.authenticate_with(address, password)
+
+      session = DoorMat::Session.new
+      session.ip = "request.remote_ip"
+      session.agent = "request.user_agent"
+
+      RequestStore.store[:current_session] = session.initialize_with(actor, password)
+
+      actor.sessions << DoorMat::Session.current_session
+      actor.save!
+
+      [actor, RequestStore.store[:current_session]]
+    end
+
+    def self.sign_out(session)
+      session.destroy! if session.persisted?
+      RequestStore.store[:current_session] = nil
+    end
+
+  end
+end

data/lib/door_mat/url_protocol.rb

@@ -0,0 +1,9 @@
+module DoorMat
+  module UrlProtocol
+
+    def self.url_protocol
+      Rails.application.config.force_ssl ? 'https' : 'http'
+    end
+
+  end
+end

data/lib/door_mat/version.rb

@@ -0,0 +1,3 @@
+module DoorMat
+  VERSION = "0.0.5"
+end

data/lib/tasks/door_mat_tasks.rake

@@ -0,0 +1,31 @@
+require 'door_mat'
+require 'door_mat/test_helper'
+
+namespace :door_mat do
+
+  desc "Create an admin actor in the system, useful if you need to share data between a user and the system - specify admin_account_email and admin_account_pwd in your rails secret file using environment variables."
+  task :create_admin_actor => :environment do
+
+    if DoorMat::Email.matching(Rails.application.secrets.admin_account_email).count == 0
+      DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(
+          Rails.application.secrets.admin_account_email,
+          Rails.application.secrets.admin_account_pwd
+      )
+      puts "SUCCESS: #{Rails.application.secrets.admin_account_email} is now defined in the database"
+    else
+      puts "ERROR: #{Rails.application.secrets.admin_account_email} is already defined in the database"
+    end
+
+  end
+
+  desc "Environment cleanup before building gem"
+  task :cleanup => :environment do
+    list = Dir['spec/test_app/db/*sqlite3', 'spec/test_app/db/schema.rb', 'spec/test_app/tmp', 'spec/test_app/log/*log']
+    list.each do |file|
+      FileUtils.remove_entry_secure(file)
+      puts file
+    end
+    puts "Ready to run: rake build"
+  end
+
+end

data/spec/controllers/door_mat/activities_controller_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module DoorMat
+  describe ActivitiesController do
+    routes { DoorMat::Engine.routes }
+    let(:user) { {email: 'user@example.com', password: 'k#dkvKfdj38g!'} }
+
+    describe '#resend_email_confirmation' do
+      it 'redirects to :back if the email is invalid' do
+        _, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        post :resend_email_confirmation, {email: 'invalid_email'}
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+      it 'redirects to :confirm_email_success if the email is already confirmed' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        post :resend_email_confirmation, {email: actor.current_email.to_urlsafe_encoded}
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/confirm_email_success')
+      end
+
+      it 'redirects to :back if the address is not confirmed' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        email = DoorMat::Email.for('new_address@example.com')
+        actor.emails << email
+
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        post :resend_email_confirmation, {email: email.to_urlsafe_encoded}
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+
+      it 'redirects to main app root url if the address is not confirmed and HTTP_REFERER is not set' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        email = DoorMat::Email.for('new_address@example.com')
+        actor.emails << email
+
+        post :resend_email_confirmation, {email: email.to_urlsafe_encoded}
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/')
+      end
+
+    end
+
+    describe '#confirm_email' do
+      it 'redirects to :back after an invalid email confirmation request' do
+        _, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        get :confirm_email, {token: 'invalid_token', email: 'invalid_email'}
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+    end
+
+    describe '#download_recovery_key' do
+      it 'redirects to :back after an invalid download request' do
+        _, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        post :download_recovery_key
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+    end
+
+  end
+end

data/spec/controllers/door_mat/forgot_passwords_controller_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module DoorMat
+  describe ForgotPasswordsController do
+    routes { DoorMat::Engine.routes }
+    let(:user) { {email: 'user@example.com', password: 'k#dkvKfdj38g!'} }
+
+    describe '#create' do
+      render_views
+
+      it 'render new if the user input validation fails' do
+        post :create, forgot_password: {email: 'email'}
+        expect(response).to have_http_status(200)
+        expect(response.body).to match(/Email is invalid/)
+      end
+
+      it 'redirects the user to the same page no matter if the email exists or not in the system' do
+        _ = TestHelper::create_signed_up_actor_with_confirmed_email_address(user[:email], user[:password])
+
+        post :create, {"utf8"=>"✓", "forgot_password"=>{"email"=>user[:email]} }
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/forgot_password_verification_mail_sent')
+
+        post :create, {"utf8"=>"✓", "forgot_password"=>{"email"=>"not_an_actual_user@example.com"} }
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/forgot_password_verification_mail_sent')
+      end
+
+    end
+
+    describe '#reset_password' do
+      render_views
+
+      it 'render choose_new_password if something is wrong with the user inputs' do
+        post :reset_password, forgot_password: {email: 'email'}
+        expect(response).to have_http_status(200)
+        expect(response.body).to match(/Password is too short/)
+      end
+
+      it 'redirects the user to the sign in url if the password reset is successful' do
+        allow(DoorMat::Process::ResetPassword).to receive(:with).and_return(true)
+        post :reset_password, forgot_password: {email: user[:email], password: user[:password], password_confirmation: user[:password]}
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/sign_in')
+      end
+
+      it 'redirect the user to the start of the forgot password recovery process if an error occurs' do
+        allow(DoorMat::Process::ResetPassword).to receive(:with).and_return(false)
+        post :reset_password, forgot_password: {email: user[:email], password: user[:password], password_confirmation: user[:password]}
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/forgot_password')
+      end
+
+    end
+
+  end
+end