Result:
found more than 718 distributions - search limited to the first 2001 files matching your query
( run in 2.753 )
AnyEvent-Radius
view release on metacpan or search on metacpan
lib/AnyEvent/Radius/Client.pm view on Meta::CPAN
if ($h{on_read_raw}) {
# dump raw data
$h{on_read_raw}->($obj, $data, $from);
}
# using authenticator from request to verify reply
my $request_id = $obj->packer()->request_id($data);
# FIXME how to react on unknown request_id ?
my $send_info = delete $obj->send_cache()->{ $request_id };
if (! $send_info ) {
# got unknown reply (with wrong request id?)
lib/AnyEvent/Radius/Client.pm view on Meta::CPAN
type => $type,
av_list => $av_list,
request_id => $request_id,
);
# required to verify reply
$self->send_cache()->{ $req_id } = {
authenticator => $auth,
type => $type,
callback => $cb,
time_cached => AE::now(),
AnyEvent-SMTP
view release on metacpan or search on metacpan
ex/server-restricted.pl view on Meta::CPAN
my $cv = AnyEvent->condvar;
my $server = AnyEvent::SMTP::Server->new( port => 2525 );
sub verify {
my ($s,$con,@args) = @_;
warn "inner event";
my $helo = $con->{helo} = "@args";
# Before replying 250 we check that client truly said us his hostname and that his hostname has reverse lookup.
AnyEvent::DNS::reverse_lookup $con->{host}, sub {
ex/server-restricted.pl view on Meta::CPAN
$server->reg_cb(
ready => sub {
my $s = shift;
warn "Server started on $s->{host}:$s->{port} with hostname $s->{hostname}\n";
},
before_HELO => \&verify, # For event order see L<Object::Event>
before_EHLO => \&verify,
mail => sub {
my ($s,$mail) = @_;
warn "Mail=".Dumper $mail;
},
);
AnyEvent-SSH2
view release on metacpan or search on metacpan
lib/AnyEvent/SSH2.pm view on Meta::CPAN
$dh_server_pub,
$shared_secret);
$ssh->debug("Verifying server signature.");
croak "Key verification failed for server host key"
unless $s_host_key->verify($signature, $hash);
$ssh->session_id($hash);
$kex->derive_keys($hash, $shared_secret, $ssh->session_id);
$cb->($ssh);
AnyEvent-STOMP-Client
view release on metacpan or search on metacpan
lib/AnyEvent/STOMP/Client.pm view on Meta::CPAN
my $tls_ctx = shift;
if (defined $tls_ctx) {
$self->{tls_hash}{tls} = 'connect';
$self->{tls_hash}{tls_ctx} = $tls_ctx;
if ($tls_ctx->{verify}) {
foreach my $key (keys %$tls_ctx) {
if ($key =~ m/_file$/ && not -r $tls_ctx->{$key}) {
die "ERROR: Cannot access $key at $tls_ctx->{$key}.\n";
}
}
AnyEvent-SlackBot
view release on metacpan or search on metacpan
lib/AnyEvent/SlackBot.pm view on Meta::CPAN
sub connect_and_run {
my ($self)=@_;
my $request=POST $self->rtm_start_url,[token=>$self->token];
my $ua=LWP::UserAgent->new;
$ua->ssl_opts(
SSL_verify_mode => IO::Socket::SSL::SSL_VERIFY_NONE,
SSL_hostname => '',
verify_hostname => 0
);
my $response=$ua->request($request);
$self->{timer}=undef;
if($response->code==200) {
my $data=eval { from_json($response->decoded_content) };
AnyEvent-TLS-SNI
view release on metacpan or search on metacpan
lib/AnyEvent/TLS/SNI.pm view on Meta::CPAN
my $cv = AnyEvent->condvar;
$cv->begin;
AnyEvent::HTTP::http_get(
'https://sni.velox.ch/',
tls_ctx => {
verify => 1,
verify_peername => 'https',
host_name => 'sni.velox.ch'
},
sub {
printf "Body length = %d\n", length( shift );
$cv->end;
AnyEvent-Task
view release on metacpan or search on metacpan
lib/AnyEvent/Task.pm view on Meta::CPAN
salt => $salt,
passphrase => $plaintext)
->as_crypt;
},
verify => sub {
my ($crypted, $plaintext) = @_;
return Authen::Passphrase::BlowfishCrypt->from_crypt($crypted)
->match($plaintext);
},
},
lib/AnyEvent/Task.pm view on Meta::CPAN
sub {
my ($checkout, $crypted) = @_;
print "Hashed password is $crypted\n";
$checkout->verify($crypted, 'secret',
sub {
my ($checkout, $result) = @_;
print "Verify result is $result\n";
$cv->send;
});
AnyEvent-Twitter
view release on metacpan or search on metacpan
lib/AnyEvent/Twitter.pm view on Meta::CPAN
my $cv = AE::cv;
# GET request
$cv->begin;
$ua->get('account/verify_credentials', sub {
my ($header, $response, $reason) = @_;
say $response->{screen_name};
$cv->end;
});
# GET request with parameters
$cv->begin;
$ua->get('account/verify_credentials', {
include_entities => 1
}, sub {
my ($header, $response, $reason) = @_;
say $response->{screen_name};
lib/AnyEvent/Twitter.pm view on Meta::CPAN
# verbose and old style
$cv->begin;
$ua->request(
method => 'GET',
api => 'account/verify_credentials',
sub {
my ($hdr, $res, $reason) = @_;
if ($res) {
print "ratelimit-remaining : ", $hdr->{'x-ratelimit-remaining'}, "\n",
AnyEvent-WebSocket-Client
view release on metacpan or search on metacpan
lib/AnyEvent/WebSocket/Client.pm view on Meta::CPAN
is => 'ro',
default => sub { 30 },
);
has ssl_no_verify => (
is => 'ro',
);
has ssl_ca_file => (
lib/AnyEvent/WebSocket/Client.pm view on Meta::CPAN
}
my $hdl = AnyEvent::Handle->new(
fh => $fh,
provided $uri->secure, tls => 'connect',
provided $uri->secure && !$self->ssl_no_verify, peername => $uri->host,
provided $uri->secure && !$self->ssl_no_verify, tls_ctx => {
verify => 1,
verify_peername => "https",
maybe ca_file => $self->ssl_ca_file,
},
on_error => sub {
my ($hdl, $fatal, $msg) = @_;
if($fatal)
lib/AnyEvent/WebSocket/Client.pm view on Meta::CPAN
=head2 timeout
Timeout for the initial connection to the web server. The default
is 30.
=head2 ssl_no_verify
If set to true, then secure WebSockets (those that use SSL/TLS) will
not be verified. The default is false.
=head2 ssl_ca_file
AnyEvent-XMPP
view release on metacpan or search on metacpan
lib/AnyEvent/XMPP/Ext/Receipts.pm view on Meta::CPAN
=head1 DESCRIPTION
This module adds support for XEP-0184 message receipts.
Message receipts provide a way to verify that messages were received by the
recipient, as long as the recipient's client supports it.
Note that you need to send messages with message receipts to full Jabber IDs
(e.g. jabber@example.com/android3948128), not bare Jabber IDs (e.g.
jabber@example.com).
AnyEvent-XSPromises
view release on metacpan or search on metacpan
F<ppport.h> on your source code. See the next section for
details.
=head1 EXAMPLES
To verify whether F<ppport.h> is needed for your module, whether you
should make any changes to your code, and whether any special defines
should be used, F<ppport.h> can be run as a Perl script to check your
source code. Simply say:
perl ppport.h
vmess||5.006000|
vnewSVpvf|5.006000|5.004000|p
vnormal||5.009002|
vnumify||5.009000|
vstringify||5.009000|
vverify||5.009003|
vwarner||5.006000|
vwarn||5.006000|
wait4pid|||
warn_nocontext|||vn
warn_sv||5.013001|
AnyEvent-YACurl
view release on metacpan or search on metacpan
F<ppport.h> on your source code. See the next section for
details.
=head1 EXAMPLES
To verify whether F<ppport.h> is needed for your module, whether you
should make any changes to your code, and whether any special defines
should be used, F<ppport.h> can be run as a Perl script to check your
source code. Simply say:
perl ppport.h
vmess||5.006000|
vnewSVpvf|5.006000|5.004000|p
vnormal||5.009002|
vnumify||5.009000|
vstringify||5.009000|
vverify||5.009003|
vwarner||5.006000|
vwarn||5.006000|
wait4pid|||
warn_nocontext|||vn
warn_sv||5.013001|
AnyEvent-Yubico
view release on metacpan or search on metacpan
lib/AnyEvent/Yubico.pm view on Meta::CPAN
my $class = shift;
my $self = {
sign_request => 1,
local_timeout => 30.0,
urls => [
"https://api.yubico.com/wsapi/2.0/verify",
"https://api2.yubico.com/wsapi/2.0/verify",
"https://api3.yubico.com/wsapi/2.0/verify",
"https://api4.yubico.com/wsapi/2.0/verify",
"https://api5.yubico.com/wsapi/2.0/verify"
]
};
my $options = shift;
lib/AnyEvent/Yubico.pm view on Meta::CPAN
return bless $self, $class;
};
# Verifies the given OTP and returns a true value if the OTP could be
# verified, false otherwise.
sub verify {
return verify_async(@_)->recv->{status} eq 'OK';
}
# Verifies the given OTP and returns a hash containing the server response.
sub verify_sync {
return verify_async(@_)->recv
}
# Non-blocking version of verify_sync, which returns a condition variable
# (see AnyEvent->condvar for details).
sub verify_async {
my($self, $otp, $callback) = @_;
my $nonce = create_UUID_as_string(UUID_V4);
$nonce =~ s/-//g;
lib/AnyEvent/Yubico.pm view on Meta::CPAN
use AnyEvent::Yubico;
$yk = AnyEvent::Yubico->new({ client_id => 4711, api_key => '<your API key here>' });
$result = $yk->verify('<YubiKey OTP here>');
if($result) ...
For more details about the response, instead call verify_sync($otp), which
returns a hash containing all the parameters that were in the response.
$result_details = $yk->verify_sync('<YubiKey OTP here>');
if($result_details->{status} == 'OK') ...
As an alternative, you can call verify_async, which will return a condition
variable immediately. This can be used if your application already uses an
asynchronous model. You can also pass a callback as a second parameter to
verify as well as verify_async, which will be invoked once validation has
completed, with the result.
$result_cv = $yk->verify_async('<YubiKey OTP here>', sub {
#Callback invoked when verification is done
$result_details = shift;
if($result_details->{status} eq 'OK') ...
});
#Wait for the result (blocking, same as calling verify directly).
$result_details = $result_cv->recv;
=head1 DESCRIPTION
Validates a YubiKey OTP (One Time Password) using the YKVAL 2.0 protocol as
lib/AnyEvent/Yubico.pm view on Meta::CPAN
Required. The client ID corresponding to the API key.
=item api_key => $api_key_string
Optional. The API key used to sign requests and verify responses. Without
this response signatures won't be verified.
=item urls => $array_of_urls
Optional. Defines which validation server URLs to query. The default uses
lib/AnyEvent/Yubico.pm view on Meta::CPAN
$yk = AnyEvent::Yubico->new({
client_id => ...,
api_key => ...,
urls => [
"http://example.com/wsapi/2.0/verify",
"http://127.0.0.1/wsapi/2.0/verify"
]
});
=item sign_requests => $enable
lib/AnyEvent/Yubico.pm view on Meta::CPAN
Optional. When enabled, sends the timestamp parameter to the server, causing
YubiKey counter and timestamp information to be returned in the response.
=item local_timeout => $seconds
Optional. Sets the local timeout for how long the verify method will wait
until failing. The default is 30 seconds.
=back
=head1 SEE ALSO
AnyMQ
view release on metacpan or search on metacpan
memory_cycle_ok( $sub, 'no leaks in subscriber' );
memory_cycle_ok( $topic, 'no leaks in publisher' );
# We''re actually relying on the poll_once test, hacky but not sure how to
# verify
$sub->poll(sub { });
memory_cycle_ok( $sub, 'no leaks in subscriber' );
memory_cycle_ok( $topic, 'no leaks in publisher' );
Apache-Admin-Config
view release on metacpan or search on metacpan
t/httpd.conf-dist view on Meta::CPAN
#
# VirtualHost: If you want to maintain multiple domains/hostnames on your
# machine you can setup VirtualHost containers for them.
# Please see the documentation at <URL:http://www.apache.org/docs/vhosts/>
# for further details before you try to setup virtual hosts.
# You may use the command line option '-S' to verify your virtual host
# configuration.
#
# If you want to use name-based virtual hosts you need to define at
# least one IP address (and port number) for them.
Apache-App-Mercury
view release on metacpan or search on metacpan
$controller->sitemark('/messaging');
} elsif ($self->{'state'} eq 'edit_settings' or $args{'edit_mail_prefs'}) {
if ($q->param('add_box')) {
if ($self->verify_new_mailbox($q->param('new_box'))) {
$self->add_new_mailbox($q->param('new_box'));
$self->checkmail;
$q->delete('new_box');
}
} elsif ($q->param('delete_box')) {
$controller->infomsg("You must take action on your existing composition before creating a transaction-related message.")
if ($q->param('reply_trans') or $q->param('compose_trans'));
if ($q->param('preview')) {
my ($fail, $recip, $recip_desc) =
$self->verify_recipient($self->{compose_msg}->{'sent_to'}, 1);
unless ($fail) {
$self->{compose_msg}->{'sent_to'} = $recip;
$self->{compose_msg}->{'recipient_desc'} = $recip_desc;
$self->{'state'} = 'preview_message';
} elsif ($args{'mailto'}) {
if (ref $self->{compose_msg} ne "Apache::App::Mercury::Message") {
$self->reset_compose_message;
my ($fail, $recip, $recip_desc) =
$self->verify_recipient($args{'mailto'}, 1);
unless ($fail) {
$self->{compose_msg}->{'action'} = 'mailto';
$self->{compose_msg}->{'sent_to'} = $recip;
$self->{compose_msg}->{'recipient_desc'} = $recip_desc;
}
sub set_compose_reply {
my ($self, $origmsg) = @_;
my $new = $self->{compose_msg};
my ($fail, $recip, $recip_desc) =
$self->verify_recipient($origmsg->{'sender'}, 1);
return 0 if $fail;
$new->{'action'} = 'reply';
$new->{'subject'} = "Re: ".$origmsg->{'subject'};
$new->{'sent_to'} = $recip;
$new->{'Attachments'} = dclone $origmsg->{'Attachments'}
if ref $origmsg->{'Attachments'} eq "ARRAY";
}
sub verify_recipient {
my ($self, $recip, $show_fail_message) = @_;
my $q = $self->{q};
my $controller = $self->{controller};
# remove all whitespace (user_names can't have any)
$recip =~ s/\s//g;
$self->warn("->verify_recipient: checking '$recip'.");
if (!$recip) {
$controller->infomsg("You must enter a recipient.") if $show_fail_message;
return ('fail', undef, undef);
} elsif ($recip eq $self->{user_manager}->userprofile('user')) {
return (0, $self->{user_manager}->userprofile('user'),
} else {
$self->{controller}->infomsg("There was an error ".(!$is_memo ? "sending your message" : "committing your memo").". Please contact technical support.");
}
}
sub verify_new_mailbox {
my ($self, $new_box) = @_;
my $controller = $self->{controller};
# make sure there is a new_box
if (!$new_box) {
Apache-Auth-UserDB
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.55.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
Apache-AuthCookie
view release on metacpan or search on metacpan
lib/Apache/AuthCookie.pm view on Meta::CPAN
credentials. The credentials are posted to the server where AuthCookie
verifies them and returns a session key.
The session key is returned to the user's browser as a cookie. As a
cookie, the browser will pass the session key on every subsequent
accesses. AuthCookie will verify the session key and re-authenticate
the user.
All you have to do is write a custom module that inherits from
AuthCookie. Your module is a class which implements two methods:
lib/Apache/AuthCookie.pm view on Meta::CPAN
requires user programmør
=head1 ABOUT SESSION KEYS
Unlike the sample AuthCookieHandler, you have you verify the user's
login and password in C<authen_cred()>, then you do something
like:
my $date = localtime;
my $ses_key = MD5->hexhash(join(';', $date, $PID, $PAC));
Apache-AuthCookieDBIRadius
view release on metacpan or search on metacpan
AuthCookie.pm view on Meta::CPAN
credentials. The credentials are posted to the server where AuthCookie
verifies them and returns a session key.
The session key is returned to the user's browser as a cookie. As a
cookie, the browser will pass the session key on every subsequent
accesses. AuthCookie will verify the session key and re-authenticate
the user.
All you have to do is write a custom module that inherits from
AuthCookie. Your module is a class which implements two methods:
AuthCookie.pm view on Meta::CPAN
server-side login information too. AuthCookie doesn't do this for
you, you have to handle it yourself.
=head1 ABOUT SESSION KEYS
Unlike the sample AuthCookieHandler, you have you verify the user's
login and password in C<authen_cred()>, then you do something
like:
my $date = localtime;
my $ses_key = MD5->hexhash(join(';', $date, $PID, $PAC));
Apache-AuthNetLDAP
view release on metacpan or search on metacpan
AuthNetLDAP.pm view on Meta::CPAN
my $ldap = new Net::LDAP($ldapserver, port => $ldapport);
if (lc $start_TLS eq 'yes')
{
$ldap->start_tls(verify => 'none')
or MP2 ? $r->log_error( "Unable to start_tls", $r->uri)
: $r->log_reason("Unable to start_tls", $r->uri);
}
my $mesg;
Apache-AuthTicket
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.80.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
Apache-AuthTypeKey
view release on metacpan or search on metacpan
lib/Apache/AuthTypeKey.pm view on Meta::CPAN
my $tk = Authen::TypeKey->new;
$tk->token($token);
$tk->version(1.1);
my $key = $r->args;
my $q = Apache::AuthTypeKey::Query->new($key);
my $res = $tk->verify($q);
unless ($res) {
$r->log_error('TypeKey verification failed: ' . $tk->errstr);
}
$q->delete('destination');
$res ? $q->as_string : undef;
lib/Apache/AuthTypeKey.pm view on Meta::CPAN
$tk->token($token);
$tk->version(1.1);
## When checking the validity of the session key, we need to skip the
## expiration check on the signature.
$tk->skip_expiry_check(1);
my $res = $tk->verify(Apache::AuthTypeKey::Query->new($key));
$res ? $res->{name} : undef;
}
## This is needed for 2 reasons:
## 1. Authen::TypeKey currently expects a Query-type object.
Apache-Authen-Generic
view release on metacpan or search on metacpan
configuration file with the PerlSetVar directive.
=head3 generic_auth_cipher_key
This is the encryption key used for encrypting the cookies used
to verify authentication. It must be 32 bytes (256-bit). The
encryption used is AES-256 and uses an SHA1 digest to verify
data integrity.
=head3 generic_auth_failed_url
This is the url users are be redirected to if they have not been
is useful for allowing the user to access the login page and to
allow access to other public pages.
=head3 generic_auth_cookie_name
This is the name of the cookie that will be used to verify
authentication. This must match the name passed to the
generateAuthCookie() method when using a CGI script for the
login process.
=head3 generic_auth_ref_url_var
Apache-Authen-Program
view release on metacpan or search on metacpan
examples/filelogon view on Meta::CPAN
|| die "FAILURE: can't close password file '$passfile' because: $!\n";
if (!defined($password) || $password =~ m/^\s*$/) {
die "FAILURE: missing or empty password\n";
}
# ------ verify username/password
if ($username eq "fred" && $password eq "Scooby-Do!2002") {
print "OK: File login succeeded.\n";
} else {
print "FAILURE: bad username or password.\n";
}
Apache-AuthenNIS
view release on metacpan or search on metacpan
AuthenNIS.pm view on Meta::CPAN
adaptation (i.e. I modified the code) of Michael Parker's
(B<parker@austx.tandem.com>) Apache::AuthenSmb module.
The module uses Net::NIS::yp_match to retrieve the "passwd" entry from the
passwd.byname map, using the supplied username as the search key. It then
uses crypt() to verify that the supplied password matches the retrieved
hashed password.
= head2 Apache::AuthenNIS vs. Apache::AuthzNIS
I've taken "authentication" to be meaningful only in terms of a user and
Apache-AuthenNTLM
view release on metacpan or search on metacpan
AuthenNTLM.pm view on Meta::CPAN
};
}
$self -> {smbhandle} = Authen::Smb::Valid_User_Connect ($pdc, $bdc, $domain, $nonce) ;
print STDERR "[$$] AuthenNTLM: verify handle $self->{username} smbhandle == $self->{smbhandle} \n" if ($debug) ;
if (!$self -> {smbhandle})
{
MP2 ? $r->log_error("Connect to SMB Server failed (pdc = $pdc bdc = $bdc domain = $domain error = "
. Authen::Smb::SMBlib_errno . '/' . Authen::Smb::SMBlib_SMB_Error . ") for " .
AuthenNTLM.pm view on Meta::CPAN
return $self -> {nonce} = $nonce ;
}
sub verify_user
{
my ($self, $r) = @_ ;
if (!$self -> {smbhandle})
AuthenNTLM.pm view on Meta::CPAN
my $header1 = $self -> set_msg2 ($r, $nonce) ;
my $hdr = $r -> err_headers_out ;
$hdr -> add ($r->proxyreq ? 'Proxy-Authenticate' : 'WWW-Authenticate', $header1) if ($self -> {authntlm}) ;
# $r->discard_request_body ;
print STDERR "[$$] AuthenNTLM: verify handle = 1 smbhandle == $self->{smbhandle} \n" if ($debug) ;
return MP2 ? Apache::HTTP_UNAUTHORIZED : Apache::Constants::HTTP_UNAUTHORIZED ;
}
elsif ($type == 3)
{
print STDERR "[$$] handler type == 3 \n" if ($debug) ;
print STDERR "[$$] AuthenNTLM: verify handle = 3 smbhandle == $self->{smbhandle} \n" if ($debug) ;
if ( !$self->verify_user( $r ) )
{
if ( $self->{ntlmauthoritative} )
{
my $hdr = $r -> err_headers_out ;
$hdr -> add ($r->proxyreq ? 'Proxy-Authenticate' : 'WWW-Authenticate', 'NTLM') if ($self -> {authntlm}) ;
AuthenNTLM.pm view on Meta::CPAN
$self -> {lock} = undef ; # reset lock in case anything has gone wrong
MP2 ? $r->log_error("Cannot get nonce for " . $r->uri) : $r->log_reason("Cannot get nonce for " . $r->uri) ;
return MP2 ? Apache::HTTP_INTERNAL_SERVER_ERROR : Apache::Constants::HTTP_INTERNAL_SERVER_ERROR ;
}
if (!$self -> verify_user ($r))
{
if ($self -> {basicauthoritative})
{
my $hdr = $r -> err_headers_out ;
$hdr -> add ($r->proxyreq ? 'Proxy-Authenticate' :'WWW-Authenticate', 'Basic realm="'
AuthenNTLM.pm view on Meta::CPAN
The NTLM protocol performs a challenge/response to exchange a random number
(nonce) and get back a md4 hash, which is built from the user's password
and the nonce. This makes sure that no password goes over the wire in plain text.
The main advantage of the Perl implementation is, that it can be easily extended
to verify the user/password against other sources than a windows domain controller.
The defaultf implementation is to go to the domain controller for the given domain
and verify the user. If you want to verify the user against another source, you
can inherit from Apache::AuthenNTLM and override it's methods.
To support users that aren't using Internet Explorer, Apache::AuthenNTLM can
also perform basic authentication depending on its configuration.
AuthenNTLM.pm view on Meta::CPAN
=head2 PerlSetVar ntlmauthoritative
Setting the ntlmauthoritative directive explicitly to 'off' allows authentication
to be passed on to lower level modules if AuthenNTLM cannot authenticate the user
and the NTLM authentication scheme is used.
If set to 'on', which is the default, AuthenNTLM will try to verify the user and,
if it fails, will give an Authorization Required reply.
=head2 PerlSetVar basicauthoritative
Setting the ntlmauthoritative directive explicitly to 'off' allows authentication
to be passed on to lower level modules if AuthenNTLM cannot authenticate the user
and the Basic authentication scheme is used.
If set to 'on', which is the default, AuthenNTLM will try to verify the user and
if it fails will give an Authorization Required reply.
=head2 PerlSetVar ntlmsemkey
There are troubles when two authentication requests take place at the same
AuthenNTLM.pm view on Meta::CPAN
Will be called to setup the connection to the windows domain controller
for $self -> {domain} and retrieve the nonce.
In case you do not authenticate against a windows machine, you simply need
to set $self -> {nonce} to a 8 byte random string. Returns undef on error.
=head2 $self -> verify_user ($r)
Should verify that the given user supplied the right credentials. Input:
=over
=item $self -> {basic}
Apache-AuthenPasswd
view release on metacpan or search on metacpan
AuthenPasswd.pm view on Meta::CPAN
adaptation (i.e. I modified the code) of Michael Parker's
(B<parker@austx.tandem.com>) Apache::AuthenSmb module.
The module uses getpwnam to retrieve the B<passwd> entry from the
B</etc/passwd> file, using the supplied username as the search key. It
then uses B<crypt()> to verify that the supplied password matches the
retrieved hashed password.
= head2 Apache::AuthenPasswd vs. Apache::AuthzPasswd
I've taken "authentication" to be meaningful only in terms of a user and
Apache-AuthenProgram
view release on metacpan or search on metacpan
examples/filelogon view on Meta::CPAN
|| die "FAILURE: can't close password file '$passfile' because: $!\n";
if (!defined($password) || $password =~ m/^\s*$/) {
die "FAILURE: missing or empty password\n";
}
# ------ verify username/password
if ($username eq "fred" && $password eq "Scooby-Do!2002") {
print "OK: File login succeeded.\n";
} else {
print "FAILURE: bad username or password.\n";
}
Apache-AuthenSecurID
view release on metacpan or search on metacpan
Auth/Auth.pm view on Meta::CPAN
=item *
AuthUserCookie
The name of the of cookie that contains the value of the persons username
in plain text. This is checked against the contents of the encrypted cookie
to verify user. The cookie is set of other applications can identify
authorized users. It defaults to F<SecurID_User> if this variable is not set.
=item *
AuthCookiePath
Apache-AxKit-Provider-File-Formatter
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.38.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It would check each file's integrity, as well as the signature's
( run in 2.753 seconds using v1.01-cache-2.11-cpan-5467b0d2c73 )