Catalyst::Authentication::Credential::Authen::Simple - Verify credentials with the Authen::Simple framework

  use Catalyst qw(Authentication);
  # later on ...
  if ($c->authenticate({ username => 'myusername', 
                         password => 'mypassword' })){
    my $long_name = $c->user->get('LongName');
    # Hello Mr $long_name 
  }

  'Plugin::Authentication' => {
    'realms' => {
      'default' => {
        'store' => { ... }
        'credential' => {
          'class' => 'Authen::Simple',
          'authen' => [
            {
              'class' => 'Passwd',
              'args' => {
                'path' => '/etc/shadow'
              }
            },
            {
              'class' => 'SSH',
              'args' => {
                'host' => 'host.company.com'
              }
            }
          ]
        }
      }
    }
  }

 Usage     : Call $c->authenticate({ username => ..., password => ...}); 
 Returns   : User object if the credentials are verified successfully. undef if user not authenticated.

    Jose Luis Martinez
    CPAN ID: JLMARTIN
    CAPSiDE
    jlmartinez@capside.com
    http://www.pplusdomain.net

package Catalyst::Authentication::Credential::Authen::Simple;

our $VERSION = '0.07';

use strict;
use warnings;

use Authen::Simple;
use Catalyst::Utils;

sub new {
    my ($class, $config, $app, $realm) = @_;
    my $self = {};
    bless $self, $class;

    unless (defined $config->{'authen'}){
        die "No Authen::Simple classes specified for Credential::Authen::Simple in 'authen' key"
    }

    if (ref($config->{'authen'}) ne 'ARRAY') {
        $config->{'authen'} = [ $config->{'authen'}  ];
    }
    my $log = $app->log;

    my @auth_arr;
    foreach my $auth (@{ $config->{'authen'}  }){
        my $class = "Authen::Simple::$auth->{'class'}";
        $log->debug("Loading class: $class") if $app->debug;
        Catalyst::Utils::ensure_class_loaded($class);
        push @auth_arr, $class->new(%{ $auth->{'args'} });
    }

    # Catalyst documentation only says that Logger objects SHOULD
    # implement these methods. $log has to exist, and $log->debug too
    # (they've been used a couple of lines earlier)
    if ($log->can('warn') and
	$log->can('error') and
	$log->can('debug') and
	$log->can('info')
       ){
        foreach my $auth (@auth_arr){
            $auth->log($log);
	}
    } else {
        $log->debug('Authen::Simple classes cannot log with the configured Catalyst log object') if ($app->debug);
    }

    $self->{'_config'}->{'password_field'} ||= 'password';
    $self->{'_auth'} = new Authen::Simple(@auth_arr);

    return $self;

}

sub authenticate {
    my ($self, $c, $realm, $authinfo) = @_;

    my $user = $authinfo->{'username'};
    my $password = $authinfo->{'password'};

    ## because passwords may be in a hashed format, we have to make sure that we remove the
    ## password_field before we pass it to the user routine, as some auth modules use
    ## all data passed to them to find a matching user...
    my $userfindauthinfo = {%{$authinfo}};
    delete($userfindauthinfo->{$self->{'_config'}->{'password_field'}});

    my $user_obj = $realm->find_user($userfindauthinfo, $c);
    if (not ref($user_obj)) {
        $c->log->debug("Unable to locate user matching user info provided") if $c->debug;
        return;
    }

    unless (defined $password) {
        $c->log->debug("Can't login a user without a password") if $c->debug;
        return 0;
    }

    if ($self->{'_auth'}->authenticate($user, $password)){
        $c->log->debug("User $user Authenticated") if $c->debug;
        return $user_obj;
    } else {
        $c->log->debug("None of the Authen::Simple classes authed $user") if $c->debug;;
        return;
    }
}

#################### main pod documentation begin ###################

#################### main pod documentation end ###################


1;