view release on metacpan or  search on metacpan

CompanyNames/TextSupport.pm  view on Meta::CPAN

crease creased creases creasing
create created creater creates creating creation creationism creations creative creatively creativeness creatives creativity creator creators
creationist creationists
creature creatures
creche creches
credential credentialed credentialing credentials
credentialled credentialling
credenza credenzas
credibility credible credibly
credit creditability creditable creditably credited crediting credits
creditor creditors

 view release on metacpan or  search on metacpan

lib/Finance/FXCM/Simple.pm  view on Meta::CPAN

Your FXCM account password

=item C<$type>

The account type the login credentials apply to. Either 'Demo' or 'Real'.


=item C<$url>

The url to connect to, typically this will be 'http://www.fxcorporate.com/Hosts.jsp'

 view release on metacpan or  search on metacpan

lib/Finance/GDAX/API.pm  view on Meta::CPAN

passphrase:andTHisiSMypassPhraSE

There can be comments ("#" beginning a line), and blank lines.

In other words, for exmple, if you cryptographically store your API
credentials, you can create a small callable program that will decrypt
them and provide them, so that they never live on disk unencrypted,
and never show up in process listings:

  my $request = Finance::GDAX::API->new;
  $request->external_secret('/path/to/my_decryptor', 1);

 view release on metacpan or  search on metacpan

Testing/test-record.pl  view on Meta::CPAN

# This file needs a valid account to do anything useful. 
# This will be your account, not mine! 
# You can hardcode here or use a credential fiie. 
# Running this script will allow you to generate 
# new canned test data for new test scripts. 
if ( eval (require "credentials.pl") ) 
{
  $ig=Finance::IG->new(cred()); 
} 
else
{ 

 view release on metacpan or  search on metacpan

lib/Finance/MtGox.pm  view on Meta::CPAN

=head1 BASIC METHODS

=head2 new

Create a new C<Finance::MtGox> object with your MtGox credentials provided
in the C<key> and C<secret> arguments.

=cut

sub new {
    my ( $class, $args ) = @_;

    $args->{key} && $args->{secret}
      or croak "You must provide 'key' and 'secret' credentials.";

    $args->{json} = JSON::Any->new;
    $args->{mech} = WWW::Mechanize->new(stack_depth => 0);

    return bless $args, $class;

 view release on metacpan or  search on metacpan

lib/Finance/PaycheckRecords/Fetcher.pm  view on Meta::CPAN

    mech     => WWW::Mechanize->new,
  }, $class;
} # end new

#---------------------------------------------------------------------
# Get a URL, automatically supplying login credentials if needed:

sub _get
{
  my ($self, $url) = @_;

 view release on metacpan or  search on metacpan

YahooQuote.pm  view on Meta::CPAN

    my $self = LWP::UserAgent::new(@_);
    $self->agent("Finance-YahooQuote/0.18");
    $self;
  }

  sub get_basic_credentials {
    my $self = @_;
    if (defined($PROXYUSER) and defined($PROXYPASSWD) and
 	$PROXYUSER ne "" and $PROXYPASSWD ne "") {
      return ($PROXYUSER, $PROXYPASSWD);
    } else {

 view release on metacpan or  search on metacpan

lib/Firefox/Marionette.pm  view on Meta::CPAN

        $authenticator = $self->webauthn_authenticator();
    }
    return $authenticator;
}

sub webauthn_credentials {
    my ( $self, $parameter_authenticator ) = @_;
    my $authenticator = $self->_get_webauthn_authenticator(
        authenticator => $parameter_authenticator );
    my $message_id = $self->_new_message_id();
    $self->_send_request(

lib/Firefox/Marionette.pm  view on Meta::CPAN

          MIME::Base64::decode_base64url( $credential->{userHandle} );
    }
    return $credential;
}

sub delete_webauthn_all_credentials {
    my ( $self, $parameter_authenticator ) = @_;
    my $authenticator = $self->_get_webauthn_authenticator(
        authenticator => $parameter_authenticator );
    my $message_id = $self->_new_message_id();
    $self->_send_request(

lib/Firefox/Marionette.pm  view on Meta::CPAN

accepts a hash of the following keys;

=over 4

=item * has_resident_key - boolean value to indicate if the authenticator will support L<client side discoverable credentials|https://www.w3.org/TR/webauthn-2/#client-side-discoverable-credential>

=item * has_user_verification - boolean value to determine if the L<authenticator|https://www.w3.org/TR/webauthn-2/#virtual-authenticators> supports L<user verification|https://www.w3.org/TR/webauthn-2/#user-verification>.

=item * is_user_consenting - boolean value to determine the result of all L<user consent|https://www.w3.org/TR/webauthn-2/#user-consent> L<authorization gestures|https://www.w3.org/TR/webauthn-2/#authorization-gesture>, and by extension, any L<test o...

lib/Firefox/Marionette.pm  view on Meta::CPAN

    $firefox->find_id('input-email')->type($user_name);
    $firefox->find_id('register-button')->click();
    $firefox->await(sub { sleep 1; $firefox->find_class('alert-success'); });
    $firefox->find_id('login-button')->click();
    $firefox->await(sub { sleep 1; $firefox->find_class('hero confetti'); });
    foreach my $credential ($firefox->webauthn_credentials()) {
        $firefox->delete_webauthn_credential($credential);

# ... time passes ...

        $firefox->add_webauthn_credential(

lib/Firefox/Marionette.pm  view on Meta::CPAN

will remove the L<User-Agent|https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent>, L<Accept|https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept> and L<Accept-Encoding|https://developer.mozilla.org/en-US/docs/Web/HTTP/Hea...

This method returns L<itself|Firefox::Marionette> to aid in chaining methods.

=head2 delete_webauthn_all_credentials

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will delete all L<credentials|Firefox::Marionette::WebAuthn::Credential> from this authenticator.  If no parameter is supplied, the defaul...

    my $firefox = Firefox::Marionette->new();
    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    $firefox->delete_webauthn_all_credentials($authenticator);
    $firefox->delete_webauthn_all_credentials();

=head2 delete_webauthn_authenticator

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will delete this authenticator from the current Firefox instance.  If no parameter is supplied, the default authenticator will be deleted.

lib/Firefox/Marionette.pm  view on Meta::CPAN

    use Firefox::Marionette();

    my $firefox = Firefox::Marionette->new();
    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    foreach my $credential ($firefox->webauthn_credentials($authenticator)) {
        $firefox->delete_webauthn_credential($credential, $authenticator);
    }

just a L<credential|Firefox::Marionette::WebAuthn::Credential>, in which case it will remove the credential from the default authenticator.

    use Firefox::Marionette();

    my $firefox = Firefox::Marionette->new();
    ...
    foreach my $credential ($firefox->webauthn_credentials()) {
        $firefox->delete_webauthn_credential($credential);
    }

This method returns L<itself|Firefox::Marionette> to aid in chaining methods.

lib/Firefox/Marionette.pm  view on Meta::CPAN

=head2 webauthn_authenticator

returns the default L<WebAuthn authenticator|Firefox::Marionette::WebAuthn::Authenticator> created when the L<new|/new> method was called.

=head2 webauthn_credentials

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will return all the L<credentials|Firefox::Marionette::WebAuthn::Credential> attached to this authenticator.  If no parameter is supplied,...

    use Firefox::Marionette();
    use v5.10;

    my $firefox = Firefox::Marionette->new();
    foreach my $credential ($firefox->webauthn_credentials()) {
       say "Credential host is " . $credential->host();
    }

    # OR

    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    foreach my $credential ($firefox->webauthn_credentials($authenticator)) {
       say "Credential host is " . $credential->host();
    }

=head2 webauthn_set_user_verified

 view release on metacpan or  search on metacpan

lib/Firefox/Sync/Client.pm  view on Meta::CPAN

    my ($self, $url) = @_;

    # Initialize LWP
    my $ua = LWP::UserAgent->new;
    $ua->agent ("FFsyncClient/0.1 ");
    $ua->credentials ( $self->{'hostname'} . ':' . $self->{'port'}, 'Sync', $self->{'username'} => $self->{'password'} );

    # Do the request
    my $res = $ua->get($url);
    die $res->{'_msg'} if ($res->{'_rc'} != '200');

 view release on metacpan or  search on metacpan

doc/examples/petmarket/petmarket/api/userservice.pm  view on Meta::CPAN

sub methodTable
{
    return {
        "addUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
        "getUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
        "updateUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
    };
    
}

 view release on metacpan or  search on metacpan

lib/Flickr/Upload/FireEagle.pm  view on Meta::CPAN

Aaron Straup Cope <ascope@cpan.org>

=head1 NOTES

Aside from requiring your own Flickr API key, secret and authentication token
you will also need similar FireEagle (OAuth) credentials. Since Flickr::Upload::FireEagle
already requires that you install the excellent I<Net::FireEagle> you should just
use the command line I<fireeagle> client for authorizing yourself with FireEagle.

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

flickr_upload  view on Meta::CPAN

    else {
        die "Unable to initiate OAuth authorization. Response from Flickr was: '$response'\n";
    }
    my $ac_rc = $ua->oauth_access_token(\%request_token);
    if($ac_rc eq 'ok') {
        print "Saving OAuth credentials to $oauth_config\n";
        $ua->export_storable_config($oauth_config);
    }
}

if(!exists $args{'auth_token'} && -r $oauth_config) {
    $ua = Flickr::Upload->import_storable_config($oauth_config);
    bless $ua, 'Flickr::Upload';
}

die "No auth token or OAuth credentials found.\nUse --auth or --oauth to generate credentials or --auth_token to specify a token.\n"
    unless exists $args{'auth_token'} || $ua->is_oauth;

if( $check ) {
	exit( checkToken( $ua, $args{api_key}, $args{auth_token} ) );
}

flickr_upload  view on Meta::CPAN

Authentication token. You B<must> get an authentication token using
C<--auth> before you can upload images. See the L<EXAMPLES> section.

=item --oauth

Interactively perform OAuth authorization with Flickr. The user will get a URL to visit at Flickr at which Flickr::Upload must be granted write permissions. After granting permission, the user will be redirected to a dummy URL that contains an OAuth ...

=item --title <title>

Title to use on all the images. Optional.

flickr_upload  view on Meta::CPAN

Note that options unknown to Flickr will result in undefined behaviour.

=item --check

Checks the authentication token via the flickr.auth.checkToken API call.
This can be used to verify API keys and credentials without trying to
upload an image. The output is the raw results of the API call.

=item --progress, --no-progress

Display a progress bar for each upload with L<Term::ProgressBar>. That

 view release on metacpan or  search on metacpan

lib/Footprintless/Plugin/Ldap/Ldap.pm  view on Meta::CPAN

    my ( $self, $dn, %options ) = @_;
    croak('not connected') unless ( $self->{connection} );

    if ( !$dn ) {

        # binding with instance credentials
        $dn      = $self->{bind_dn};
        %options = %{ $self->{bind_options} };
    }

    if ($dn) {

 view release on metacpan or  search on metacpan

t/Footprintless.t  view on Meta::CPAN

my ($fpl);

ok( $fpl = Footprintless->new(
        config_dirs            => File::Spec->catdir( $test_dir,  'config/entities' ),
        config_properties_file => File::Spec->catfile( $test_dir, 'config/credentials.pl' )
    ),
    'load data/entities'
);

ok( $fpl->entities()->{dev}, 'root is dev' );

 view release on metacpan or  search on metacpan

TODO  view on Meta::CPAN

            t/24e-kill.t does not terminate

    _X_ have a "remote_host" option to go with "cmd" option
        _X_ remote_host => host
        _X_ remote_host => [host, user, pwd]
            to run on a remote server that requires some credentials
        _X_ remote_host => [ \@hosts ]  or  [ \@hosts, user, pwd ]
            to run on any of a cluster of available remote hosts
        _X_ allow a separate MAX_PROC-like setting to be used for
            remote hosts
        ___ remote_host_proto => 'ssh'

 view release on metacpan or  search on metacpan

lib/LWP/UserAgent/FramesReady.pm  view on Meta::CPAN

Get/set the B<$self->{'nomax'}> can be used by the included callback
routine to enforce truncation of received content even if the request
to do so is not honored by the server called for the content.

=item $ua->credent([$credentials])

Get/set the credentials for authentification if called for.

=item $ua->errors()

Get the last error encountered if a return was an undef.  This routine
has only been tested in development so there is no guarantee that it

lib/LWP/UserAgent/FramesReady.pm  view on Meta::CPAN

    }

    return 1;
}

=item $ua->get_basic_credentials()

This routine overloads the LWP::UserAgent::get_basic_credentials in
order to supply authorization if it has been pre-loaded an initial/new
or by use of the $ua->credent() routine.  Supplies a return in a list
context of a UserID and a Password to LWP::UserAgent::credentials().

=cut

sub get_basic_credentials {
    my($self, $realm, $uri) = @_;

    $self->{'errstring'} = '';
    if ($self->{credent}) {
        return split(':', $self->{credent}, 2);

 view release on metacpan or  search on metacpan

lib/FreeMED/Relay.pm  view on Meta::CPAN

	$JSON::QuotApos = 1;
	$JSON::BareKey = 1;
	return $self;
}

sub set_credentials {
	my $self = shift;

	my ( $base_uri, $username, $password ) = @_;
	print "base_uri = $base_uri\n" if $self->{'debug'};
	print "username = $username\n" if $self->{'debug'};

lib/FreeMED/Relay.pm  view on Meta::CPAN

}

sub login {
	my $self = shift;
	if (!defined($self->{username}) or !defined($self->{password})) {
		die "login(): Must set credentials before logging in\n";
	}

	$self->_init() if (!defined($self->{ua}));
	my $login = $self->call(
		'org.freemedsoftware.public.Login.Validate',

lib/FreeMED/Relay.pm  view on Meta::CPAN

Returns a FreeMED::Relay object.

C<new> takes "debug" as a boolean argument.

=item set_credentials ( $base_uri, $username, $password )

Sets the credentials used to access the FreeMED installation in question. The
C<$base_uri> variable should be the base name of the installation, such as
"http://localhost/freemed".

=item login ( )

 view release on metacpan or  search on metacpan

t/100_low/32_proxy_auth.t  view on Meta::CPAN

                    my ( $self, $headers, $request ) = @_;
                    my $auth = $self->proxy->hop_headers->header('Proxy-Authorization') || '';

                    my $request_uri = $request->uri->as_string;
                    my $token = $request_uri =~ m{/escape$} ? $token_escape : $token_simple;
                    # check the credentials
                    if ( $auth ne $token ) {
                        my $response = HTTP::Response->new(407);
                        $response->header( Proxy_Authenticate => 'Basic realm=
        +"HTTP::Proxy"' );
                        $self->proxy->response($response);

 view release on metacpan or  search on metacpan

t/000_env.t  view on Meta::CPAN

## test for presence of our test_environment_variables
if( $ENV{PERLSSH_HOST} ){
	if( $ENV{PERLSSH_USER} ){
		pass("PERLSSH host values seem to be sound." );
	}else{
		fail("do we have ssh credentials via ENV variables? (HOST is required! You can pass ENV vars like this: make test PERLSSH_HOST=example.com PERLSSH_PORT=port PERLSSH_USER=user)" );
		BAIL_OUT('Required ENV VARS declared!');
	}
}else{
	ok(1);
}

 view release on metacpan or  search on metacpan

lib/FusionInventory/Agent/HTTP/Client.pm  view on Meta::CPAN

        # authentication required
        if ($result->code() == 401) {
            if ($self->{user} && $self->{password}) {
                $logger->debug(
                    $log_prefix .
                    "authentication required, submitting credentials"
                );
                # compute authentication parameters
                my $header = $result->header('www-authenticate');
                my ($realm) = $header =~ /^Basic realm="(.*)"/;
                my $host = $url->host();
                my $port = $url->port() ||
                   ($scheme eq 'https' ? 443 : 80);
                $self->{ua}->credentials(
                    "$host:$port",
                    $realm,
                    $self->{user},
                    $self->{password}
                );

lib/FusionInventory/Agent/HTTP/Client.pm  view on Meta::CPAN

                    alarm 0;
                };
                if (!$result->is_success()) {
                    $logger->error(
                        $log_prefix .
                        "authentication required, wrong credentials"
                    );
                }
            } else {
                # abort
                $logger->error(
                    $log_prefix .
                    "authentication required, no credentials available"
                );
            }

        } elsif ($result->code() == 407) {
            $logger->error(
                $log_prefix .
                "proxy authentication required, wrong or no proxy credentials"
            );

        } else {
            # check we request through a proxy
            my $proxyreq = defined $result->request->{proxy};

 view release on metacpan or  search on metacpan

lib/FusqlFS/Backend/Base.pm  view on Meta::CPAN

These methods can be used to control database connection in runtime.
Please use them instead of direct DBH object access via $fusqlh->{dbh},
as they make some more work, than simple database {dis,re}connection.

They use credentials, provided on first backend object initialization
with L</new> method above, so no parameters are required.

C<connect> establish new database connection and reinitializes backend.
Backend reinitialization is required, because some backends make some
query preparation, linked to current database connection.

 view release on metacpan or  search on metacpan

bin/gbrowse_aws_balancer.pl  view on Meta::CPAN

=head1 CONFIGURING AWS CREDENTIALS

To work, the balancer script must be able to make spot instance
requests and to monitor and terminate instances. To perform these
operations the script must have access to the appropriate AWS
credentials (access key and secret key) on the command line or as
environment variables. 

While the script does its best to shield the credentials from prying
eyes, there is still a chance that the credentials can be intercepted
by another party with login access to the machine that the master runs
on and use the credentials to run up your AWS bill. For this reason
some people will prefer to create an EC2 account or role with limited
access to AWS resources.

=over 4

=item 1. Your personal EC2 credentials

You may provide the balancer script with --access_key and --secret_key
command line arguments using your personal EC2 credentials or set the
environment variables EC2_ACCESS_KEY and EC2_SECRET_KEY. If not
provided, the script will interactively prompt for one or both of
these values.

This is the simplest method, but has the risk that if the credentials
are intercepted by a malicious third party, he or she gains access to
all your EC2 resources.

=item 2. The credentials of a restricted IAM account

You may use the Amazon AWS console to create an IAM (Identity Access
and Management) user with restricted permissions, and provide that
user's credentials to the script on the command line or with
environment variables. The following IAM permission policy is the
minimum needed for the balancer script to work properly:

 {
  "Statement": [

bin/gbrowse_aws_balancer.pl  view on Meta::CPAN

    }
  ]
 }

Note that even with these restrictions, an unauthorized user with
access to the credentials could still launch a large number of spot
instances or terminate bona fide instances. This is just a fundamental
limitation of the granularity of EC2's permissions system.

=item 3. Create an IAM role

If the master is running on an EC2 instance, then the most convenient
way to pass credentials is by assigning the instance an IAM role. The
balancer script can then obtain temporary credentials by making
internal EC2 calls. The credentials do not need to be provided on the
command line or in environment variables, and are only valid for short
periods of time, limiting the effect of theft.

First, create an IAM role using the Amazon Console. Select
IAM->Roles->Create New Role, and give the role the name

 view release on metacpan or  search on metacpan

CONTRIBUTING  view on Meta::CPAN

=back

The C<-d> flag uses defaults where they match; you'll only be prompted for
the values that differ.

=item 3. Configure CPAN credentials (repo admin, one-time)

In GitHub, go to B<Settings → Secrets and variables → Actions> and add:

=over 4

 view release on metacpan or  search on metacpan

examples/oauth/generate_offline_credentials.pl  view on Meta::CPAN

# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This utility script demonstrate how to generate offline credentials for
# OAuth2 Installed Applications. The generated refresh token can then be used
# to configure the client library, refer to the OAuth2 section of the
# adwords.properties file. This example is meant to be run from the command line
# and requires user input.
#

examples/oauth/generate_offline_credentials.pl  view on Meta::CPAN

use Google::Ads::AdWords::Client;

use Cwd qw(abs_path);

# Main subroutine.
sub generate_offline_credentials {
  my ($client) = @_;

  my $auth_handler = $client->get_oauth_2_handler();

  print "Please enter your OAuth 2.0 Client ID and Client Secret.\n" .

examples/oauth/generate_offline_credentials.pl  view on Meta::CPAN

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Get AdWords Client, credentials will be read from ~/adwords.properties.
my $client = Google::Ads::AdWords::Client->new();

# Call the example
generate_offline_credentials($client);

 view release on metacpan or  search on metacpan

lib/GRNOC/Config.pm  view on Meta::CPAN

When asking for attributes denoted by '@' it will return only the attribute(s) without the hash

    use GRNOC::Config;

    my $foo = GRNOC::Config->new(config_file => '/etc/grnoc/db.xml', debug => 0, force_array => 0 schema => '/path/to/schema.csd')
    my $db_username = $foo->get("/config/db/credentials");
    print $db_username->{'user'};
    print $db_username->{'password'};

    #just 1 attribute
    my $user = $foo->get("/config/db/credentials[1]/@user");
    my $password = $foo->get("/config/db/credentials[1]/@password");

    #if I have more than 1 result I get an array
    my $hosts = $foo->get("/config/hosts") or die Dumper($foo->get_error());   
    foreach my $host ($hosts){
	print $host->{'hostname'};

lib/GRNOC/Config.pm  view on Meta::CPAN

    ##get errors
    print Dumper($foo->get_errors());

    # I always want an array... even if I only get 1 result
    $foo->{'force_array'} = 1;
    $db_username = $foo->get("/config/db/credentials") or die Dumper($foo->get_error());
    print @{db_username}[0]->{'user'}
    print @{db_username}[0]->{'password'}

   $user = $foo->get("/config/db/credentials[1]/@user") or die Dumper($foo->get_error());
   $password = $foo->get("/config/db/credentials[1]/@password") or die Dumper($foo->get_error());
   $user = @{$user}[0];
   $password = @{$password}[0];
 
   my $valid = $foo->validate();

 view release on metacpan or  search on metacpan

bin/wsutil.pl  view on Meta::CPAN

                  cookies in the file when authenticating to a service and 
                  also save them to this file when done. If not given 
                  cookies are maintained only for the current run.

                  It is probably prudent to make sure that the cookies that 
                  are generated using your own credentials are cleaned up 
                  afterwards or at least not made publicly available.


  -c              service cache file (in case of specifying -S Service Name)
  --servicecache  This file should be in the same format as the grnoc proxy 

 view release on metacpan or  search on metacpan

lib/Game/WordBrain/WordList.pm  view on Meta::CPAN

credensiveness
credent
credential
credentialed
credentialism
credentials
credently
credenza
credenzas
credere
credibilities

 view release on metacpan or  search on metacpan

OPP.pm  view on Meta::CPAN

    return substr($buf,0,$newlen);
}

=head2 joingame

Sends username/password credentials and joins the game. Returns 0 if
the username/password was not accepted.

=cut

sub joingame {

 view release on metacpan or  search on metacpan

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

creation creationism creationisms creationist creationists creations creative
creatively creativeness creativenesses creativities creativity creator
creators creatural creature creaturehood creaturehoods creatureliness
creaturelinesses creaturely creatures creche creches credal credence credences
credenda credendum credent credential credentialed credentialing credentialism
credentialisms credentialled credentialling credentials credenza credenzas
credibilities credibility credible credibly credit creditabilities
creditability creditable creditableness creditablenesses creditably credited
crediting creditor creditors credits creditworthiness creditworthinesses
creditworthy credo credos credulities credulity credulous credulously
credulousness credulousnesses creed creedal creeds creek creeks creel creeled

 view release on metacpan or  search on metacpan

lib/Gantry/Docs/Cookbook.pod  view on Meta::CPAN

tables into an existing database is better for self standing sites.
The samples use a single database, so I'll show that approach first.

There are three essential columns in the user table needed for
authentication: id, user name, and pass word.  The id is for the benifit
of the ORM.  The other fields hold the user's credentials.  The names
of these columns is not fixed by the AuthCookie plugin.  The defaults
are ident and password.  We'll see how to control the names the plugin
uses below.

You are welcome to put additional information in the user rows.  The