password results from the CPAN

script/create-random-file view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

view all matches for this distribution

App-CriticDB

1 match

LICENSE view on Meta::CPAN

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-DBBrowser

3 results

lib/App/DBBrowser/DB.pm view on Meta::CPAN

        return 'Pg';
    }

    sub get_db_handle {
        my ( $self, $db ) = @_;
        my $dbh = DBI->connect( "DBI:Pg:dbname=$db", 'user', 'password', {
            RaiseError => 1,
            PrintError => 0,
        });
        return $dbh;
    }

view all matches for this distribution

App-DBCritic

7 results

#pod =head1 SYNOPSIS
#pod
#pod     use App::DBCritic;
#pod
#pod     my $critic = App::DBCritic->new(
#pod         dsn => 'dbi:Oracle:HR', username => 'scott', password => 'tiger');
#pod     $critic->critique();
#pod
#pod =head1 DESCRIPTION
#pod
#pod This package is used to scan a database schema and catalog any violations


use Moo;
use Scalar::Util 'blessed';
use App::DBCritic::Loader;

for (qw(username password class_name)) { has $_ => ( is => 'ro' ) }

#pod =attr username
#pod
#pod The optional username used to connect to the database.
#pod
#pod =attr password
#pod
#pod The optional password used to connect to the database.
#pod
#pod =attr class_name
#pod
#pod The name of a L<DBIx::Class::Schema|DBIx::Class::Schema> class you wish to
#pod L</critique>.

);

sub _build_schema {
    my $self = shift;

    my @connect_info = map { $self->$_ } qw(dsn username password);

    if ( my $class_name = $self->class_name ) {
        return $class_name->connect(@connect_info)
            if eval "require $class_name";
    }

=head1 SYNOPSIS

    use App::DBCritic;

    my $critic = App::DBCritic->new(
        dsn => 'dbi:Oracle:HR', username => 'scott', password => 'tiger');
    $critic->critique();

=head1 DESCRIPTION

This package is used to scan a database schema and catalog any violations


=head2 username

The optional username used to connect to the database.

=head2 password

The optional password used to connect to the database.

=head2 class_name

The name of a L<DBIx::Class::Schema|DBIx::Class::Schema> class you wish to
L</critique>.

view all matches for this distribution

App-DBI-Loader

1 match

bin/dbiloader view on Meta::CPAN


=head1 SYNOPSIS

dbiloader C<-h>

dbiloader [C<-c>] [C<-t E<lt>separatorE<gt>>] [C<-u E<lt>usernameE<gt>>] [C<-p E<lt>passwordE<gt>>] C<E<lt>connectionE<gt>> C<E<lt>tableE<gt>> [C<E<lt>schemaE<gt>>] [C<E<lt>filesE<gt>>...]

  # Read TSV and load into mytable in SQLite database t.db
  dbiloader -t '\t' dbi:SQLite:t.db mytable data.txt

  # Clear mytable, read CSV (default), and load into mytable in SQLite database t.db

bin/dbiloader view on Meta::CPAN


=head2 C<-u E<lt>usernameE<gt>>

Specify username.

=head2 C<-p E<lt>passwordE<gt>>

Specify password.

=head2 C<E<lt>connectionE<gt>>

Specify DBI connection string.

view all matches for this distribution

App-DBIUtils

2 results

            pos => 1,
        },
        user => {
            schema => 'str*',
        },
        password => {
            schema => 'str*',
        },
        catalog => {
            schema => 'str*',
        },

    },
};
sub dump_dbi_column_info {
    my %args = @_;

    my $dbh = DBI->connect($args{dsn}, $args{user}, $args{password},
                           {RaiseError=>1});
    my @rows;
    my $sth = $dbh->column_info($args{catalog}, $args{schema}, $args{table}, undef);
    while (my $row = $sth->fetchrow_hashref) {
        push @rows, $row;


=item B<--help>, B<-h>, B<-?>

Display help message and exit.

=item B<--password>=I<s>

=item B<--schema>=I<s>

Default value:


 catalog (see --catalog)
 dsn (see --dsn)
 format (see --format)
 naked_res (see --naked-res)
 password (see --password)
 schema (see --schema)
 table (see --table)
 user (see --user)

=head1 ENVIRONMENT

view all matches for this distribution

App-DDNS-Namecheap

4 results

lib/App/DDNS/Namecheap.pm view on Meta::CPAN

use LWP::Simple qw($ua get);
$ua->agent("");
use Mozilla::CA;

has domain => ( is => 'ro', isa => 'Str', required => 1 );
has password => ( is => 'ro', isa => 'Str', required => 1 );
has hosts => ( is => 'ro', isa => 'ArrayRef', required => 1 );
has ip => ( is => 'ro', isa => 'Str', required => 0 );

sub update {
  my $self = shift;
  foreach ( @{ $self->{hosts} } ) {
    my $url = "https://dynamicdns.park-your-domain.com/update?domain=$self->{domain}&password=$self->{password}&host=$_";
    $url .= "&ip=$self->{ip}" if $self->{ip};
    if ( my $return = get($url) ) {
      unless ( $return =~ /<errcount>0<\/errcount>/is ) {
	$return = ( $return =~ /<responsestring>(.*)<\/responsestring>/is ? $1 : "unknown error" );
        print "failure submitting host \"$_\.$self->{domain}\": $return\n";

lib/App/DDNS/Namecheap.pm view on Meta::CPAN


=head1 SYNOPSIS

    my $domain =  App::DDNS::Namecheap->new(
                      domain   => 'mysite.org',
         	      password => 'abcdefghijklmnopqrstuvwxyz012345',
		      hosts    => [ "@", "www", "*" ],
                      ip       => '127.0.0.1',    #optional -- defaults to external ip
    );

    $domain->update();

view all matches for this distribution

App-DNSZoneUtils

1 match

script/gen-bind-zone-from-powerdns-db view on Meta::CPAN


Default value:

 "DBI:mysql:database=pdns"

=item B<--db-password>=I<s>

=item B<--db-user>=I<s>

=back

view all matches for this distribution

App-Dest

1 match

SECURITY.md view on Meta::CPAN

Security vulnerabilities can be reported to the current App-Dest
maintainers by email to Gryphon Shafer <gryphon@goldenguru.com>.

Please include as many details as possible, including code samples
or test cases, so that we can reproduce the issue.  Check that your
report does not expose any sensitive data, such as passwords,
tokens, or personal information.

If you would like any help with triaging the issue, or if the issue
is being actively exploited, please copy the report to the CPAN
Security Group (CPANSec) at <cpan-security@security.metacpan.org>.

view all matches for this distribution

App-Devbot

2 results

use Regexp::Common qw /net/;

##################################################

my $nick='devbot';
my $password;
my $server='irc.oftc.net';
my $port=6697;
my $ssl=1;
my @channels;
my $trace=0;

my $log=1;
my $store_files=0;

GetOptions (
  "nick=s" => \$nick,
  "password=s" => \$password,
  "server=s" => \$server,
  "port=i" => \$port,
  "ssl!" => \$ssl,
  "channel=s" => \@channels,
  "log!" => \$log,

  mkdir "logs/$channel";
  append_file "logs/$channel/$file.txt", strftime ('%T ', localtime), @strings, "\n";
}

sub bot_start{
  $irc->plugin_add (NickServID => POE::Component::IRC::Plugin::NickServID->new(Password => $password)) if defined $password;
  $irc->plugin_add (AutoJoin => POE::Component::IRC::Plugin::AutoJoin->new(
	Channels => \@channels,
	RejoinOnKick => 1,
	Rejoin_delay => 10,
	Retry_when_banned => 60,


=item B<--nick> I<nickname>

The nickname of devbot. Defaults to devbot.

=item B<--password> I<password>

If supplied, identify to NickServ with this password

=item B<--server> I<hostname>

The server to connect to. Defaults to irc.oftc.net.

view all matches for this distribution

App-DiffDBSchemaUtils

6 results

    },
    username1 => {
        schema => 'str*',
        tags => ['category:db-connection'],
    },
    password1 => {
        schema => 'str*',
        tags => ['category:db-connection'],
    },
    dsn2 => {
        schema => 'str*',

    },
    username2 => {
        schema => 'str*',
        tags => ['category:db-connection'],
    },
    password2 => {
        schema => 'str*',
        tags => ['category:db-connection'],
    },
);

#    require DBIx::Connect::Any;
#
#    my %args = @_;
#
#    my $dbh = DBIx::Connect::Any->connect(
#        $args{dsn}, $args{username}, $args{password},
#        {RaiseError=>1});
#
#}

$SPEC{diff_db_schema} = {

    require DBIx::Connect::Any;

    my %args = @_;

    my $dbh1 = DBIx::Connect::Any->connect(
        $args{dsn1}, $args{username1}, $args{password1},
        {RaiseError=>1});
    my $dbh2 = DBIx::Connect::Any->connect(
        $args{dsn2}, $args{username2}, $args{password2},
        {RaiseError=>1});

    require DBIx::Diff::Schema;

    my $res = DBIx::Diff::Schema::diff_db_schema($dbh1, $dbh2);


=item * B<dsn1>* => I<str>

=item * B<dsn2>* => I<str>

=item * B<password1> => I<str>

=item * B<password2> => I<str>

=item * B<username1> => I<str>

=item * B<username2> => I<str>


=item * B<db2>* => I<str>

Name of the second MySQL database.

=item * B<password1> => I<str>

=item * B<password2> => I<str>

=item * B<username1> => I<str>

=item * B<username2> => I<str>


=item * B<db2>* => I<str>

Name of the second PostgreSQL database.

=item * B<password1> => I<str>

=item * B<password2> => I<str>

=item * B<username1> => I<str>

=item * B<username2> => I<str>


=item * B<db2>* => I<str>

Name of the second PostgreSQL database.

=item * B<password1> => I<str>

=item * B<password2> => I<str>

=item * B<username1> => I<str>

=item * B<username2> => I<str>

view all matches for this distribution

App-DistUtils

15 results

script/dir2dist view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

view all matches for this distribution

App-DocKnot

19 results

t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN


blurb: |
  pam-krb5 is a Kerberos PAM module for either MIT Kerberos or Heimdal.  It
  supports ticket refreshing by screen savers, configurable authorization
  handling, authentication of non-local accounts for network services,
  password changing, and password expiration, as well as all the standard
  expected PAM features.  It works correctly with OpenSSH, even with
  ChallengeResponseAuthentication and PrivilegeSeparation enabled, and
  supports extensive configuration either by PAM options or in krb5.conf or
  both.  PKINIT is supported with recent versions of both MIT Kerberos and
  Heimdal and FAST is supported with recent MIT Kerberos.

description: |
  pam-krb5 provides a Kerberos PAM module that supports authentication, user
  ticket cache handling, simple authorization (via .k5login or checking
  Kerberos principals against local usernames), and password changing.  It can
  be configured through either options in the PAM configuration itself or
  through entries in the system krb5.conf file, and it tries to work around
  PAM implementation flaws in commonly-used PAM-enabled applications such as
  OpenSSH and xdm.  It supports both PKINIT and FAST to the extent that the
  underlying Kerberos libraries support these features.

t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN

    against a Heimdal server, the test will be skipped; if you use the Heimdal
    library against an MIT server, the test suite may hang.

    Several `module/expired` tests are expected to fail with Heimdal 1.5 due
    to a bug in Heimdal with reauthenticating immediately after a
    library-mediated password change of an expired password.  This is fixed in
    later releases of Heimdal.

    To run the full test suite, Perl 5.10 or later is required.  The following
    additional Perl modules will be used if present:

t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN


      Be sure to include the module in the session group as well as the auth
      group.  Without the session entry, the user's ticket cache will not be
      created properly for ssh logins (among possibly others).

      If your users should normally all use Kerberos passwords exclusively,
      putting something like:

      ```
          password sufficient pam_krb5.so minimum_uid=1000
          password required   pam_unix.so try_first_pass obscure md5
      ```

      in `/etc/pam.d/common-password` will change users' passwords in Kerberos
      by default and then only fall back on Unix if that doesn't work.  (You
      can make this tighter by using the more complex new-style PAM
      configuration.)  If you instead want to synchronize local and Kerberos
      passwords and change them both at the same time, you can do something
      like:

      ```
          password required   pam_unix.so obscure sha512
          password required   pam_krb5.so use_authtok minimum_uid=1000
      ```

      If you have multiple environments that you want to synchronize and you
      don't want password changes to continue if the Kerberos password change
      fails, use the `clear_on_fail` option.  For example:

      ```
          password required   pam_krb5.so clear_on_fail minimum_uid=1000
          password required   pam_unix.so use_authtok obscure sha512
          password required   pam_smbpass.so use_authtok
      ```

      In this case, if `pam_krb5` cannot change the password (due to password
      strength rules on the KDC, for example), it will clear the stored
      password (because of the `clear_on_fail` option), and since `pam_unix`
      and `pam_smbpass` are both configured with `use_authtok`, they will both
      fail.  `clear_on_fail` is not the default because it would interfere
      with the more common pattern of falling back to local passwords if the
      user doesn't exist in Kerberos.

      If you use a more complex configuration with the Linux PAM `[]` syntax
      for the session and account groups, note that `pam_krb5` returns a
      status of ignore, not success, if the user didn't log on with Kerberos.

t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN

      On Red Hat systems, modify `/etc/pam.d/system-auth` instead, which
      contains all of the configuration for the different stacks.

      You can also use pam-krb5 only for specific services.  In that case,
      modify the files in `/etc/pam.d` for that particular service to use
      `pam_krb5.so` for authentication.  For services that are using passwords
      over TLS to authenticate users, you may want to use the `ignore_k5login`
      and `no_ccache` options to the authenticate module.  `.k5login`
      authorization is only meaningful for local accounts and ticket caches
      are usually (although not always) only useful for interactive sessions.

t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN

      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
      therefore require setting the `defer_pwchange` or `force_pwchange`
      option for selected login applications.  See the description and
      warnings about that option in the pam_krb5(5) man page.

      Some configuration options may be put in the `krb5.conf` file used by
      your Kerberos libraries (usually `/etc/krb5.conf` or
      `/usr/local/etc/krb5.conf`) instead or in addition to the PAM
      configuration.  See the man page for more details.

      The Kerberos library, via pam-krb5, will prompt the user to change their
      password if their password is expired, but when using OpenSSH, this will
      only work when `ChallengeResponseAuthentication` is enabled.  Unless
      this option is enabled, OpenSSH doesn't pass PAM messages to the user
      and can only respond to a simple password prompt.

      If you are using MIT Kerberos, be aware that users whose passwords are
      expired will not be prompted to change their password unless the KDC
      configuration for your realm in `[realms]` in `krb5.conf` contains a
      `master_kdc` setting or, if using DNS SRV records, you have a DNS entry
      for `_kerberos-master` as well as `_kerberos`.
  - title: Debugging
    body: |

t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN

      return `PAM_IGNORE`, which tells the PAM library to proceed as if that
      module wasn't listed in the PAM configuration at all.
      `pam_authenticate`, however, returns failure in the ignored user case by
      default, since otherwise a configuration using `ignore_root` with
      pam-krb5 as the only PAM module would allow anyone to log in as root
      without a password.  There doesn't appear to be a case where returning
      `PAM_IGNORE` instead would improve the module's behavior, but if you
      know of a case, please let me know.

      By default, `pam_authenticate` intentionally does not follow the PAM
      standard for handling expired accounts and instead returns failure from
      `pam_authenticate` unless the Kerberos libraries are able to change the
      account password during authentication.  Too many applications either do
      not call `pam_acct_mgmt` or ignore its exit status.  The fully correct
      PAM behavior (returning success from `pam_authenticate` and
      `PAM_NEW_AUTHTOK_REQD` from `pam_acct_mgmt`) can be enabled with the
      `defer_pwchange` option.

t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN

          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.

      What we do is set a flag in our PAM data structure saying that we're
      processing an expired password, and `pam_chauthtok`, if it sees that
      flag, redoes the authentication with password prompting disabled after
      it finishes changing the password.

      Unfortunately, when handling password changes this way, `pam_chauthtok`
      will always have to prompt the user for their current password again
      even though they just typed it.  This is because the saved
      authentication tokens are cleared after `pam_authenticate` returns, for
      security reasons.  We could hack around this by saving the password in
      our PAM data structure, but this would let the application gain access
      to it (exactly what the clearing is intended to prevent) and breaks a
      PAM library guarantee.  We could also work around this by having
      `pam_authenticate` get the `kadmin/changepw` authenticator in the
      expired password case and store it for `pam_chauthtok`, but it doesn't
      seem worth the hassle.
  - title: History and Acknowledgements
    body: |
      Originally written by Frank Cusack <fcusack@fcusack.com>, with the
      following acknowledgement:

view all matches for this distribution

App-Dochazka-CLI

26 results

config/CLI_Config.pm view on Meta::CPAN

#     nick to use when we authenticate ourselves to the App::Dochazka::REST server
#     when this is set to '' or undef, App::Dochazka::CLI will prompt for it
set( 'DOCHAZKA_REST_LOGIN_NICK', undef );

# DOCHAZKA_REST_LOGIN_NICK
#     password to use when we authenticate ourselves to the App::Dochazka::REST server
#     when this is set to '' or undef, App::Dochazka::CLI will prompt for a password
#     WARNING: PUTTING YOUR PASSWORD HERE MAY BE CONVENIENT, BUT IS PROBABLY UNSAFE
set( 'DOCHAZKA_REST_LOGIN_PASSWORD', undef );

# MREST_CLI_COOKIE_JAR
#     default location of the cookie jar

view all matches for this distribution

App-Dochazka-Common

1 match

lib/App/Dochazka/Common.pm view on Meta::CPAN


All four of these, plus the C<eid> field, have C<UNIQUE> constraints defined at
the database level, meaning that duplicate entries are not permitted. However,
of the four, only C<nick> is required.

Depending on how authentication is set up, employee passwords may also be
stored in this table, using the C<passhash> and C<salt> fields.

For details, see L<App::Dochazka::REST::Model::Employee>.

view all matches for this distribution

App-Dochazka-REST

23 results

config/REST_Config.pm view on Meta::CPAN

#     N.B. 1 administrators can edit all fields, and passerbies can't edit any
#     N.B. 2 if LDAP authentication and LDAP import/sync are being used, it may not 
#            make sense for employees to edit *any* of the fields
#     N.B. 3 this site param affects the functioning of the "POST employee/self" and "POST employee/current" resources
set( 'DOCHAZKA_PROFILE_EDITABLE_FIELDS', {
    'inactive' => [ 'password' ],
    'active' => [ 'password' ],
});

# DOCHAZKA_INTERVAL_SELECT_LIMIT
#     upper limit on number of intervals fetched (for sanity, to avoid
#     overly huge result sets)

view all matches for this distribution

App-Dochazka-WWW

5 results

lib/App/Dochazka/WWW/Dispatch.pm view on Meta::CPAN

    $log->debug( "Entering " . __PACKAGE__ . "::validate_user_credentials()" );

    my $r = $self->request;
    my $session = $self->session;
    my $nick = $body->{'nam'};
    my $password = $body->{'pwd'};
    my $standalone = $meta->META_WWW_STANDALONE_MODE;

    $log->debug( "Employee $nick login attempt" );
    $log->debug( "DOCHAZKA_WWW_BACKEND_URI is " .  $site->DOCHAZKA_WWW_BACKEND_URI );

    my ( $code, $message, $body_json );
    my $rr = $self->rest_req( {
        server => $site->DOCHAZKA_WWW_BACKEND_URI,
        nick => $nick,
        password => $password,
        path => 'employee/self/full',
    } );
    $code = $rr->{'hr'}->code;
    $message = $rr->{'hr'}->message;
    $body_json = $rr->{'body'};

view all matches for this distribution

App-DoubleUp

1 match

lib/App/DoubleUp.pm view on Meta::CPAN

    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'";
}

sub process_querys_for_one_db {
    my ($self, $db, $querys) = @_;

view all matches for this distribution

App-DownloadsDirUtils

12 results

script/foremost-download view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

view all matches for this distribution

App-DrivePlayer

1 match

lib/App/DrivePlayer/GUI.pm view on Meta::CPAN

    my $fp_status = Gtk3::Label->new();
    $fp_status->set_xalign(0.0);

    my $install_btn = Gtk3::Button->new_with_label('Installâ€¦');
    $install_btn->set_tooltip_text(
        'Installs libchromaprint-tools via apt (requires administrator password)'
    );

    my $fp_hbox = Gtk3::Box->new('horizontal', 8);
    $fp_hbox->pack_start($fp_status,    FALSE, FALSE, 0);
    $fp_hbox->pack_start($install_btn,  FALSE, FALSE, 0);

view all matches for this distribution

App-DuckPAN

1 match

README.md view on Meta::CPAN


#### Logging into the VM

Once you have installed the virtual machine you should be able to start up the VM and login with the following credentials:
- **username** : `vagrant`
- **password** : `duckduckhack`


#### Cloning the repository on the VM

**The DuckPAN client has already been installed for you.** To use it, you must 1st clone your instant answer git repository.

view all matches for this distribution

App-DzilUtils

6 results

script/list-dist-deps view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

view all matches for this distribution

App-ElasticSearch-Utilities

17 results

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

            base|index-basename=s
            days=i
            noop!
            proto=s
            http-username=s
            password-exec=s
            master-only|M
            insecure
            capath=s
            cacert=s
            cert=s

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

                     : exists $_GLOBALS{days}  ? $_GLOBALS{days} : 1,
        # HTTP Basic Authentication
        USERNAME    => exists $opts->{'http-username'}    ? $opts->{'http-username'}
                     : exists $_GLOBALS{'http-username'}  ? $_GLOBALS{'http-username'}
                     : $ENV{USER},
        PASSEXEC    => exists $opts->{'password-exec'}   ? $opts->{'password-exec'}
                     : exists $_GLOBALS{'password-exec'} ? $_GLOBALS{'password-exec'}
                     : undef,
        # TLS Options
        INSECURE    => exists $opts->{insecure} ? 1
                    :  exists $_GLOBALS{insecure} ? $_GLOBALS{insecure}
                    :  0,

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

    es_utils_initialize() unless keys %DEF;

    $host ||= $DEF{HOST};

    # Return the results if we've done this already
    return @{ $_auth_cache{$host} }{qw(username password)}
        if exists $_auth_cache{$host};

    # Set the cached element
    my %auth = ();

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

    my $netrc = Net::Netrc->lookup($host);
    if( $DEF{HOST} eq $host ) {
        %auth = map { lc($_) => $DEF{$_} } qw(USERNAME);
    }
    my %meta = ();
    foreach my $k (qw( http-username password-exec )) {
        foreach my $name ( $DEF{INDEX}, $DEF{BASE} ) {
            next unless $name;
            if( my $v = es_local_index_meta($k, $name) ) {
                $meta{$k} = $v;
                last;

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

    $auth{username} ||= $meta{'http-username'} ? $meta{'http-username'}
                      : defined $DEF{USERNAME} ? $DEF{USERNAME}
                      : defined $netrc         ? $netrc->login
                      : $ENV{USER};

    # Prompt for the password
    $auth{password} ||= defined $netrc ? $netrc->password
                      : (es_pass_exec($host,$auth{username},$meta{'password-exec'})
                            || prompt(sprintf "Password for '%s' at '%s': ", $auth{username}, $host)
                        );

    # Store
    $_auth_cache{$host} = \%auth;
    return @auth{qw(username password)};
}


sub es_pass_exec {
    my ($host,$username,$exec) = @_;

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

    # Simplest case we can't run
    $exec ||= $DEF{PASSEXEC};
    return unless length $exec && -x $exec;

    my(@out,@err);
    # Run the password command captue out, error and RC
    run3 [ $exec, $host, $username ], \undef, \@out, \@err;
    my $rc = $?;

    # Record the error
    if( @err or $rc != 0 ) {

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

        ssl_opts => _get_ssl_opts(),
    );
    # Only authenticate over TLS
    if( $DEF{PROTO} eq 'https' ) {
        $conn{username} = $DEF{USERNAME};
        $conn{password} = es_pass_exec(@DEF{qw(HOST USERNAME)}) if $DEF{PASSEXEC};
    }

    # If we're overriding, return a unique handle
    if(defined $override_servers) {
        my @overrides = is_arrayref($override_servers) ? @$override_servers : $override_servers;

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

    host: esproxy.example.com
    port: 80
    timeout: 10
    proto: https
    http-username: bob
    password-exec: /home/bob/bin/get-es-passwd.sh

=head1 ARGS

From App::ElasticSearch::Utilities:

    --local         Use localhost as the elasticsearch host
    --host          ElasticSearch host to connect to
    --port          HTTP port for your cluster
    --proto         Defaults to 'http', can also be 'https'
    --http-username HTTP Basic Auth username
    --password-exec Script to run to get the users password
    --insecure      Don't verify TLS certificates
    --cacert        Specify the TLS CA file
    --capath        Specify the directory with TLS CAs
    --cert          Specify the path to the client certificate
    --key           Specify the path to the client private key file

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN


If HTTP Basic Authentication is required, use this username.

See also the L<HTTP Basic Authentication> section for more details

=item B<password-exec>

If HTTP Basic Authentication is required, run this command, passing the arguments:

    <command_to_run> <es_host> <es_username>

The script expects the last line to contain the password in plaintext.

=item B<noop>

Prevents any communication to the cluster from making changes to the settings or data contained therein.
In short, it prevents anything but HEAD and GET requests, B<except> POST requests to the _search endpoint.

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN

    CLI::Helpers prompt()

Once the username has been resolved, the following mechanisms are tried in order:

    Netrc element matching the hostname of the request
    Password executable defined by --password-exec
    'password-exec' in /etc/es-utils.yml, ~/.es-utils.yml
    CLI::Helpers prompt()

=head2 Password Exec

It is B<BAD> practice to specify passwords as a command line argument, or store it in a plaintext
file.  There are cases where this may be necessary, but it is not recommended.  The best method for securing  your
password is to use the B<password-exec> option.

This option must point to an executable script.  That script will be passed two arguments, the hostname and the username
for the request.  It expects the password printed to STDOUT as the last line of output.  Here's an example password-exec setup
using Apple Keychain:

    #!/bin/sh

    HOSTNAME=$1;
    USERNAME=$2;

    /usr/bin/security find-generic-password -w -a "$USERNAME" -s "$HOSTNAME"

If we save this to "$HOME/bin/get-passwd.sh" we can execute a script
like this:

    $ es-search.pl --http-username bob --password-exec $HOME/bin/get-passwd.sh \
                    --base secure-data --fields

Though it's probably best to set this in your ~/.es-utils.yml file:

    ---
    host: secured-cluster.example.org
    port: 443
    proto: https
    http-username: bob
    password-exec: /home/bob/bin/get-passwd.sh

=head3 CLI::Helpers and Password Prompting

If all the fails to yield a password, the last resort is to use CLI::Helpers::prompt() to ask the user for their
password.  If the user is using version 1.1 or higher of CLI::Helpers, this call will turn off echo and readline magic
for the password prompt.

=head1 INDEX SELECTION ARGUMENTS

=over

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN


Grab the value of the global value from the es-utils.yaml files.

=head2 es_basic_auth($host)

Get the user/password combination for this host.  This is called from LWP::UserAgent if
it recieves a 401, so the auth condition must be satisfied.

Returns the username and password as a list.

=head1 CONNECTION FUNCTIONS

=head2 es_connect

lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN


=head1 FUNCTIONS

=head2 es_pass_exec(host, username)

Called from es_basic_auth to exec a program, capture the password
and return it to the caller.  This allows the use of password vaults
and keychains.

=head2 es_pattern

Returns a hashref of the pattern filter used to get the indexes

view all matches for this distribution

App-Env-Login

1 match

LICENSE view on Meta::CPAN

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-Env

1 match

LICENSE view on Meta::CPAN

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-Envdoctor

1 match

lib/App/Envdoctor/Scanner.pm view on Meta::CPAN

    return $t;
}

my $SECRET_NAME = qr/SECRET|TOKEN|PASSWORD|PASSWD|PRIVATE|CREDENTIAL|API_?KEY|ACCESS_?KEY|AUTH/i;
my $WEAK_VALUE
    = qr/^(?:changeme|change_me|placeholder|x{3,}|todo|secret|password|passwd|test|example|sample|dummy|your[_-].*|<.*>|\$\{.*\})$/i;

sub _is_weak_secret {
    my ($v) = @_;
    return 1 if $v eq '' || length($v) < 8;
    return $v =~ $WEAK_VALUE ? 1 : 0;

view all matches for this distribution

App-Environ-Mojo-Pg

2 results

lib/App/Environ/Mojo/Pg.pm view on Meta::CPAN


  ## Non standart schema workaround
  ## For URI objects that do not belong to one of these, you can only use the common and generic methods.
  $url->scheme('https');

  $url->userinfo("$conf->{user}:$conf->{password}");
  $url->host( $conf->{host} );
  $url->port( $conf->{port} );
  $url->path( $conf->{dbname} );
  $url->query_form( %{ $conf->{options} } );

view all matches for this distribution

App-Environ-Que

1 match

example/pg.yml view on Meta::CPAN

  connectors:
    main:
      host: 'db.example.com'
      port: 5432
      user: 'main'
      password: 'main'
      dbname: 'postgres'
      options:
        PrintWarn: 0
        PrintError: 0
        RaiseError: 1

view all matches for this distribution

App-EventStreamr

11 results

bin/station-mgr.pl view on Meta::CPAN

                    host      => $self->{config}{mixer}{host},
                    port      => $self->{config}{mixer}{port},
                    id        => $id,
                    shost     => $self->{config}{stream}{host},
                    sport     => $self->{config}{stream}{port},
                    spassword => $self->{config}{stream}{password},
                    stream    => $self->{config}{stream}{stream},
                  );

  $command =~ s/\$(\w+)/$cmd_vars{$1}/g;

bin/station-mgr.pl view on Meta::CPAN

  "run" : "0",
  "stream" :
    {
      "host" : "",
      "port" : "",
      "password" : "",
      "stream" : ""
    }
}
CONFIG

bin/station-mgr.pl view on Meta::CPAN

          'commands' => {
                          'alsa' => 'dvsource-alsa -h $host -p $port hw:$device',
                          'dv' => 'dvsource-firewire -h $host -p $port -c $device',
                          'record' => 'dvsink-files $device',
                          'v4l' => 'ffmpeg -f video4linux2 -s vga -r 25 -i $device -target pal-dv - | dvsource-file /dev/stdin -h $host -p $port',
                          'stream' => 'dvsink-command -- ffmpeg2theora - -f dv -F 25:2 --speedlevel 0 -v 4  --optimize -V 420 --soft-target -a 4 -c 1 -H 44100 -o - | oggfwd $host $port 8000 $password /$stream',
                          'file' => 'dvsource-file -l $device',
                          'dvswitch' => 'dvswitch -h 0.0.0.0 -p $port'
                        },
          'config' => {
                        'roles' => [

view all matches for this distribution

App-FTNDB

5 results