Extending laravel 5.2 authentication

Question

I am trying to connect Laravel to an external database for the authentication, though I am not sure how to go about it.

How would I go about extending Laravels authentication to allow for a custom login method?

The database is auth and it uses username or email to login with, the password hash is sha512.

What would be the best way?

Answer 1

Different database:

I would say that the best way to do so is to define a separate connection for the specific model.

So, in your database.php config, add another connection (let's name it mysql_auth).

To use it in a model, you need to add this as a variable in the class:

protected $connection = 'mysql_auth';

Now, by default the model queries will do queries to that exact connection.

Just as a note, to build migrations, use Schema::connection('mysql_auth')->create(...).

Different hashing method:

Original: To use different hashing functionality, you need to, basically, use a different class as a Hash class.

By default, hashing, as defined in providers, is done here: Illuminate\Hashing\HashServiceProvider::class. To change it, you'll have to create a separate, different class as a provider and change this line:

$this->app->singleton('hash', function () {
    return new BcryptHasher;
});

Now, this will then link to your hashing class (that will implement HasherContract interface) that will do the sha512 (or whatever else) hashing.

All in all, check out Illuminate\Hashing\HashServiceProvider, how it registers the hashing methods and Illuminate\Hashing\BcryptHasher for the methods that you need to implement to implement your hashing.

Update:

Comment out Illuminate\Hashing\HashServiceProvider::class in providers and add something like \App\Providers\NewHashServiceProvider::class. Now, we create a new provider(app/Providers). This should work:

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class NewHashServiceProvider extends ServiceProvider
{
    /**
     * Indicates if loading of the provider is deferred.
     *
     * @var bool
     */
    protected $defer = true;

    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->app->singleton('hash', function () {
            return new \App\ShaHasher;
        });
    }

    /**
     * Get the services provided by the provider.
     *
     * @return array
     */
    public function provides()
    {
        return ['hash'];
    }
}

This actually returns our hasher, that we will create in a moment.

To implement ShaHasher, create a class that implements HasherContract (just like BcryptHasher does):

<?php

namespace App;

use RuntimeException;
use Illuminate\Contracts\Hashing\Hasher as HasherContract;

class ShaHasher implements HasherContract
{
    /**
     * Hash the given value.
     *
     * @param  string  $value
     * @param  array   $options
     * @return string
     *
     * @throws \RuntimeException
     */
    public function make($value, array $options = [])
    {
        return hash('sha512',$value);
    }

    /**
     * Check the given plain value against a hash.
     *
     * @param  string  $value
     * @param  string  $hashedValue
     * @param  array   $options
     * @return bool
     */
    public function check($value, $hashedValue, array $options = [])
    {
        if (strlen($hashedValue) === 0) {
            return false;
        }

        return hash('sha512',$value) == $hashedValue
    }

    /**
     * Check if the given hash has been hashed using the given options.
     *
     * @param  string  $hashedValue
     * @param  array   $options
     * @return bool
     */
    public function needsRehash($hashedValue, array $options = [])
    {
        return false;
    }
}

Answer 2

The new implementation for Sha512 would then probably be something like:

namespace App;

use Illuminate\Contracts\Hashing\Hasher;

class Sha512Hasher implements Hasher
{
    public function make($value, array $options = [])
    {

    }

    public function check($value, $hashedValue, array $options = [])
    {

    }

    public function needsRehash($hashedValue, array $options = [])
    {

    }
}

So you basically utilizing a ServiceContract Illuminate\Contracts\Hashing\Hasher

To bind this use a ServiceProvider:

class Sha512ServiceProvider extends ServiceProvider
{
    /**
     * Register bindings in the container.
     *
     * @return void
     */
    public function register()
    {
        $this->app->singleton('hash', function () { 
        return new App\Sha512Hasher; 
    });

    }
}