view release on metacpan or search on metacpan
lib/AsposeCellsCloud/ApiClient.pm view on Meta::CPAN
my $difference_in_seconds=time() - $self->{get_access_token_time};
if($difference_in_seconds < 86300){
return;
}
}
my $access_token = $self->o_auth_post('grant_type' => "client_credentials", 'client_id' => $self->{config}->{client_id}, 'client_secret' =>$self->{config}->{client_secret})->access_token;
$self->{config}->{access_token} = $access_token;
}
# make the HTTP request
# @param string $resourcePath path to method endpoint
view release on metacpan or search on metacpan
lib/AsposeDiagramCloud/DiagramApi.pm view on Meta::CPAN
$api_client = $_[0];
} else {
$api_client = AsposeDiagramCloud::ApiClient->new(@_);
}
my $access_token = $api_client->o_auth_post('grant_type' => "client_credentials", 'client_id' => $api_client->{config}->{app_sid}, 'client_secret' =>$api_client->{config}->{app_key})->access_token;
$api_client->{config}->{access_token} = $access_token;
my $base_url = $api_client->{config}->{base_url};
if( substr( $base_url,length($base_url)-1,1) eq '/'){
$base_url = $base_url . $api_client->{config}->{api_version};
view release on metacpan or search on metacpan
lib/AsposeSlidesCloud/ApiClient.pm view on Meta::CPAN
# @param array $headerParams header parameters (by ref)
sub update_params_for_auth {
my ($self, $header_params) = @_;
if ((defined $self->{config}{app_sid} && $self->{config}{app_sid} ne "") && (!defined $self->{config}{access_token} || $self->{config}{access_token} eq "")) {
my $_url = $self->{config}{auth_base_url} . "/connect/token";
my $_request = POST($_url, {}, Content => 'grant_type=client_credentials&client_id='.$self->{config}{app_sid}.'&client_secret='.$self->{config}{app_key});
my $_response = $self->{ua}->request($_request);
unless ($_response->is_success) {
my $content = sprintf("%s", $_response->content);
croak(sprintf "API Exception(%s): %s\n%s", 401, $_response->message, $content);
}
view release on metacpan or search on metacpan
share/lexicons/com/atproto/identity/getRecommendedDidCredentials.json view on Meta::CPAN
"lexicon": 1,
"id": "com.atproto.identity.getRecommendedDidCredentials",
"defs": {
"main": {
"type": "query",
"description": "Describe the credentials that should be included in the DID doc of an account that is migrating to this service.",
"output": {
"encoding": "application/json",
"schema": {
"type": "object",
"properties": {
view release on metacpan or search on metacpan
lib/Auth/ActiveDirectory.pm view on Meta::CPAN
use warnings FATAL => 'all';
use Net::LDAP qw[];
use Net::LDAP::Constant qw[LDAP_INVALID_CREDENTIALS];
my $ErrorCodes = {
'525' => { error => 'user not found' },
'52e' => { error => 'invalid credentials' },
'530' => { error => 'not permitted to logon at this time' },
'531' => { error => 'not permitted to logon at this workstation' },
'532' => { error => 'password expired' },
'533' => { error => 'data 533' },
'701' => { error => 'account expired' },
view release on metacpan or search on metacpan
lib/Authen/CAS/External.pm view on Meta::CPAN
# Return the last response
return $self->previous_response;
}
sub get_cas_credentials {
my ($self, $service) = @_;
# This default callback stub simply returns the stored
# credentials
if (!$self->has_username) {
confess 'Unable to authenticate because no username was provided';
}
if (!$self->has_password) {
lib/Authen/CAS/External.pm view on Meta::CPAN
# Splice out the variables
my ($username, $service) = @args{qw(username service)};
# This default callback stub simply returns the stored
# credentials
if (!$self->has_ticket_granting_cookie) {
return;
}
# Return ticket granting ticket
lib/Authen/CAS/External.pm view on Meta::CPAN
This is a string that specifies the service value to send to the CAS server.
The default is to not send any service parameter.
=back
=head2 get_cas_credentials
This method is not actually used, but is required for classes to consume the
L<Authen::CAS::External::UserAgent|Authen::CAS::External::UserAgent> role as
this class does. This method will return the currently set username and
password to the user agent.
view release on metacpan or search on metacpan
t/01-tests.t view on Meta::CPAN
htusers => "t/htusers",
htgroups => "t/htgroups",
)};
ok($atest->can("check"), "load auth files");
ok($atest->check("ryan", "fuckface"), "valid credentials check");
ok(!$atest->check("ryan", "ilikecheese"), "invalid credentials check");
ok($atest->check(qw/ryan fuckface/, groups => [
[One => qw/admin users/],
qw/middleclass american/, ]),
"valid groups check");
ok($atest->groupcheck("ryan", groups => [
view release on metacpan or search on metacpan
lib/Authen/Credential.pm view on Meta::CPAN
$req = HTTP::Request->new(GET => $url);
$req->header(Authorization => $cred->prepare("HTTP.Basic"));
=head1 DESCRIPTION
This module offers abstractions of credentials, i.e. something that
can be used to authenticate. It allows the creation and manipulation of
credentials. In particular, it defines a standard string representation
(so that credentials can be given to external programs as command line
options), a standard structured representation (so that credentials can
be stored in structured configuration files or using JSON) and
"preparators" that can transform credentials into ready-to-use data for
well known targets.
Different authentication schemes (aka credential types) are supported.
This package currently supports C<none>, C<plain> and C<x509> but others
can be added by providing the supporting code in a separate module.
A Python implementation of the same credential abstractions is available
at L<https://github.com/cern-mig/python-auth-credential> so credentials
can be shared between different programming languages.
For a given scheme, a credential is represented by an object with a
fixed set of string attributes. For instance, the C<plain> scheme has
two attributes: C<name> and C<pass>. More information is provided by
view release on metacpan or search on metacpan
the configuration from the Kerberos 5 profile (F</etc/krb5.conf> by
default).
=item * $kadm5 = Authen::Krb5::Admin->init_with_creds($client, $krb5_ccache[, $service, $kadm5_config])
Authenticate using the credentials cached in $krb5_ccache.
=item * $kadm5 = Authen::Krb5::Admin->init_with_password($client[, $password, $service, $kadm5_config])
Authenticate with $password.
view release on metacpan or search on metacpan
This uses the keytab file specified in $keytab and uses it to acquire a ticket granting ticket for $principle. This is functionally equivalent to system("kinit -k -t $keytab $principle"), but is done directly through the kerberos libraries.
=item kdestroy()
Erases all credentials in the ticket file.
=item kerror()
returns an error string ended with a "\n" that describes what error happened.
view release on metacpan or search on metacpan
lib/Authen/Krb5/Simple.pm view on Meta::CPAN
to allow perl scripts to perform authentication against a Microsoft Active
Directory (AD) server configured to accept Kerberos client requests.
B<It is important to note:> This module only performs simple authentication.
It does not get, grant, use, or retain any kerberos tickets. It will check
user credentials against the Kerberos server (as configured on the local
system) each time the I<authenticate> method is called.
=head1 CONSTRUCTOR
B<new>
view release on metacpan or search on metacpan
lib/Authen/Krb5.pm view on Meta::CPAN
Type can be one of the following: NT_UNKNOWN, NT_PRINCIPAL, NT_SRV_INST,
NT_SRV_HST, NT_SRV_XHST, NT_UID. See the Kerberos documentation for details.
=head2 C<cc_resolve(name)>
Returns a credentials cache identifier which corresponds to the given name.
'name' must be in the form TYPE:RESIDUAL. See the Kerberos documentation
for more information.
=head2 C<cc_default_name()>
Returns the name of the default credentials cache, which may be equivalent
to KRB5CCACHE.
=head2 C<cc_default()>
Returns a L<Authen::Krb5::Ccache> object representing the default credentials
cache.
=head2 C<kt_resolve(name)>
Returns a L<Authen::Krb5::Keytab> object representing the specified keytab name.
lib/Authen/Krb5.pm view on Meta::CPAN
Attempt to get an initial ticket for the client. 'client' is a principal
object for which you want an initial ticket. 'server' is a principal object
for the service (usually C<krbtgt/REALM@REALM>). 'password' is the password
for the client, and 'cc' is a L<Authen::Krb5::Ccache> object representing the
current credentials cache. Returns a Kerberos error code.
Although this interface is deprecated in the Kerberos C libraries, it's
supported in the Perl module. In this module, it's implemented in terms of
C<krb5_get_init_creds_password>, L<krb5_cc_initialize>, and L<krb5_cc_store_cred>.
lib/Authen/Krb5.pm view on Meta::CPAN
Obtain an initial ticket for the client using a keytab. 'client' is a
principal object for which you want an initial ticket. 'server' is a
principal object for the service (usually C<krbtgt/REALM@REALM>). 'keytab' is
a keytab object createed with kt_resolve. 'cc' is a L<Authen::Krb5::Ccache>
object representing the current credentials cache. Returns a Kerberos error
code.
Although this interface is deprecated in the Kerberos C libraries, it's
supported in the Perl module. In this module, it's implemented in terms of
L<krb5_get_init_creds_keytab>, L<krb5_cc_initialize>, and L<krb5_cc_store_cred>.
lib/Authen/Krb5.pm view on Meta::CPAN
suitable for passing to rd_req. 'auth_context' is the L<Authen::Krb5::AuthContext>
object you want to use for this connection, 'ap_req_options' is an OR'ed
representation of the possible options (see Kerberos docs), 'service' is
the name of the service for which you want a ticket (like 'host'), hostname
is the hostname of the server, 'in' can be any user-specified data that can
be verified at the server end, and 'cc' is your credentials cache object.
=head2 C<rd_req(auth_context,in,server,keytab)>
Parses a C<KRB_AP_REQ> message and returns its contents in a L<Authen::Krb5::Ticket>
object. 'auth_context' is the connection's L<Authen::Krb5::AuthContext> object,
lib/Authen/Krb5.pm view on Meta::CPAN
principal to which you are authenticating, e.g. C<service.hostname@REALM>.
The only useful option right now is C<AP_OPTS_MUTUAL_REQUIRED>, which forces
sendauth to perform mutual authentication with the server. 'in' is a string
that will be received by recvauth and verified by the server--it's up to the
application. 'in_creds' is not yet supported, so just use 'undef' here. 'cc'
should be set to the current credentials cache. sendauth returns true
on success and undefined on failure.
=head2 C<recvauth(auth_context,fh,version,server,keytab)>
Receives authentication data from a client using the sendauth function through
view release on metacpan or search on metacpan
Krb5Password.pm view on Meta::CPAN
use the Kerberos protocol directly. If it must be run on a system that
receives a username and password over the network, steps should be
taken to ensure that these are passed to the server in a cryptographically
secure manner.
kpass() attempts to obtain credentials for the given username and password
from the Kerberos AS, then obtain credentials for a local service from the
Kerberos TGS to verify the authenticity of the AS response. Empty strings
can be passed as the 3rd and/or 4th arguments to use the default service
name ("host") and the fully canonicalized primary hostname of the system
that the function is executed on. The fifth argument may be omitted to use
the system's default keytab file.
view release on metacpan or search on metacpan
lib/Authen/NTLM/HTTP.pm view on Meta::CPAN
| Authen::NTLM::NTLMSSP_NEGOTIATE_UNICODE
| Authen::NTLM::NTLMSSP_REQUEST_TARGET;
$auth_msg = $client->http_auth($nonce, $flags);
# Stage 6 Scenario: Finally the server parses the reply
# verify the authentication credentials.
# To parse a NTLM Response Packet
($flags, $lm_resp, $nt_resp, $user_domain, $username, $machine) =
$server->http_parse_auth($auth_msg);
view release on metacpan or search on metacpan
lib/Authen/Passphrase/SaltedSHA512.pm view on Meta::CPAN
to generate a good salt.
The hashing algorithm chosen is the SHA-512 hash function from the SHA-2
family. Currently SHA-512 is a leading edge standard in strong hashing.
The salt generated when creating authentication credentials is a 512 bit
random string. The random number generating algorithm used comes from
L<Bytes::Random::Secure|http://search.cpan.org/perldoc?Bytes::Random::Secure>.
That module uses Math::Random::ISAAC, "I<...a cryptographically-strong random
number generator with no known serious weaknesses.>" Bytes::Random::Secure
obtains its seed using Crypt::Random::Seed. The reason that
view release on metacpan or search on metacpan
examples/authen_prompt_all.pl view on Meta::CPAN
use warnings;
use Authen::Prepare 0.04;
use Smart::Comments;
# Prompt for everything
my %auth = Authen::Prepare->new->credentials();
### %auth
view release on metacpan or search on metacpan
lib/Authen/SASL/Perl/DIGEST_MD5.pm view on Meta::CPAN
my $final_response = _response(\%response);
$cb->($final_response);
return;
}
sub client_step { # $self, $server_sasl_credentials
my ($self, $challenge) = @_;
$self->{server_params} = \my %sparams;
# Parse response parameters
$self->_parse_challenge(\$challenge, server => $self->{server_params})
view release on metacpan or search on metacpan
lib/Authen/SCRAM.pm view on Meta::CPAN
};
### SERVER SIDE ###
$server = Authen::SCRAM::Server->new(
credential_cb => \&get_credentials,
);
$username = try {
# get client-first-message
view release on metacpan or search on metacpan
lib/Authen/Simple/CDBI.pm view on Meta::CPAN
return 0;
}
unless ( $self->check_password( $password, $encrypted ) ) {
$self->log->debug( qq/Failed to authenticate user '$username'. Reason: 'Invalid credentials'/ )
if $self->log;
return 0;
}
view release on metacpan or search on metacpan
lib/Authen/Simple/DBI.pm view on Meta::CPAN
return 0;
}
unless ( $self->check_password( $password, $encrypted ) ) {
$self->log->debug( qq/Failed to authenticate user '$username'. Reason: 'Invalid credentials'/ )
if $self->log;
return 0;
}
view release on metacpan or search on metacpan
lib/Authen/Simple/DBM.pm view on Meta::CPAN
return 0;
}
unless ( $self->check_password( $password, $encrypted ) ) {
$self->log->debug( qq/Failed to authenticate user '$username'. Reason: 'Invalid credentials'/ )
if $self->log;
return 0;
}
view release on metacpan or search on metacpan
t/00.load.t view on Meta::CPAN
skip 'Please specify a valid username and password (in that order on a line by itself) in .gmail.test.config', 2 unless $username && $password;
SKIP: {
skip 'These tests require connectivity to pop.gmail.com over port 995.', 2 unless detect_net( 'pop.gmail.com', 995 );
ok( $gmail_auth->authenticate( $username, $password ), 'authenticate() valid credentials return true' );
ok( !$gmail_auth->authenticate( $username, $password . $$ . time ), 'authenticate() invalid credentials return false' );
}
}
view release on metacpan or search on metacpan
lib/Authen/Simple/HTTP.pm view on Meta::CPAN
# This implementation is very hackish, however I could not find a cleaner
# way to implement this without forking a lot of code from LWP::UserAgent.
# Please let me know if you have any ideas of improvements.
my $override = sprintf '%s::get_basic_credentials', ref $self->agent;
my $response = undef;
my $url = $self->url;
# First make sure we receive a challenge
lib/Authen/Simple/HTTP.pm view on Meta::CPAN
if $self->log;
return 0;
}
# We have a challenge, issue a new request with credentials.
{
no strict 'refs';
no warnings 'redefine';
lib/Authen/Simple/HTTP.pm view on Meta::CPAN
$response = $self->agent->head($url);
}
if ( $response->code == 401 ) {
$self->log->debug( qq/Failed to authenticate user '$username' using url '$url'. Reason: 'Invalid credentials'/ )
if $self->log;
return 0;
}
view release on metacpan or search on metacpan
lib/Authen/Simple/LDAP.pm view on Meta::CPAN
if $self->log;
return 0;
}
my ( @credentials, $message, $search, $entry, $filter, $dn );
@credentials = $self->binddn ? ( $self->binddn, password => $self->bindpw ) : ();
$message = $connection->bind(@credentials);
if ( $message->is_error ) {
my $error = $message->error;
my $binddn = $self->binddn;
lib/Authen/Simple/LDAP.pm view on Meta::CPAN
binddn => 'uid=proxy,cn=users,dc=company,dc=com'
=item * bindpw
The credentials to bind with.
bindpw => 'secret'
=item * basedn
view release on metacpan or search on metacpan
lib/Authen/Simple/NIS.pm view on Meta::CPAN
my $encrypted = ( split( /:/, $entry ) )[1];
unless ( $self->check_password( $password, $encrypted ) ) {
$self->log->debug( qq/Failed to authenticate user '$username'. Reason: 'Invalid credentials'/ )
if $self->log;
return 0;
}
view release on metacpan or search on metacpan
lib/Authen/Simple/Passwd.pm view on Meta::CPAN
next if /^#/;
next if /^\s+/;
chop;
my (@credentials) = split( /:/, $_, 3 );
if ( $credentials[0] eq $username ) {
$encrypted = $credentials[1];
$self->log->debug( qq/Found user '$username' in passwd '$path'./ )
if $self->log;
last;
lib/Authen/Simple/Passwd.pm view on Meta::CPAN
return 0;
}
unless ( $self->check_password( $password, $encrypted ) ) {
$self->log->debug( qq/Failed to authenticate user '$username'. Reason: 'Invalid credentials'/ )
if $self->log;
return 0;
}
view release on metacpan or search on metacpan
lib/Authen/Simple/SMB.pm view on Meta::CPAN
$self->log->error( qq/Failed to authenticate user '$username' using domain '$domain'. Reason: 'Received a Protocol Error'/ )
if $self->log;
}
if ( $status == 3 ) { # NTV_LOGON_ERROR
$self->log->debug( qq/Failed to authenticate user '$username' using domain '$domain'. Reason: 'Invalid credentials'/ )
if $self->log;
}
return 0;
}
view release on metacpan or search on metacpan
lib/Authen/Simple/Twitter.pm view on Meta::CPAN
=cut
sub check {
my ( $self, $username, $password ) = @_;
$self->net_twitter->credentials(
$username, $password,
$self->net_twitter->{apihost},
$self->net_twitter->{apirealm}
);
if ( my $response = $self->net_twitter->verify_credentials() ) {
$self->log->debug(qq/Successfully authenticated user '$username'./)
if $self->log;
return 1;
view release on metacpan or search on metacpan
examples/ex1.pl view on Meta::CPAN
my $webform = Authen::Simple::WebForm->new(
'log' => $log,
initial_url => 'http://freshmeat.net/session/new?return_to=/',
login_url => 'http://freshmeat.net/session',
login_expect => 'href="/logout"',
login_expect_cookie => 'user_credentials',
username_field => 'user_session[login]',
password_field => 'user_session[password]',
extra_fields => [
'commit' => 'Log in!',
'user_session[remember_me]' => 0,
view release on metacpan or search on metacpan
lib/Authen/Simple/Adapter.pm view on Meta::CPAN
if $self->log;
return 1;
}
$self->log->debug( qq/Failed to authenticate user '$username'. Reason: 'Invalid credentials'/ )
if $self->log;
return 0;
}