view release on metacpan or  search on metacpan

lib/Carp/Proxy.pm  view on Meta::CPAN

Underscores are replaced by single spaces everywhere they occur.  Spaces
are inserted everywhere character-case changes from lower to upper, and
upper-case characters are folded to lower-case.  The following are example
conversions:

    'no_user_credentials'  => 'no user credentials'
    'nonexistentRecord'    => 'nonexistent record'

Sub-class B<Carp::Proxy> and override B<identifier_presentation()> if
you want a different convention.

lib/Carp/Proxy.pm  view on Meta::CPAN

      *** Please contact the maintainer ***
        your.name@support.org   555-1212

      *** Missing Handler ***
        handler_name:   no_credentials
        handler_pkgs:   main
        handler_prefix: (undef)

      *** Stacktrace ***
        fatal called from line 443 of /usr/local/bin/hibs

 view release on metacpan or  search on metacpan

lib/Cassandra/Client/Connection.pm  view on Meta::CPAN

sub authenticate {
    my ($self, $callback, $initial_challenge)= @_;

    my $authenticator= unpack_string($initial_challenge);
    if (!$self->{options}{authentication}) {
        return $callback->("Server expected authentication using <$authenticator> but no credentials were set");
    }

    my $auth;
    eval {
        $auth= $self->{options}{authentication}->begin($authenticator);

 view release on metacpan or  search on metacpan

lib/Cassandra/Lite.pm  view on Meta::CPAN

sub _login {
    my $self = shift;
    my $client = shift;

    my $auth = Cassandra::AuthenticationRequest->new;
    $auth->{credentials} = {username => $self->username, password => $self->password};
    $client->login($auth);
}

sub _trigger_keyspace {
    my ($self, $keyspace) = @_;

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/Authen/Simple.pm  view on Meta::CPAN

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

=head1 NAME

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

=head1 SYNOPSIS

  use Catalyst qw(Authentication);
  # later on ...

lib/Catalyst/Authentication/Credential/Authen/Simple.pm  view on Meta::CPAN

This module helps your Cataylst Application authenticate against a lot of credential databases thanks to the Authen::Simple framework.

=head1 USAGE

Just configure your Catalyst App Authentication to use class 'Authen::Simple' as the credential verifier, and give it a set of Authen::Simple classes. You can pass arguments to the Authen::Simple:XXX class constructors with the 'args' key. Note that ...

  'Plugin::Authentication' => {
    'realms' => {
      'default' => {
        'store' => { ... }

lib/Catalyst/Authentication/Credential/Authen/Simple.pm  view on Meta::CPAN

=cut

=head2 authenticate 

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

=cut

=head1 AUTHOR

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/CAS.pm  view on Meta::CPAN

=item B<authenticate( $authinfo, $realm, $c )>

This is called during the normal Catalyst authentication process
and should never be called directly.

Since CAS is a service that verifies credentials outside of your
application, the login process for your application will have
two phases.  In the first phase, an unauthenticated user will
attempt to access your application and be redirected to the CAS
for credential verification.  A service URI must be provided to
the CAS so that once the user has been identified, they can be

lib/Catalyst/Authentication/Credential/CAS.pm  view on Meta::CPAN

C<'ticket'> key of the C<$authinfo> hash.  If no ticket is
defined (phase one authentication) the response will be set to
redirect to the CAS and the current action will be detached.

You may also pass other parameters in the C<$authinfo> hash that
will affect the way the CAS verifies credentials.  See the
documentation for L<Authen::CAS::Client|Authen::CAS::Client> for
more on the C<'renew'>, C<'gateway'> and C<'pgtUrl'> parameters.

=back

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/Facebook/OAuth2.pm  view on Meta::CPAN

L<http://facebook.com> that will ask the user to confirm our request to
authenticate him. Once that has happened, Facebook will redirect back to use and
C<authenticate> will return a user instance.

Note how this is different from most other Catalyst authentication
credentials. Successful authentication requires two requests to the Catalyst
application - one is initiated by the user, the second one is caused by Facebook
redirecting the user back to the application.

Because of that, special care has to be taken. If C<authenticate> returns a
false value, that means it set up the appropriate redirect response in

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/Facebook.pm  view on Meta::CPAN

	if (my $user = $c->authenticate(undef,'facebook')) {
		# user is logged in - redirect or do something
	}
	else {
		# user has no account in your system
		# detect Facebook credentials and create an account
		# or do comething else
	} 
 }

=head1 DESCRIPTION

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/HTTP/Proxy.pm  view on Meta::CPAN

    my $headers = $c->req->headers;

    if ( my ( $user, $password ) = $headers->authorization_basic ) {
        my $ua = Catalyst::Authentication::Credential::HTTP::Proxy::User->new;
        $ua->credentials($user, $password);
        my $resp = $ua->get($self->url);
        if ( $resp->is_success ) {
            # Config username_field TODO
	        my $user_obj = $realm->find_user( { username => $user }, $c);
	        unless ($user_obj) {

lib/Catalyst/Authentication/Credential/HTTP/Proxy.pm  view on Meta::CPAN

            $c->log->info('Remote authentication failed:'.$resp->message);
            return 0;
        }
    } 
    elsif ( $c->debug ) {
        $c->log->info('No credentials provided for basic auth');
        return 0;
    }
}

1;

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/HTTP.pm  view on Meta::CPAN

If this is omitted or its value is empty, the client will assume that the
protection space consists of all URIs on the responding server.

Therefore, if your application is not hosted at the root of this domain, and you want to
prevent the authentication credentials for this application being sent to any other applications.
then you should use the I<use_uri_for> configuration option, and pass a domain of I</>.

=back

=item authenticate_basic $c, $realm, \%auth_info

lib/Catalyst/Authentication/Credential/HTTP.pm  view on Meta::CPAN

=item use_uri_for

If this configuration key has a true value, then the domain(s) for the authorization header will be
run through $c->uri_for(). Use this configuration option if your application is not running at the root
of your domain, and you want to ensure that authentication credentials from your application are not shared with
other applications on the same server.

=item require_ssl

If this configuration key has a true value then authentication will be denied

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/OpenID.pm  view on Meta::CPAN

As previously noted, L</EXTENSIONS TO OPENID>, I have not tested the extensions. I would be grateful for any feedback or, better, tests.

=head2 FATALS

The problems encountered by failed OpenID operations have always been fatals in the past. This is unexpected behavior for most users as it differs from other credentials. Authentication errors here are no longer fatal. Debug/error output is improved ...

=head1 SYNOPSIS

In MyApp.pm-

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/RemoteHTTP.pm  view on Meta::CPAN

            keep_alive => $self->http_keep_alive ? 1 : 0 );

        # add prefix/suffix to user data to make auth_user, get password
        my $auth_user = sprintf( '%s%s%s', $self->user_prefix, $username, $self->user_suffix );
        my $password = $authinfo->{ $self->password_field };
        $ua->set_credentials( $auth_user, $password );

        # do the request
        my $res = $ua->head( $self->url );

        # did it succeed

lib/Catalyst/Authentication/Credential/RemoteHTTP.pm  view on Meta::CPAN

=item url

The URL that is used to authenticate the user. The module attempts
to fetch this URL using a HEAD request (to prevent dragging a large
page across the network) with the credentials given. If this fails
then the authentication fails. If no URL is supplied in the config,
then an exception is thrown on startup.

=item username_field

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/Twitter.pm  view on Meta::CPAN

	# get the user
	$self->_twitter->access_token($access_token);
    $self->_twitter->access_token_secret($access_token_secret);

	my $twitter_user_hash = eval {
		$self->_twitter->verify_credentials;
	};

	if ($@ || !$twitter_user_hash) {
		$c->log->debug("no twitter_user_hash or error: ".$@);
		return undef;

lib/Catalyst/Authentication/Credential/Twitter.pm  view on Meta::CPAN

		# user has an account - redirect or do something cool
    	$c->res->redirect("/super/secret/member/area");
	}
	else {
		# user doesn't have an account - either detect Twitter
		# credentials and create one, or return an error.
		#
		# Note that "request_token" and "request_token_secret"
		# are stored in $c->user_session as hashref variables under
		# the same names
	}

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/Upstream/Headers.pm  view on Meta::CPAN

package Catalyst::Authentication::Credential::Upstream::Headers;
{
  $Catalyst::Authentication::Credential::Upstream::Headers::VERSION = '0.02';
}

# ABSTRACT: Catalyst authentication credentials from HTTP headers

use Moose;

has user_header =>
	isa			=> 'Str',

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Realm/Adaptor.pm  view on Meta::CPAN

The Catalyst::Authentication::Realm::Adaptor allows for modification of
authentication parameters within the catalyst application. It's basically a
filter used to adjust authentication parameters globally within the
application or to adjust user retrieval parameters provided by the credential
in order to be compatible with a different store. It provides for better
control over interaction between credentials and stores. This is particularly
useful when working with external authentication such as OpenID or OAuth.

 __PACKAGE__->config(
    'Plugin::Authentication' => {
            'default' => {

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Store/LDAP.pm  view on Meta::CPAN

wide variation of LDAP directories and schemas from one system to another.

It authenticates users in two steps:

1) A search of the directory is performed, looking for a user object that
   matches the username you pass.  This is done with the bind credentials
   supplied in the "binddn" and "bindpw" configuration options.

2) If that object is found, we then re-bind to the directory as that object.
   Assuming this is successful, the user is Authenticated.

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Store/UserXML.pm  view on Meta::CPAN

            }
        },
        'authentication' => {
            'userxml' => {
                'folder' => 'members',
                'user_folder_file' => 'index.xml',   # optional if credentials stored one per folder
            }
        },
    );

    # later in controller (login)

 view release on metacpan or  search on metacpan

inc/Test/WWW/Mechanize/Catalyst.pm  view on Meta::CPAN

    $self->_set_host_header($request);

    my $res = $self->_check_external_request($request);
    return $res if $res;

    my @creds = $self->get_basic_credentials( "Basic", $uri );
    $request->authorization_basic( @creds ) if @creds;

    require Catalyst;
    my $response = $Catalyst::VERSION >= 5.89000 ?
      Catalyst::Test::_local_request($self->{catalyst_app}, $request) :

 view release on metacpan or  search on metacpan

script/auth_bootstrap.pl  view on Meta::CPAN

         help => \$help);

pod2usage(1) if ( $help || !$credential );

if  ($credential !~ /^(http|password)$/) {
    die "Valid credentials are 'http' for basic auth or 'password' for web based auth";
}

Catalyst::Helper::AuthDBIC::make_model();
Catalyst::Helper::AuthDBIC::mk_auth_controller() if $credential eq 'password';
Catalyst::Helper::AuthDBIC::add_plugins();

 view release on metacpan or  search on metacpan

lib/Catalyst/Manual/Components.pod  view on Meta::CPAN

config hash. Great for testing or getting up and running quickly.

=head4 L<Catalyst::Authentication::Store::Null>

The Null store is a transparent store where any supplied user data is
accepted.  This is mainly useful for remotely authenticating credentials
(e.g. OpenID) which may not be tied to any local storage.

=head4 L<Catalyst::Authentication::Store::RDBO>

Allows access to authentication information stored in a database via a L<Rose::DB::Object> class.

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/LDAP/Connection.pm  view on Meta::CPAN

On connection failure, an error is thrown using L<Carp/croak>.

=head2 bind

Bind to the configured LDAP server using the specified credentials.

    $conn->bind(
        dn       => 'uid=dwc,ou=People,dc=ufl,dc=edu',
        password => 'secret',
    );

 view release on metacpan or  search on metacpan

inc/Test/WWW/Mechanize/Catalyst.pm  view on Meta::CPAN

    }
 
    my $res = $self->_check_external_request($request);
    return $res if $res;

    my @creds = $self->get_basic_credentials( "Basic", $uri );
    $request->authorization_basic( @creds ) if @creds;

    my $response =Catalyst::Test::local_request($self->{catalyst_app}, $request);

    # LWP would normally do this, but we dont get down that far.

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/SCP.pm  view on Meta::CPAN

=head1 SUBROUTINES/METHODS

=head2 is_connection_success

C<is_connection_success()> - Returns true when it able to make connection using specified credentials.

=cut

has is_connection_success => (
    isa => 'Bool',

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Authentication/Credential/Atom.pm  view on Meta::CPAN

use constant NS_WSSE => 'http://schemas.xmlsoap.org/ws/2002/07/secext';
use constant NS_WSU => 'http://schemas.xmlsoap.org/ws/2002/07/utility';

sub login_atom {
    my $c = shift;
    my($username, $cred) = $c->_extract_credentials;
    unless ($username) {
        return $c->_atom_auth_error(401);
    }

    if (my $user = $c->get_user($username)) {
        if ($c->_validate_credentials($user, $cred)) {
            $c->set_authenticated($user);
            return $username;
        }
    }
    return $c->_atom_auth_error(403);

lib/Catalyst/Plugin/Authentication/Credential/Atom.pm  view on Meta::CPAN

    $c->response->header('WWW-Authenticate',
        'WSSE profile="UsernameToken", Basic');
    return 0;
}

sub _extract_credentials {
    my $c = shift;
    my $req = $c->request;
    my($tokens, $username, %cred);
    ## SOAP wrapper only supports WSSE?
    if ($req->is_soap) {

lib/Catalyst/Plugin/Authentication/Credential/Atom.pm  view on Meta::CPAN

        $username = delete $cred{Username};
    }
    ($username, \%cred);
}

sub _validate_credentials {
    my $c = shift;
    my($user, $cred) = @_;
    if ($cred->{password}) {
        return $c->_check_password($user, $cred->{password})
    } elsif ($cred->{PasswordDigest}) {

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Authentication/Credential/HTTP/Proxy.pm  view on Meta::CPAN

    croak "url setting required for authentication" 
        unless $c->config->{authentication}{http_proxy}{url};
    if ( my ( $user, $password ) = $headers->authorization_basic ) {

        my $ua=Catalyst::Plugin::Authentication::Credential::HTTP::User->new;
        $ua->credentials($user,$password);
        my $resp= $ua->get($c->config->{authentication}{http_proxy}{url});
        if ( $resp->is_success ) {
            if ( my $store = $c->config->{authentication}{http_proxy}{store} ) {
                $user = $store->get_user($user);
            } elsif ( my $user_obj = $c->get_user($user) ) {

lib/Catalyst/Plugin/Authentication/Credential/HTTP/Proxy.pm  view on Meta::CPAN

        } elsif ( $c->debug ) {
            $c->log->info('Remote authentication failed:'.$resp->message);
            return 0;
        }
    } elsif ( $c->debug ) {
        $c->log->info('No credentials provided for basic auth');
        return 0;
    }
}

sub authorization_required {

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm  view on Meta::CPAN

    my %ret;

    if ( @params % 2 == 1 ) {

        # either it's a user object or a hash ref of credentials
        # if it's a user object the credentials are pulled out of it
        # otherwise a user will be found/made for the credentials
        if ( Scalar::Util::blessed( $params[0] ) ) {
            my $user = $ret{user_object} = shift @params;

            croak "Attempted to authenticate user object, but "
              . "user doesnt't support 'typekey_credentials'"
              unless $user->supports(qw/typekey_credentials/);

            $ret{credentials} = $user->typekey_credentials;

        } elsif ( @params == 1 and ref( $params[0] ) eq "HASH" ) {
            $ret{credentials} = shift @params;
        } else {
            croak "Invalid parameters";
        }
    }

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm  view on Meta::CPAN

    foreach my $key (@config_fields) {
        # if it was passed as a parameter then move it to the right place
        $ret{$key} = delete $params{$key} || $config->{$key};
    }

    # separate TypeKey's config from credentials
    # these options override config
    $ret{typekey_config} = {};
    foreach my $key (grep { exists $params{$_} } @typekey_config_fields) {
        $ret{typekey_config}{$key} = delete $params{$key};
    }

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm  view on Meta::CPAN

    # get the object from config and apply local overrides
    $ret{typekey_object} = delete $params{typekey_object} || $c->get_typekey_object( %{ $ret{typekey_config} } );

    # Authen::TypeKey can also take CGI compatible objects
    if ( keys %params ) {
        $ret{credentials} = \%params;
    } else {
        $ret{credentials} = $c->request if not($ret{credentials}) or not( keys %{ $ret{credentials} } );
    }

    return \%ret;
}

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm  view on Meta::CPAN

    my ( $c, @params ) = @_;

    my $params = $c->_munge_typekey_params(@params);

    my $typekey    = $params->{typekey_object};
    my $cred       = $params->{credentials};
    my $user       = $params->{user_object};      # probably undef
    my $user_class = $params->{user_class};
    my $auth_store = $params->{auth_store};

    $c->last_typekey_object($typekey);

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm  view on Meta::CPAN

Any configuration field (this plugin's configuration, e.g. C<user_class>, as
well as any L<Authen::TypeKey> configuration fields, e.g. C<token>, etc) can
be in %parameters. This will clone the configured typekey object if needed and
set the fields locally for this call only.

All other fields are assumed to be typekey credentials.

If a user object is provided it will be asked for it's typekey credentials and
then authenticated against the server keys.

If there are no typekey credentials in the paramters or the user object, the
credentials will be taken from C<< $c->request >>.

If a user object exists and is authenticated correctly it will be marked as
authenticated. If no such object exists but C<auth_store> is provided (or
configured) then it will attempt to retrieve a user from that store using the
C<name> typekey credential field. If no C<auth_store> is configured or a user

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Authentication/Store/HTTP.pm  view on Meta::CPAN

=head1 DESCRIPTION

This module is Catalyst authentication storage plugin that
authenticates based on a URL HTTP HEAD fetch using the supplied
credentials.  If the fetch succeeds then the authentication succeeds.

L<LWP::UserAgent> is used to fetch the URL which requires authentication,
so any authentication method supported by that module can be used.

Remote authentication methods known to work are:-

lib/Catalyst/Plugin/Authentication/Store/HTTP.pm  view on Meta::CPAN

=over 4

=item auth_url

The URL that is fetched to demonstrate that the supplied credentials
work.  This can be any URL that L<LWP::UserAgent> will support and
that will support a C<HEAD> method.  This item must be supplied.

=item keep_alive

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/NoPassword.pm  view on Meta::CPAN

=head1 DESCRIPTION

This authentication credential checker takes authentication information 
(most often a username) and retrieves the user from the store. No validation
of any credentials is done. This is intended for administrative backdoors,
SAML logins and so on when you have identified the new user by other means.

=head1 CONFIGURATION

    # example

 view release on metacpan or  search on metacpan

inc/Test/WWW/Mechanize/Catalyst.pm  view on Meta::CPAN

    {
        return $self->SUPER::_make_request($request);
    }

    $request->authorization_basic(
        LWP::UserAgent->get_basic_credentials(
            undef, "Basic", $request->uri
        )
        )
        if LWP::UserAgent->get_basic_credentials( undef, "Basic",
        $request->uri );

    my $response = Test::WWW::Mechanize::Catalyst::Aux::request($request);
    $response->header( 'Content-Base', $request->uri );
    $response->request($request);

 view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Credential/OAuth2.pm  view on Meta::CPAN

      }
    );

=head1 DESCRIPTION

This module implements authentication via OAuth2 credentials, giving you a
user object which stores tokens for accessing protected resources.

=head1 ATTRIBUTES

=head2 grant_uri

 view release on metacpan or  search on metacpan

lib/Catmandu/Adlib/API/Login.pm  view on Meta::CPAN

has username => (is => 'ro', required => 1);
has password => (is => 'ro', required => 1);

# login => moet helemaal anders!

sub get_basic_credentials {
    my ($self, $realm, $url) = @_;
    return $self->username, $self->password;
}

1;