Result:
found more than 615 distributions - search limited to the first 2001 files matching your query
( run in 4.518 )
App-DDFlare
view release on metacpan or search on metacpan
script/ddflare view on Meta::CPAN
Loads in the configuration file, which is YAML, the structure
is an array of hashrefs.
The first element being { user => ..., key => ... } which are
CloudFlare credentials.
Subsequent elements are { zone => ..., domains => [ ... ] } which are
cloudflare zones, and the subdomains within them to update. An
undefined value in domains represents the zone itself.
App-Dapper
view release on metacpan or search on metacpan
3. Optionally, create a second bucket named `www.mydomain.com` and set its
static website hosting to 'Redirect requests' to `mydomain.com`.
4. Install and configure the [AWS CLI](https://aws.amazon.com/cli/) with
your credentials:
$ aws configure
5. Now any time you want to rebuild your content and push it to S3, it's a
simple call to:
App-DocKnot
view release on metacpan or search on metacpan
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
A similar configuration could be used for other services, such as ssh.
See the pam.conf(5) man page for more information. When using this
module with Solaris login (at least on Solaris 8 and 9), you will
probably also need to add `retain_after_close` to the PAM configuration
to avoid having the user's credentials deleted before they are logged
in.
The Solaris Kerberos library reportedly does not support prompting for a
password change of an expired account during authentication. Supporting
password change for expired accounts on Solaris with native Kerberos may
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
on the same system. That will test your basic Kerberos configuration.
If the system has a keytab file installed that's readable by the process
doing authentication via PAM, make sure that the keytab is current and
contains a key for `host/<system>` where <system> is the fully-qualified
hostname. pam-krb5 prevents KDC spoofing by checking the user's
credentials when possible, but this means that if a keytab is present it
must be correct or authentication will fail. You can check the keytab
with `klist -k` and `kinit -k`.
Be sure that all libraries and modules, including PAM modules, loaded by
a program use the same Kerberos libraries. Sometimes programs that use
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
When `pam_authenticate` is called, pam-krb5 creates a temporary ticket
cache in `/tmp` and sets the PAM environment variable `PAM_KRB5CCNAME`
to point to it. This ticket cache will be automatically destroyed when
the PAM session is closed and is there only to pass the initial
credentials to the call to `pam_setcred`. The module would use a memory
cache, but memory caches will only work if the application preserves the
PAM environment between the calls to `pam_authenticate` and
`pam_setcred`. Most do, but OpenSSH notoriously does not and calls
`pam_authenticate` in a subprocess, so this method is used to pass the
tickets to the `pam_setcred` call in a different process.
`pam_authenticate` does a complete authentication, including checking
the resulting TGT by obtaining a service ticket for the local host if
possible, but this requires read access to the system keytab. If the
keytab doesn't exist, can't be read, or doesn't include the appropriate
credentials, the default is to accept the authentication. This can be
controlled by setting `verify_ap_req_nofail` to true in `[libdefaults]`
in `/etc/krb5.conf`. `pam_authenticate` also does a basic authorization
check, by default calling `krb5_kuserok` (which uses `~/.k5login` if
available and falls back to checking that the principal corresponds to
the account name). This can be customized with several options
documented in the pam_krb5(5) man page.
pam-krb5 treats `pam_open_session` and `pam_setcred(PAM_ESTABLISH_CRED)`
as synonymous, as some applications call one and some call the other.
Both copy the initial credentials from the temporary cache into a
permanent cache for this session and set `KRB5CCNAME` in the
environment. It will remember when the credential cache has been
established and then avoid doing any duplicate work afterwards, since
some applications call `pam_setcred` or `pam_open_session` multiple
times (most notably X.Org 7 and earlier xdm, which also throws away the
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
(`PAM_REFRESH_CRED` may be used instead.) Authentication proceeds as
above. At the `pam_setcred` stage, rather than creating a new ticket
cache, the module instead finds the current ticket cache (from the
`KRB5CCNAME` environment variable or the default ticket cache location
from the Kerberos library) and then reinitializes it with the
credentials from the temporary `pam_authenticate` ticket cache. When
refreshing a ticket cache, the application should not open a session.
Calling `pam_acct_mgmt` is optional; pam-krb5 doesn't do anything
different when it's called in this case.
If `pam_authenticate` apparently didn't succeed, or if an account was
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
pam_chauthtok
pam_setcred
pam_open_session
```
During the first `pam_authenticate`, we can't obtain credentials and
therefore a ticket cache since the password is expired. But
`pam_authenticate` isn't called again after `pam_chauthtok`, so
`pam_chauthtok` has to create a ticket cache. We however don't want it
to do this for the normal password change (`passwd`) case.
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
Joel Kociolek <joko@logidee.com> to be usable with Debian GNU/Linux.
It was packaged by Sam Hartman as the Kerberos v5 PAM module for Debian
and improved and modified by him and later by Russ Allbery to fix bugs
and add additional features. It was then adopted by Andres Salomon, who
added support for refreshing credentials.
The current distribution is maintained by Russ Allbery, who also added
support for reading configuration from `krb5.conf`, added many features
for compatibility with the Sourceforge module, commented and
standardized the formatting of the code, and overhauled the
App-Dochazka-CLI
view release on metacpan or search on metacpan
lib/App/Dochazka/CLI/Testers.pm view on Meta::CPAN
New password : <type george>
New password again: <type george again>
Password changed
Now you can log in with credentials C<george/george>:
$ dochazka-cli -u george -p george
...
Authenticating to server at http://localhost:5000 as user george
Server is alive
App-Dochazka-REST
view release on metacpan or search on metacpan
config/REST_Config.pm view on Meta::CPAN
{ code => 'SICK_DAY', long_desc => 'Discretionary sick leave' },
{ code => 'MEDICAL_LEAVE', long_desc => 'Statutory medical leave' },
] );
# DOCHAZKA_BASIC_AUTH_REALM
# message displayed to user when she is asked to enter her credentials
set( 'DOCHAZKA_BASIC_AUTH_REALM',
'ENTER YOUR DOCHAZKA CREDENTIALS (e.g., demo/demo)' );
# DOCHAZKA_LDAP
# Enable/disable LDAP authentication
App-Dochazka-WWW
view release on metacpan or search on metacpan
lib/App/Dochazka/WWW/Dispatch.pm view on Meta::CPAN
# two possibilities: login/logout attempt or normal AJAX call
if ( $method =~ m/^LOGIN/i ) {
$log->debug( "Incoming login/logout attempt" );
if ( $path =~ m/^login/i ) {
return $self->validate_user_credentials( $body );
} else {
return $self->_logout( $body );
}
}
lib/App/Dochazka/WWW/Dispatch.pm view on Meta::CPAN
my $hr = $rr->{'hr'};
return $self->_prep_ajax_response( $hr, $rr->{'body'} );
}
=head2 validate_user_credentials
Called either from C<process_post> on login AJAX requests originating from the
JavaScript side (i.e. the login screen in login-dialog.js, via login.js), or
directly from C<is_authorized> if the MFILE_WWW_BYPASS_LOGIN_DIALOG mechanism
is activated.
lib/App/Dochazka/WWW/Dispatch.pm view on Meta::CPAN
Returns a status object - OK means the login was successful; all other statuses
mean unsuccessful.
=cut
sub validate_user_credentials {
my ( $self, $body ) = @_;
$log->debug( "Entering " . __PACKAGE__ . "::validate_user_credentials()" );
my $r = $self->request;
my $session = $self->session;
my $nick = $body->{'nam'};
my $password = $body->{'pwd'};
App-DoubleUp
view release on metacpan or search on metacpan
lib/App/DoubleUp.pm view on Meta::CPAN
my $source = $self->source;
if ($source->{type} eq 'config') {
return @{ $source->{databases} };
}
elsif ($source->{type} eq 'database') {
my $db = $self->connect_to_db('dbi:mysql:information_schema', $self->credentials);
return db_flatarray($db, $source->{schemata_sql});
}
}
sub credentials {
my $self = shift;
return @{$self->{config}{credentials}};
}
sub connect_to_db {
my ($self, $dsn, $user, $password) = @_;
return DBI->connect($dsn, $user, $password, { RaiseError => 1, PrintError => 0 }) || croak "Error while connecting to '$dsn'";
lib/App/DoubleUp.pm view on Meta::CPAN
my @querys = $self->process_files($self->files);
for my $schema (@{ $self->database_names }) {
my $dsn = 'dbi:mysql:'.$schema;
say "DB: $schema";
my $db = $self->connect_to_db($dsn, $self->credentials);
$self->process_querys_for_one_db($db, \@querys);
say '';
}
}
when (undef) {
App-DrivePlayer
view release on metacpan or search on metacpan
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
return $self->rest_api if $self->rest_api;
my $auth_cfg = $self->config->auth_config();
unless ($auth_cfg->{client_id} && $auth_cfg->{client_secret}) {
$self->_show_error(
"Google API credentials not configured.\n\n" .
"Open File > Settings and enter your OAuth Client ID and Secret.\n\n" .
"You can obtain these from the Google Cloud Console under\n" .
"APIs & Services > Credentials (OAuth 2.0 Client ID, Desktop app type)."
);
return;
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
$dlg->set_default_size(520, -1);
my $vbox = $dlg->get_content_area();
$vbox->set_spacing(0);
# ---- Google API credentials ----
my $auth_frame = Gtk3::Frame->new('Google API Credentials');
$auth_frame->set_border_width(8);
my $grid = Gtk3::Grid->new();
$grid->set_row_spacing(8);
$grid->set_column_spacing(8);
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
my $auth_note = Gtk3::Label->new();
$auth_note->set_markup(
'<span size="small" foreground="#555555">'
. 'Create a Desktop-app OAuth client at '
. '<a href="https://console.cloud.google.com/apis/credentials">'
. 'Google Cloud Console → Credentials</a>, then enable the '
. '<a href="https://console.cloud.google.com/apis/library/drive.googleapis.com">'
. 'Drive API</a>. Generate the token file by running '
. '<tt>google_restapi_oauth_token_creator</tt> in a terminal.'
. '</span>'
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
$self->_settings_dialog();
}
}
# Heuristic: does an error message look like a Google API auth/connection
# failure that the user can fix in the Settings dialog (bad credentials,
# expired/revoked token, etc.)?
sub _is_auth_error {
my ($msg) = @_;
return 0 unless defined $msg && length $msg;
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
Running folder scans (via L<App::DrivePlayer::Scanner>) in a background thread
with live progress reporting.
=item *
Persisting configuration changes (music folder list, OAuth2 credentials)
through L<App::DrivePlayer::Config>.
=back
Requires the GTK3 system libraries and the L<Gtk3> and L<Glib> Perl
App-DuckPAN
view release on metacpan or search on metacpan
Change: b2b99d5b579e5491352fae0a42211a730aaa3675
Author: Zach Thompson <zach@duckduckgo.com>
Date : 2016-06-02 15:37:00 +0000
Remove all admin functionality requiring duck.co credentials:
* release * setup * poupload
Most of these were just wrappers around dzil.
App-EC2Cssh
view release on metacpan or search on metacpan
See [http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-DescribeInstances.html](http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-DescribeInstances.html) for all available
ways of filtering instances.
## SPLIT CONFIGURATION
Having a config file is fine, but what if you want to keep your credentials secret, and have
your EC2 sets of machine in a .ec2cssh.conf file per projects?
With ec2-cssh, this is possible by splitting the configuration in severl files.
For instance, you can have:
}
- $HOME/.ec2cssh.conf:
{
'ec2_config' => { .. Your credentials },
'ec2_sets' => { 'asetilike' => ... }
}
- /etc/ec2cssh.conf:
App-ElasticSearch-Utilities
view release on metacpan or search on metacpan
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
=back
=head1 AUTHENTICATION
HTTP Basic Authorization is only supported when the C<proto> is set to B<https>
as not to leak credentials all over.
The username is selected by going through these mechanisms until one is found:
--http-username
'http-username' in /etc/es-utils.yml or ~/.es-utils.yml
App-EventStreamr
view release on metacpan or search on metacpan
share/status/app/lib/angular/angular-resource.js view on Meta::CPAN
* caching.
* - **`timeout`** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise} that
* should abort the request when resolved.
* - **`withCredentials`** - `{boolean}` - whether to set the `withCredentials` flag on the
* XHR object. See {@link https://developer.mozilla.org/en/http_access_control#section_5
* requests with credentials} for more information.
* - **`responseType`** - `{string}` - see {@link
* https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType requestType}.
* - **`interceptor`** - `{Object=}` - The interceptor object has two optional methods -
* `response` and `responseError`. Both `response` and `responseError` interceptors get called
* with `http response` object. See {@link ng.$http $http interceptors}.
App-FargateStack
view release on metacpan or search on metacpan
lib/App/FargateStack/Checker.pm view on Meta::CPAN
########################################################################
my ($self) = @_;
my @rows;
push @rows, check( $self, \&check_credentials );
push @rows, check( $self, \&check_service_linked_roles );
push @rows, check( $self, \&check_vpc_and_subnets );
push @rows, check( $self, \&check_egress );
push @rows, check( $self, \&check_ecs_permissions );
push @rows, check( $self, \&check_elbv2_permissions );
lib/App/FargateStack/Checker.pm view on Meta::CPAN
return row_ok( 'Events perms', 'Describe OK' );
}
########################################################################
sub check_credentials {
########################################################################
my ($opt) = @_;
my $sts = new_client( 'App::STS', $opt );
lib/App/FargateStack/Checker.pm view on Meta::CPAN
=over 4
=item B<--profile> I<STR>
AWS config/credentials profile to use. Defaults to C<$ENV{AWS_PROFILE}> or the
SDK’s default behavior if unset.
=item B<--region> I<STR>
AWS region to target (e.g. C<us-east-1>). Defaults to C<$ENV{AWS_REGION}> if set.
App-Fetchware
view release on metacpan or search on metacpan
lib/App/Fetchware.pm view on Meta::CPAN
#CPAN API. And if it exists ask user if they wanna use that one instead of
#autogening one.
#
#Perhaps create a 'fetchwarefile' command to download and look at
#fetchwarefiles from CPAN, and then install them, and/or perhaps upload
#them pausing to ask for the user's PAUSE credentials!!!!!!!!!
extension_name(__PACKAGE__);
lib/App/Fetchware.pm view on Meta::CPAN
Discusses how FSF's gnu.org ftp download site was hacked.
3. http://arstechnica.com/security/2012/11/malicious-code-added-to-open-source-piwik-following-website-compromise/
Discusses how Piwiki's wordpress software was hacked, and downloads of
Piwiki had malicious code inserted into them.
4. http://www.theregister.co.uk/2011/03/21/php_server_hacked/
Discusses how php's wiki.php.org server was hacked yielding credentials to
php's source code repository.
Download mirrors *do* get hacked. Do not make the mistake, and think that it is
not possible. It is possible, and it does happen, so please properly configure
your Fetchwarefile to enable fetchware to verify that the downloaded software is
the same what the author uploaded.
App-Followme
view release on metacpan or search on metacpan
lib/App/Followme/UploadSite.pm view on Meta::CPAN
return (
verbose => 0,
max_errors => 5,
remote_url => '',
hash_file => 'upload.hash',
credentials => 'upload.cred',
state_directory => '_state',
data_pkg => 'App::Followme::UploadData',
upload_pkg => 'App::Followme::UploadFtp',
);
}
lib/App/Followme/UploadSite.pm view on Meta::CPAN
my ($self) = @_;
my $filename = catfile(
$self->{top_directory},
$self->{state_directory},
$self->{credentials}
);
my ($user, $pass);
if (-e $filename) {
($user, $pass) = $self->read_word($filename);
lib/App/Followme/UploadSite.pm view on Meta::CPAN
The following fields in the configuration file are used:
=over 4
=item credentials
The name of the file which holds the user name and password for the remote site
in obfuscated form. Te default name is 'upload.cred'.
=item hash_file
lib/App/Followme/UploadSite.pm view on Meta::CPAN
The url of the remote website, e.g. http://www.cloudhost.com.
=item state_directory
The name of the directory containing the credentials and hash file. This
directory name is relative to the top directory of the site. The default
name is '_state'.
=item upload_pkg
App-FonBot-Daemon
view release on metacpan or search on metacpan
lib/App/FonBot/Plugin/Email.pm view on Meta::CPAN
$log->debug("Processing email from $user");
eval { pwcheck $user, $password };
if ($@) {
$log->debug("Incorrect credentials in email subject from user $user. Exception: $@");
POE::Kernel->yield(send_message => $replyto, "Incorrect credentials");
return
}
$ok_user_addresses{"$user EMAIL $replyto"}=1;
App-FuguBench
view release on metacpan or search on metacpan
lib/App/FuguBench/Worktree.pm view on Meta::CPAN
if ( -e $dst ) {
$log->notice( 'already exists, skipped: %s', $dst );
return 1;
}
# A .env file holds credentials, so the copy takes the mode of
# the source and not the default of the umask. The stat runs
# before the copy: a stat after it can follow a parallel
# removal of the source, and the chmod then gives the copy the
# mode 0.
my @stat = stat $src;
App-GitGerrit
view release on metacpan or search on metacpan
lib/App/GitGerrit.pm view on Meta::CPAN
}
}
}
# The credential_* routines below use the git-credential command to
# get and set credentials for git commands and also for Gerrit REST
# interactions.
sub url_userinfo {
my ($url) = @_;
if (my $userinfo = $url->userinfo) {
lib/App/GitGerrit.pm view on Meta::CPAN
return ($fh, $fh->filename);
}
my $git_credential_supported = 1;
sub get_credentials {
my $baseurl = URI->new(config('baseurl'));
my ($fh, $credfile) = credential_description_file($baseurl);
my %credentials;
debug "Get credentials from git-credential";
open my $pipe, '-|', "git credential fill <$credfile"
or error "Can't open pipe to git-credential: $!";
while (<$pipe>) {
chomp;
$credentials{$1} = $2 if /^([^=]+)=(.*)/;
}
unless (close $pipe) {
error "Can't close pipe to git-credential: $!" if $!;
# If we get here it is because the shell invoked by open
lib/App/GitGerrit.pm view on Meta::CPAN
# means that we're using a pre-1.8 Git, which doesn't
# support git-credential yet.
$git_credential_supported = 0;
}
my ($username, $password) = @credentials{qw/username password/};
unless (defined $username && defined $password) {
debug "Get credentials from git-gerrit.baseurl";
($username, $password) = url_userinfo(config('baseurl'));
}
unless (defined $username && defined $password) {
debug "Get credentials from a .netrc file";
if (eval {require Net::Netrc}) {
if (my $mach = Net::Netrc->lookup(URI->new(config('baseurl'))->host, $username)) {
($username, $password) = ($mach->login, $mach->password);
}
} else {
debug "Failed to require Net::Netrc";
}
}
unless (defined $username && defined $password) {
debug "Prompt the user for the credentials";
if (eval {require Term::Prompt}) {
$username = Term::Prompt::prompt('x', 'Gerrit username: ', '', $ENV{USER});
$password = Term::Prompt::prompt('p', 'Gerrit password: ', '');
print "\n";
} else {
lib/App/GitGerrit.pm view on Meta::CPAN
defined $password or error "Couldn't get credential's password";
return ($username, $password);
}
sub set_credentials {
my ($username, $password, $what) = @_;
return 1 unless $git_credential_supported;
$what =~ /^(?:approve|reject)$/
or error "set_credentials \$what argument ($what) must be either 'approve' or 'reject'";
my $baseurl = URI->new(config('baseurl'));
my ($fh, $credfile) = credential_description_file($baseurl, $password);
return system("git credential $what <$credfile") == 0;
lib/App/GitGerrit.pm view on Meta::CPAN
sub gerrit {
my $method = shift;
state $gerrit;
unless ($gerrit) {
my ($username, $password) = get_credentials;
require Gerrit::REST;
$gerrit = Gerrit::REST->new(config('baseurl'), $username, $password);
eval { $gerrit->GET("/projects/" . uri_escape_utf8(config('project'))) };
if (my $error = $@) {
set_credentials($username, $password, 'reject') if $error->{code} == 401;
die $error;
} else {
set_credentials($username, $password, 'approve');
}
}
if ($Options{debug}) {
my ($endpoint, @args) = @_;
App-GitHubPullRequest
view release on metacpan or search on metacpan
lib/App/GitHubPullRequest.pm view on Meta::CPAN
# Perform HTTP GET
sub _get_url {
my ($url, $return_on_error) = @_;
croak("Please specify a URL") unless $url;
# See if we should use credentials
my @credentials;
if ( _is_api_url($url) ) {
my $token = _qx('git', 'config github.pr-token');
@credentials = ( '-H', "Authorization: token $token" ) if $token;
}
# Send request
my ($content, $rc) = _run_ext(
'curl',
'-L', # follow redirects
'-s', # be silent
'-w', '%{http_code}', # include HTTP status code at end of stdout
@credentials, # Logon credentials, if any
$url, # The URL we're GETing
);
die("curl failed to fetch $url with code $rc.\n") if $rc != 0;
my $code = substr($content, -3, 3, '');
lib/App/GitHubPullRequest.pm view on Meta::CPAN
my ($url, $mimetype, $data) = @_;
croak("Please specify a URL") unless $url;
croak("Please specify a mimetype") unless $mimetype;
croak("Please specify some data") unless $data;
# See if we should use credentials
my @credentials;
if ( _is_api_url($url) ) {
my $token = _qx('git', 'config github.pr-token');
die("You must login before you can modify information.\n")
unless $token;
@credentials = ( '-H', "Authorization: token $token" );
}
# Send request
my ($content, $rc) = _run_ext(
'curl',
'-s', # be silent
'-w', '%{http_code}', # include HTTP status code at end of stdout
'-X', 'PATCH', # perform an HTTP PATCH
'-H', "Content-Type: $mimetype", # What kind of data we're sending
'-d', $data, # Our data
@credentials, # Logon credentials, if any
$url, # The URL we're PATCHing
);
die("curl failed to patch $url with code $rc.\n") if $rc != 0;
my $code = substr($content, -3, 3, '');
lib/App/GitHubPullRequest.pm view on Meta::CPAN
my ($url, $mimetype, $data, $user, $password, $two_factor_token) = @_;
croak("Please specify a URL") unless $url;
croak("Please specify a mimetype") unless $mimetype;
croak("Please specify some data") unless $data;
# See if we should use credentials
my @credentials;
if ( _is_api_url($url) ) {
my $token = _qx('git', 'config github.pr-token');
die("You must login before you can modify information.\n")
unless $token or ( $user and $password );
if ( $user and $password ) {
@credentials = ( '-u', "$user:$password" );
push @credentials, '-H', "X-GitHub-OTP: $two_factor_token"
if $two_factor_token;
}
else {
@credentials = ( '-H', "Authorization: token $token" ) if $token;
}
}
# Send request
my ($content, $rc) = _run_ext(
lib/App/GitHubPullRequest.pm view on Meta::CPAN
'-s', # be silent
'-w', '%{http_code}', # include HTTP status code at end of stdout
'-X', 'POST', # perform an HTTP POST
'-H', "Content-Type: $mimetype", # What kind of data we're sending
'-d', $data, # Our data
@credentials, # Logon credentials, if any
$url, # The URL we're POSTing to
);
die("curl failed to post to $url with code $rc.\n") if $rc != 0;
my $code = substr($content, -3, 3, '');
App-GitKtti
view release on metacpan or search on metacpan
- [Usage examples](#usage-examples)
- [🚀 CPAN Distribution Guide](#-cpan-distribution-guide)
- [Prerequisites](#prerequisites)
- [Command Line Upload](#command-line-upload)
- [Step 1: Install Upload Tool](#step-1-install-upload-tool)
- [Step 2: Configure PAUSE Credentials](#step-2-configure-pause-credentials)
- [Step 3: Prepare Distribution](#step-3-prepare-distribution)
- [Step 4: Upload to CPAN](#step-4-upload-to-cpan)
- [What Happens Next](#what-happens-next)
- [Complete Example](#complete-example)
- [📋 Recent Releases](#-recent-releases)
```
#### Step 2: Configure PAUSE Credentials
```bash
# Create credentials file (one time setup)
echo "user YOUR_PAUSE_ID" > ~/.pause
echo "password YOUR_PASSWORD" >> ~/.pause
chmod 600 ~/.pause
```
Replace `YOUR_PAUSE_ID` and `YOUR_PASSWORD` with your actual PAUSE credentials.
#### Step 3: Prepare Distribution
```bash
# Clean and build distribution
make disttest
# Build distribution
make dist
# Upload (assuming credentials already configured)
cpan-upload App-GitKtti-2.0.0.tar.gz
```
**Note**: Only authorized maintainers with PAUSE access can upload to CPAN.
App-Glacier
view release on metacpan or search on metacpan
lib/App/Glacier.pm view on Meta::CPAN
Configures access to the Glacier service. The following keywords are defined:
=over 8
=item B<credentials => I<FILE>
Sets the name of the credentials file. See below for a detailed discussion.
=item B<access => I<KEYNAME>
Defines Amazon access key or access ID for look up in the credentials file.
=item B<secret => I<SECRET>
Sets the secret key. The use of this statement is discouraged for
security reason.
lib/App/Glacier.pm view on Meta::CPAN
AWS instance).
=back
If either of B<access> or B<secret> is not supplied, B<glacier> attemtps to
obtain access and secret keys from the file named in the B<credentials>
setting (if it is defined). If unable to find credentials, B<glacier> attempts
to get credentials from the instance store, assuming it is run on an EC2
instance. It will exit if this attempt fails.
The credentials file allows you to store all security sensitive data in a
single place and to tighten permissions accordingly. In the simplest case,
this file contains a single line with your access and secret keys separated
by a semicolon, e.g.:
AEBRGYTEBRET:RTFERYABNERTYR4HDDHEYRTWW
Additionally, the default region can be specified after a second semicolon:
AEBRGYTEBRET:RTFERYABNERTYR4HDDHEYRTWW:us-west-1
If you have several accounts, you can list their credentials on separate lines.
In that case, B<glacier> will select the account with the access key supplied
by the B<access> configuration statement, or the B<--account> command line
option. If neither of these are supplied, the first account in the file will
be used.
To further facilitate selection of the credential pair, each line can be tagged
with the line B<#:I<NAME>> immediately preceding it. In that case, the I<NAME>
can be used to select it using the B<--account> option or B<access> configuration statement.
Apart from these constructs, the credentials file can contain empty lines and
comments (lines beginning with B<#> followed by any character, except B<:> ),
which are ignored.
=item B<[transfer]>
App-Greple-pw
view release on metacpan or search on metacpan
lib/App/Greple/pw.pm view on Meta::CPAN
keywords can be configured to match your specific data format.
=item * B<Browser integration>
Includes browser automation features for automatically filling web
forms with extracted credentials.
=back
Some banks use random number matrices as a countermeasure for tapping.
If the module successfully guesses the matrix area, it blacks out the
App-HTTP_Proxy_IMP
view release on metacpan or search on metacpan
lib/App/HTTP_Proxy_IMP/IMP/CSRFprotect.pm view on Meta::CPAN
my @del;
push @del,$1 while ( $hdr =~s{^(Cookie|Cookie2):[ \t]*(.*(?:\n[ \t].*)*)\n}{}im );
if (@del) {
$self->run_callback([
IMP_LOG,0,0,0,IMP_LOG_INFO,
"removed cross-origin session credentials (@del) for request @origin -> @target"
]);
# return changed header
return $hdr;
}
lib/App/HTTP_Proxy_IMP/IMP/CSRFprotect.pm view on Meta::CPAN
App::HTTP_Proxy_IMP::IMP::CSRFprotect - IMP plugin against CSRF attacks
=head1 DESCRIPTION
This plugin attempts to block malicious cross-site requests (CSRF), by removing
session credentials (Cookie, Cookie2 and Authorization header) from the request,
if the origin of the request is not known or not trusted.
The origin is determined by checking the Origin or the Referer HTTP-header of
the request.
An origin O is considered trusted to issue a cross-site request to target T, if
App-LXC-Container
view release on metacpan or search on metacpan
lib/App/LXC/Container/Run.pm view on Meta::CPAN
debug(3, 'starting LXC application container ', $self->{name});
my $rc = system(
'lxc-execute', '--rcfile', $self->{rc},
'--name', $self->{name}, '--', '/lxc-run.sh');
my $err = $!;
# remove all .Xauthority files in container (the credentials may
# change before the next run):
local $_;
foreach (glob($self->{root} . '/.xauth-*/.Xauthority'))
{
unlink $_ or error 'can_t_remove__1__2', $_, $!;
App-LedgerSMB-Admin
view release on metacpan or search on metacpan
t/10-basic-db.t view on Meta::CPAN
);
eval { $db->drop };
dies_ok { $db->major_version } "can't get major version on nonexistent db";
ok($db = $db->new($db->export), 'Copied db credentials into new object');
ok($db->create, 'Created database');
ok($db->load('0.1'), 'Loaded base schema');
lives_ok {$db->major_version} "Lived when calling major version this time.";
App-MBUtiny
view release on metacpan or search on metacpan
lib/App/MBUtiny/Util.pm view on Meta::CPAN
my $anode = node2anode({});
Returns array of nodes
=item B<parse_credentials>
my ($user, $password) = parse_credentials( 'http://user:password@example.com' );
my ($user, $password) = parse_credentials( new URI('http://user:password@example.com') );
Returns credentials pair by URL or URI object
=item B<resolv>
my $name = resolv( $IPv4 );
my $ip = resolv( $name );
lib/App/MBUtiny/Util.pm view on Meta::CPAN
filesize sha1sum md5sum
resolv
explain
xcopy
node2anode set2attr
parse_credentials hide_password
/;
sub sha1sum {
my $f = shift;
my $sha1 = new Digest::SHA1;
lib/App/MBUtiny/Util.pm view on Meta::CPAN
my $n = shift;
return [] unless $n && ref($n) =~ /ARRAY|HASH/;
return [$n] if ref($n) eq 'HASH';
return $n;
}
sub parse_credentials {
my $url = shift || return ();
my $uri = (ref($url) eq 'URI') ? $url : URI->new($url);
my $info = $uri->userinfo() // "";
my $user = $info;
my $pass = $info;
lib/App/MBUtiny/Util.pm view on Meta::CPAN
$pass =~ s/^[^:]*://;
return (uri_unescape($user // ''), uri_unescape($pass // ''));
}
sub hide_password {
my $url = shift || return "";
my $full = shift || 0; # 0 - starts, 1 - no_credentials; 2 - user_only
my $uri = new URI($url);
my ($u,$p) = parse_credentials($uri);
return $url unless defined($p) && length($p);
$uri->userinfo($full ? ($full == 1 ? undef : $u) : sprintf("%s:*****", $u));
return $uri->canonical->as_string;
}
sub set2attr {
App-MFILE-WWW
view release on metacpan or search on metacpan
lib/App/MFILE/WWW/Dispatch.pm view on Meta::CPAN
# POST is used only for login/logout ATM
if ( $method =~ m/^LOGIN/i ) {
$log->debug( "Incoming login/logout attempt" );
if ( $path =~ m/^login/i ) {
return $self->validate_user_credentials( $body );
} else {
return $self->_logout( $body );
}
}
$log->crit( "Asked to perform an AJAX call, but feature is not implemented!" );
return 0;
}
=head2 validate_user_credentials
Called from C<process_post> to process login requests (special AJAX requests)
originating from the JavaScript side (i.e. the login screen in
login-dialog.js, via login.js).
Returns a status object - OK means the login was successful; all other statuses
mean unsuccessful.
=cut
sub validate_user_credentials {
my ( $self, $body ) = @_;
$log->debug( "Entering " . __PACKAGE__ . "::validate_user_credentials()" );
my $r = $self->request;
my $session = $r->{'env'}->{'psgix.session'};
my $nick = $body->{'nam'};
my $password = $body->{'pwd'};
App-MFILE
view release on metacpan or search on metacpan
lib/App/MFILE/HTTP.pm view on Meta::CPAN
}
# login bypass
$meta->set('META_LOGIN_BYPASS_STATE', 0) if not defined $meta->META_LOGIN_BYPASS_STATE;
if ( $site->MFILE_WWW_BYPASS_LOGIN_DIALOG and not $meta->META_LOGIN_BYPASS_STATE ) {
$log->notice("Bypassing login dialog! Using default credentials");
$session->{'ip_addr'} = $remote_addr;
$session->{'last_seen'} = time;
my $bypass_result = $self->_login_dialog( {
'nam' => $site->MFILE_WWW_DEFAULT_LOGIN_CREDENTIALS->{'nam'},
'pwd' => $site->MFILE_WWW_DEFAULT_LOGIN_CREDENTIALS->{'pwd'},
App-MHFS
view release on metacpan or search on metacpan
share/public_html/static/music_inc/drflac.js view on Meta::CPAN
async function Module(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&process.versions?....
;return moduleRtn}export default Module;
App-ModuleBuildTiny
view release on metacpan or search on metacpan
0.026
- Add --trial option to regenerate/upload/dist/distdir
0.025 Sun Dec 16 22:09:12 CET 2018
- Allow fetching credentials from console
- Add SPDX support to meta files
0.024
- Write generated files as binary
- Decode author names when POD is encoded
( run in 4.518 seconds using v1.01-cache-2.11-cpan-3f962061493 )