Result:
found more than 673 distributions - search limited to the first 2001 files matching your query
( run in 0.894 )
AnyEvent-MP
view release on metacpan or search on metacpan
MP/Transport.pm view on Meta::CPAN
if (exists $config->{cert}) {
$self->{tls_ctx} = {
sslv2 => 0,
sslv3 => 0,
tlsv1 => 1,
verify => 1,
cert => $config->{cert},
ca_cert => $config->{cert},
verify_require_client_cert => 1,
};
}
$self->{hdl} = new AnyEvent::Handle
+($self->{fh} ? (fh => $self->{fh}) : (connect => $self->{connect})),
AnyEvent-Net-Curl-Queued
view release on metacpan or search on metacpan
- use AE::postpone instead of "instant timer" hack (Stanislaw Pusep)
0.026 2012-09-05T21:24:33
- updated t/42-loopback-retry.t to use internal POST retry mechanism
(Stanislaw Pusep)
- attempt double GET at t/30-queued-single.t (to verify queue
deduplication) (Stanislaw Pusep)
- stripped dead code from AE::N::C::Q::Stats (Stanislaw Pusep)
- fixed AE::N::C::Const cache typo (Stanislaw Pusep)
- split queue accessors POD (Stanislaw Pusep)
- correctly reenqueue POST requests (Stanislaw Pusep)
AnyEvent-Porttracker
view release on metacpan or search on metacpan
Porttracker.pm view on Meta::CPAN
Enables or disables TLS (default: disables). When enabled, then the
connection will try to handshake a TLS connection before logging in. If
unsuccessful a fatal error will be raised.
Since most Porttracker/PortIQ boxes will not have a sensible/verifiable
certificate, no attempt at verifying it will be done (which means
man-in-the-middle-attacks will be trivial). If you want some form of
verification you need to provide your own C<tls_ctx> object with C<<
verify => 1, verify_peername => [1, 1, 1] >> or whatever verification mode
you wish to use.
=item tls_ctx => $tls_ctx
The L<AnyEvent::TLS> object to use. See C<tls>, above.
AnyEvent-Proc
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.73.
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
AnyEvent-RabbitMQ
view release on metacpan or search on metacpan
share/fixed_amqp0-8.xml view on Meta::CPAN
full separation of exchanges, queues, and all associated entities
per virtual host. An application, connected to a specific virtual
host, MUST NOT be able to access resources of another virtual host.
</rule>
<rule implement="SHOULD">
The server SHOULD verify that the client has permission to access
the specified virtual host.
</rule>
<rule implement="MAY">
The server MAY configure arbitrary limits per virtual host, such
as the number of each type of entity that may be used, per
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
( run in 0.894 second using v1.01-cache-2.11-cpan-39bf76dae61 )