catalyst::plugin::authentication::credential::openid(3pm) [debian man page]

Catalyst::Plugin::Authentication::Credential::OpenID(3pmUser Contributed Perl DocumentatiCatalyst::Plugin::Authentication::Credential::OpenID(3pm)

NAME

       Catalyst::Plugin::Authentication::Credential::OpenID - OpenID credential for Catalyst::Auth framework

SYNOPSIS

	 use Catalyst qw/
	   Authentication
	   Authentication::Credential::OpenID
	   Session
	   Session::Store::FastMmap
	   Session::State::Cookie
	 /;

	 # MyApp.yaml -- optional
	 authentication:
	   openid:
	     use_session: 1
	     user_class: MyApp::M::User::OpenID

	 # whatever in your Controller pm
	 sub default : Private {
	     my($self, $c) = @_;
	     if ($c->user_exists) { ... }
	 }

	 sub signin_openid : Local {
	     my($self, $c) = @_;

	     if ($c->authenticate_openid) {
		 $c->res->redirect( $c->uri_for('/') );
	     }
	 }

	 # foo.tt
	 <form action="[% c.uri_for('/signin_openid') %]" method="GET">
	 <input type="text" name="openid_url" class="openid" />
	 <input type="submit" value="Sign in with OpenID" />
	 </form>

DESCRIPTION

       Catalyst::Plugin::Authentication::Credential::OpenID is an OpenID credential for Catalyst::Plugin::Authentication framework.

METHODS

       authenticate_openid
	     $c->authenticate_openid;

	   Call this method in the action you'd like to authenticate the user via OpenID. Returns 0 if auth is not successful, and 1 if user is
	   authenticated.

	   User class specified with user_class config, which defaults to Catalyst::Plugin::Authentication::User::Hash, will be instantiated with
	   the following parameters.

	   By default, authenticate_openid method looks for claimed URI parameter from the form field named "openid_url", "openid_identifier" or
	   "claimed_uri". If you want to use another form field name, call it like:

	     $c->authenticate_openid( $c->req->param('myopenid_param') );

	   url
	   display
	   rss
	   atom
	   foaf
	   declared_rss
	   declared_atom
	   declared_foaf
	   foafmaker

	   See Net::OpenID::VerifiedIdentity for details.

DIFFERENCE WITH Authentication::OpenID
       There's already Catalyst::Plugin::Authentication::OpenID (Auth::OpenID) and this plugin tries to deprecate it.

       o   Don't use this plugin with Auth::OpenID since method names will conflict and your app won't work.

       o   Auth::OpenID uses your root path (/) as an authentication callback but this plugin uses the current path, which means you can use this
	   plugin with other Credential plugins, like Flickr or TypeKey.

       o   This plugin is NOT a drop-in replacement for Auth::OpenID, but your app needs only slight modifications to work with this one.

       o   This plugin is based on Catalyst authentication framework, which means you can specify user_class or auth_store in your app config and
	   this modules does the right thing, like other Credential modules. This crates new User object if authentication is successful, and
	   works with Session too.

AUTHOR

       Six Apart, Ltd. <cpan@sixapart.com>

LICENSE

       This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

SEE ALSO

       Catalyst::Plugin::Authentication::OpenID, Catalyst::Plugin::Authentication::Credential::Flickr

perl v5.10.1							    2007-10-26		 Catalyst::Plugin::Authentication::Credential::OpenID(3pm)

Catalyst::Authentication::Credential::Password(3pm)	User Contributed Perl Documentation    Catalyst::Authentication::Credential::Password(3pm)

NAME

       Catalyst::Authentication::Credential::Password - Authenticate a user with a password.

SYNOPSIS

	   use Catalyst qw/
	     Authentication
	     /;

	   package MyApp::Controller::Auth;

	   sub login : Local {
	       my ( $self, $c ) = @_;

	       $c->authenticate( { username => $c->req->param('username'),
				   password => $c->req->param('password') });
	   }

DESCRIPTION

       This authentication credential checker takes authentication information (most often a username) and a password, and attempts to validate
       the password provided against the user retrieved from the store.

CONFIGURATION

	   # example
	   __PACKAGE__->config('Plugin::Authentication' =>
		       {
			   default_realm => 'members',
			   realms => {
			       members => {

				   credential => {
				       class => 'Password',
				       password_field => 'password',
				       password_type => 'hashed',
				       password_hash_type => 'SHA-1'
				   },
				   ...

       The password module is capable of working with several different password encryption/hashing algorithms. The one the module uses is
       determined by the credential configuration.

       Those who have used Catalyst::Plugin::Authentication prior to the 0.10 release should note that the password field and type information is
       no longer part of the store configuration and is now part of the Password credential configuration.

       class
	   The classname used for Credential. This is part of Catalyst::Plugin::Authentication and is the method by which
	   Catalyst::Authentication::Credential::Password is loaded as the credential validator. For this module to be used, this must be set to
	   'Password'.

       password_field
	   The field in the user object that contains the password. This will vary depending on the storage class used, but is most likely
	   something like 'password'. In fact, this is so common that if this is left out of the config, it defaults to 'password'. This field is
	   obtained from the user object using the get() method. Essentially: $user->get('passwordfieldname'); NOTE If the password_field is
	   something other than 'password', you must be sure to use that same field name when calling $c->authenticate().

       password_type
	   This sets the password type.  Often passwords are stored in crypted or hashed formats.  In order for the password module to verify the
	   plaintext password passed in, it must be told what format the password will be in when it is retreived from the user object. The
	   supported options are:

	   none    No password check is done. An attempt is made to retrieve the user based on the information provided in the $c->authenticate()
		   call. If a user is found, authentication is considered to be successful.

	   clear   The password in user is in clear text and will be compared directly.

	   self_check
		   This option indicates that the password should be passed to the check_password() routine on the user object returned from the
		   store.

	   crypted The password in user is in UNIX crypt hashed format.

	   salted_hash
		   The password in user is in salted hash format, and will be validated using Crypt::SaltedHash.  If this password type is
		   selected, you should also provide the password_salt_len config element to define the salt length.

	   hashed  If the user object supports hashed passwords, they will be used in conjunction with Digest. The following config elements
		   affect the hashed configuration:

		   password_hash_type
			   The hash type used, passed directly to "new" in Digest.

		   password_pre_salt
			   Any pre-salt data to be passed to "add" in Digest before processing the password.

		   password_post_salt
			   Any post-salt data to be passed to "add" in Digest after processing the password.

USAGE

       The Password credential module is very simple to use. Once configured as indicated above, authenticating using this module is simply a
       matter of calling $c->authenticate() with an authinfo hashref that includes the password element. The password element should contain the
       password supplied by the user to be authenticated, in clear text. The other information supplied in the auth hash is ignored by the
       Password module, and simply passed to the auth store to be used to retrieve the user. An example call follows:

	   if ($c->authenticate({ username => $username,
				  password => $password} )) {
	       # authentication successful
	   } else {
	       # authentication failed
	   }

METHODS

       There are no publicly exported routines in the Password module (or indeed in most credential modules.)  However, below is a description of
       the routines required by Catalyst::Plugin::Authentication for all credential modules.

   new( $config, $app, $realm )
       Instantiate a new Password object using the configuration hash provided in $config. A reference to the application is provided as the
       second argument.  Note to credential module authors: new() is called during the application's plugin setup phase, which is before the
       application specific controllers are loaded. The practical upshot of this is that things like $c->model(...) will not function as expected.

   authenticate( $authinfo, $c )
       Try to log a user in, receives a hashref containing authentication information as the first argument, and the current context as the
       second.

   check_password( )
perl v5.14.2							    2012-04-14		       Catalyst::Authentication::Credential::Password(3pm)