Result:
found more than 505 distributions - search limited to the first 2001 files matching your query
( run in 1.267 )
ARCv2
view release on metacpan or search on metacpan
lib/Arc/Connection/Client.pm view on Meta::CPAN
logfileprefix => "client",
logdestination => "stderr",
sasl_cb_user => $ENV{'USER'}, # SASL Callback for username (PLAIN and some other mechs only)
sasl_cb_auth => $ENV{'USER'}, # SASL Callback for authname (PLAIN and some other mechs only)
sasl_cb_pass => "", # SASL Callback for password (PLAIN and some other mechs only)
server => undef, # Server to connect to
port => undef, # Port to connect to
sasl_mechanism => undef, # use this mechanism for authentication
server_sasl_mechanisms => [], # filled by the sasl mechanisms
ARS-Simple
view release on metacpan or search on metacpan
examples/generate_fid_hash.pl view on Meta::CPAN
my $CLIP = Win32::Clipboard();
my $ars = ARS::Simple->new({
server => 'dev_machine',
user => 'greg',
password => 'password',
});
print "Enter the name of the Remedy form: ";
my $form = <STDIN>;
chomp $form;
ARSObject
view release on metacpan or search on metacpan
lib/ARSObject.pod view on Meta::CPAN
C<ars_errstr>, C<dbierrstr>
=item Connection
C<connect>(C<-srv> => server, C<-usr> => name, C<-pswd> => password, C<-lang> => language);
C<-ctrl>
C<dbiconnect>(C<-dbiconnect>); C<-dbi>
lib/ARSObject.pod view on Meta::CPAN
=item -pswd
=> undef || ''
(C<Connection>)
ARS password string to login with
=item -record
=> 'record name' || 'nameRowNumber'
ARSperl
view release on metacpan or search on metacpan
ARS/OOsup.pm view on Meta::CPAN
sub newObject {
my ($class, @p) = (shift, @_);
my ($self) = {};
my ($blessed) = bless($self, $class);
my ($server, $username, $password, $catch, $ctrl, $dbg, $tcpport) =
rearrange([SERVER,USERNAME,PASSWORD,CATCH,CTRL,DEBUG,TCPPORT],@p);
# should the OO layer emit debugging information?
$self->{'.debug'} = 0;
$self->{'.debug'} = 1 if(defined($dbg));
ARS/OOsup.pm view on Meta::CPAN
}
$self->{'ctrl'} = $ctrl;
$self->{'.nologoff'} = 1;
} else {
print "new connection object: ($server, $username, $password)\n"
if $self->{'.debug'};
$self->{'ctrl'} = ars_Login($server, $username, $password, "","", $tcpport);
$self->{'.nologoff'} = 0;
$self->tryCatch();
}
return $blessed;
ARS/OOsup.pm view on Meta::CPAN
}
sub print {
my $this = shift;
my($cacheId, $operationTime, $user, $password, $lang,
$server) = ars_GetControlStructFields($this->{'ctrl'});
print "connection object details:\n";
print "\tcacheId = $cacheId\n";
print "\toperationTime = ".localtime($operationTime)."\n";
print "\tuser = $user\n";
print "\tpassword = $password\n";
print "\tserver = $server\n";
print "\tlang = $lang\n";
}
sub availableSchemas {
ASNMTAP
view release on metacpan or search on metacpan
applications/bin/generateReports.pl view on Meta::CPAN
my $dayReportMonthPdf = ($dayReportMonth < 10) ? "0$dayReportMonth" : $dayReportMonth;
my $dayReportDayPdf = ($dayReportDay < 10) ? "0$dayReportDay" : $dayReportDay;
my $catalogID_uKey = ( ( $catalogID eq 'CID' ) ? '' : $catalogID .'_' ) . $uKey;
my $pdfFilename = "$RESULTSPATH/$resultsdir/$REPORTDIR/$dayReportYear$dayReportMonthPdf$dayReportDayPdf-$test-$catalogID_uKey-$periodeMessage-id_$id.pdf";
my $encodedUrlAccessParameters = encode_html_entities('U', $urlAccessParameters);
my $user_password = (defined $userPassword and $userPassword ne '' ? '--user-password '. $userPassword : '');
my $command = "$HTMLTOPDFPRG -f '$pdfFilename' $user_password $HTMLTOPDFOPTNS 'http://${REMOTE_HOST}$HTTPSURL/cgi-bin/detailedStatisticsReportGenerationAndCompareResponsetimeTrends.pl?$encodedUrlAccessParameters'";
if ( -e "$pdfFilename" ) {
$emailMessage .= " > $pdfFilename already generated\n";
} else {
$emailMessage .= " > $pdfFilename will be generated\n";
ASP4
view release on metacpan or search on metacpan
lib/ASP4.pm view on Meta::CPAN
...
"main": {
"dsn": "DBI:mysql:database_name:data.mywebsite.com",
"username": "db-username",
"password": "db-pAsswOrd"
}
...
Suppose you had the following tables in your database:
create table users (
user_id bigint unsigned not null primary key auto_increment,
email varchar(200) not null,
password char(32) not null,
created_on timestamp not null default current_timestamp,
unique(email)
) engine=innodb charset=utf8;
create table messages (
lib/ASP4.pm view on Meta::CPAN
# Setup our database connection:
__PACKAGE__->connection(
$conn->dsn,
$conn->username,
$conn->password
);
1;# return true:
Add the following C<Class::DBI::Lite> entity classes:
lib/ASP4.pm view on Meta::CPAN
messages_out =>
'App::db::message' =>
'from_user_id'
);
# Hash the password before storing it in the database:
__PACKAGE__->add_trigger( before_create => sub {
my ($self) = @_;
# Sign the password instead of storing it as plaintext:
unless( $self->{password} =~ m{^([a-f0-9]{32})$}i ) {
$self->{password} = $self->hash_password( $self->password );
}
});
# Hash the new password before storing it in the database:
__PACKAGE__->add_trigger( before_update_password => sub {
my ($self, $old, $new) = @_;
unless( $new =~ m{^([a-f0-9]{32})$}i ) {
$self->{password} = $self->hash_password( $new );
}
});
# Verify an email/password combination and return the user if a match is found:
sub check_credentials {
my ($self, %args) = @_;
my ($result) = $self->search(
email => $args{email},
password => $self->hash_password( $args{password} ),
);
$result ? return $result : return;
}
# Convert a password string into its hashed value:
sub hash_password {
my ($self, $str) = @_;
my $key = ASP4::ConfigLoader->load->system->settings->signing_key;
return md5_hex( $str . $key );
}
lib/ASP4.pm view on Meta::CPAN
<input type="text" name="email" value="<%= $Server->HTMLEncode( $Form->{email} ) %>" />
<% $::err->("email"); %>
</p>
<p>
<label>Password:</label>
<input type="password" name="password" />
<% $::err->("password"); %>
</p>
<p>
<label>Confirm Password:</label>
<input type="password" name="password2" />
<% $::err->("password2"); %>
</p>
<p>
<input type="submit" value="Register Now" />
</p>
</form>
lib/ASP4.pm view on Meta::CPAN
# Create the user:
my $user = eval {
App::db::user->do_transaction(sub {
return App::db::user->create(
email => $Form->{email},
password => $Form->{password},
);
});
};
if( $@ ) {
lib/ASP4.pm view on Meta::CPAN
}
else {
$errors->{email} = "Required";
}
# password:
unless( length($Form->{password} ) {
$errors->{password} = "Required";
}
# password2:
if( length($Form->{password2}) ) {
if( length($Form->{password}) ) {
unless( $Form->{password} eq $Form->{password2} ) {
$errors->{password2} = "Passwords don't match";
}
}
}
else {
$errors->{password2} = "Required";
}
# Bail out of we already have errors:
return $errors if keys %$errors;
ASP4x-Captcha-Imager
view release on metacpan or search on metacpan
t/conf/asp4-config.json view on Meta::CPAN
"cookie_name": "session-id",
"cookie_domain": "*",
"session_timeout": "*",
"dsn": "DBI:SQLite:dbname=/tmp/db_asp4captcha",
"username": "",
"password": ""
},
"main": {
"dsn": "DBI:SQLite:dbname=/tmp/db_asp4captcha",
"username": "",
"password": ""
}
}
}
ASP4x-Linker
view release on metacpan or search on metacpan
t/conf/asp4-config.json view on Meta::CPAN
"cookie_name": "session-id",
"cookie_domain": "*",
"session_timeout": "*",
"dsn": "",
"username": "",
"password": ""
},
"main": {
"dsn": "",
"username": "",
"password": ""
}
}
}
ASP4x-Router
view release on metacpan or search on metacpan
t/conf/asp4-config.json view on Meta::CPAN
"cookie_name": "session-id",
"cookie_domain": "*",
"session_timeout": 30,
"dsn": "",
"username": "",
"password": ""
},
"main": {
"dsn": "",
"username": "",
"password": ""
}
}
}
AWS-Lambda-Quick
view release on metacpan or search on metacpan
lib/AWS/Lambda/Quick.pm view on Meta::CPAN
shell$ sudo ./awscli-bundle/install -i /usr/local/aws -b /usr/local/bin/aws
You'll need to configure awscli with your own personal AWS Access
Key ID and AWS Secret Access Key. You can create these from the AWS
Management console by following the guide on
L<How to quickly find and update your access keys, password, and MFA setting using the AWS Management Console|https://aws.amazon.com/blogs/security/how-to-find-update-access-keys-password-mfa-aws-management-console/>
Once you have your keys you can then use the C<configure> command
to update the aws command line utility.
shell$ aws configure
AWS-Lambda
view release on metacpan or search on metacpan
lib/AWS/Lambda.pm view on Meta::CPAN
To upload the container image, you need to create a new ECR repository in your account and tag the local image to push it to ECR.
$ aws ecr create-repository --repository-name hello-perl --image-scanning-configuration scanOnPush=true
$ docker tag hello-perl:latest 123412341234.dkr.ecr.sa-east-1.amazonaws.com/hello-perl:latest
$ aws ecr get-login-password | docker login --username AWS --password-stdin 123412341234.dkr.ecr.sa-east-1.amazonaws.com
$ docker push 123412341234.dkr.ecr.sa-east-1.amazonaws.com/hello-perl:latest
Finally, create new function using awscli.
$ aws --region "$REGION" --profile "$PROFILE" lambda create-function \
AXL-Client-Simple
view release on metacpan or search on metacpan
lib/AXL/Client/Simple.pm view on Meta::CPAN
is => 'ro',
isa => 'Str',
required => 1,
);
has password => (
is => 'ro',
isa => 'Str',
required => 1,
);
lib/AXL/Client/Simple.pm view on Meta::CPAN
sub BUILDARGS {
my ($class, @rest) = @_;
my $params = (scalar @rest == 1 ? $rest[0] : {@rest});
# collect AXL password from environment as last resort
$params->{password} ||= $ENV{AXL_PASS};
# URI escape the username and password
$params->{username} ||= '';
$params->{username} = URI::Escape::uri_escape($params->{username});
$params->{password} = URI::Escape::uri_escape($params->{password});
return $params;
}
__PACKAGE__->meta->make_immutable;
lib/AXL/Client/Simple.pm view on Meta::CPAN
use AXL::Client::Simple;
my $cucm = AXL::Client::Simple->new({
server => 'call-manager-server.example.com',
username => 'oliver',
password => 's3krit', # or set in $ENV{AXL_PASS}
});
Then perform simple queries on the Unified Communications server:
my $device = $cucm->get_phone('SEP001122334455');
lib/AXL/Client/Simple.pm view on Meta::CPAN
=item C<< username => >> String (required)
The account username under which the module will connect to CUCM. This value
will be URI encoded by the module.
=item C<< password => >> String OR via C<$ENV{AXL_PASS}> (required)
The password of the account under which the module will connect to CUCM. This
value will be URI encoded by the module. You can also provide the password via
the C<AXL_PASS> environment variable.
=item C<< schema_path => >> String (optional)
A folder on your file system which contains the WSDL and Schema file which
Abstract-Meta-Class
view release on metacpan or search on metacpan
examples/example1.pl view on Meta::CPAN
has '$.id';
has '$.name';
has '$.password' => (
on_change => sub {
my ($self, $attribute, $scope, $value_ref) = @_;
$$value_ref = sha1_hex($$value_ref);
$self;
}
examples/example1.pl view on Meta::CPAN
);
has '$.address';
has '%.roles' ;
sub is_valid_password {
my ($self, $password) = @_;
!! ($self->password eq sha1_hex($password));
}
##################
my $user = User->new(id => 1, name => 'Scott', email => 'scott@email.com', password => '1234567');
if($user->is_valid_password('1234567')) {
#do some stuff
}
AcePerl
view release on metacpan or search on metacpan
Password to log in with (when using socket server).
=item B<-url>
An Acedb URL that combines the server type, host, port, user and
password in a single string. See the connect() method's "single
argument form" description.
=item B<-cache>
AcePerl can use the Cache::SizeAwareFileCache module to cache objects
Acme-24
view release on metacpan or search on metacpan
fortune/jackbauer view on Meta::CPAN
%
Jack Bauer shoots more than Peter North.
%
When Jack Bauer goes to a strip club he doesn't get a lapdance, he gets the stage.
%
Jack's PC repairs its own errors when he types a secret password. "Son of a bitch".
%
When a burning bush appears to Jack Bauer telling him what to do, Jack pisses out the flames. Jack listens to nobody.
%
When a girl does not make Jack Bauer finish, she gets blue balled.
%
Acme-Automatix
view release on metacpan or search on metacpan
.github/workflows/build-and-upload.yml view on Meta::CPAN
run: make dist
- name: Upload to CPAN
uses: thibaultduponchelle/action-upload-to-cpan@master
with:
username: ${{ secrets.USERNAME }}
password: ${{ secrets.PASSWORD }}
Acme-Be-Modern
view release on metacpan or search on metacpan
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
Acme-CPANLists-Import-NEILB
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/NEILB/Passwords.pm view on Meta::CPAN
package Acme::CPANLists::Import::NEILB::Passwords;
our $DATE = '2016-02-21'; # DATE
our $VERSION = '0.04'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in the article [http://neilb.org/reviews/passwords.html]. For the full article, visit the URL.",entries=>[{module=>"App::Genpass"},{module=>"Benchmark"},{...
1;
# ABSTRACT: Generating passwords (2012)
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::NEILB::Passwords - Generating passwords (2012)
=head1 VERSION
This document describes version 0.04 of Acme::CPANLists::Import::NEILB::Passwords (from Perl distribution Acme-CPANLists-Import-NEILB), released on 2016-02-21.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in the article L<http://neilb.org/reviews/passwords.html>. For the full article, visit the URL.
=head1 MODULE LISTS
=head2 Generating passwords (2012)
This list is generated by extracting module names mentioned in the article [http://neilb.org/reviews/passwords.html]. For the full article, visit the URL.
=over
=item * L<App::Genpass>
Acme-CPANModules-BloomFilters
view release on metacpan or search on metacpan
lib/Acme/CPANModules/BloomFilters.pm view on Meta::CPAN
memory-efficient. The downside is that bloom filter can give you false
positives, although false negatives are not possible. So in essence you can ask
a bloom filter which item is "possibly in set" or "definitely not in set". You
can configure the rate of false positives. The larger the filter, the smaller
the rate. Some examples for application of bloom filter include: 1) checking
whether a password is in a dictionary of millions of common/compromised
passwords; 2) checking an email address against leak database; 3) virus pattern
checking; 4) IP/domain blacklisting/whitelisting. Due to its properties, it is
sometimes combined with other data structures. For example, a small bloom filter
can be distributed with a software to check against a database. When the answer
from bloom filter is "possibly in set", the software can further consult on
online database to make sure if it is indeed in set. Thus, bloom filter can be
lib/Acme/CPANModules/BloomFilters.pm view on Meta::CPAN
memory-efficient. The downside is that bloom filter can give you false
positives, although false negatives are not possible. So in essence you can ask
a bloom filter which item is "possibly in set" or "definitely not in set". You
can configure the rate of false positives. The larger the filter, the smaller
the rate. Some examples for application of bloom filter include: 1) checking
whether a password is in a dictionary of millions of common/compromised
passwords; 2) checking an email address against leak database; 3) virus pattern
checking; 4) IP/domain blacklisting/whitelisting. Due to its properties, it is
sometimes combined with other data structures. For example, a small bloom filter
can be distributed with a software to check against a database. When the answer
from bloom filter is "possibly in set", the software can further consult on
online database to make sure if it is indeed in set. Thus, bloom filter can be
Acme-CPANModules-CLI-PasswordManager
view release on metacpan or search on metacpan
lib/Acme/CPANModules/CLI/PasswordManager.pm view on Meta::CPAN
our $DATE = '2025-01-06'; # DATE
our $DIST = 'Acme-CPANModules-CLI-PasswordManager'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {
summary => "List of various password manager CLIs on CPAN",
description => <<'MARKDOWN',
Password manager CLIs are command-line tools which you can use to store and
retrieve password entries.
If you know of others, please drop me a message.
MARKDOWN
entries => [
{
module => 'App::PasswordManager',
script => 'password_manager',
description => <<'MARKDOWN',
A simple script that lets you add, edit, list, and delete passwords from the
CLI. Passwords are stored in `~/.password_manager.json` in a simple JSON object
(hash) structure. Currently a very early release that still needs to be updated.
Pros:
- simplicity.
Cons:
- At the time of this writing (version 1.0.0) only the password hash is stored
and returned, making this application unusable at the moment.
- Password must be entered as command-line argument, making it visible from
process list and shell history, unless you explicitly disable those.
- Cannot add other fields to a record, e.g. comment/note, date, etc.
- Usernames are not encrypted.
lib/Acme/CPANModules/CLI/PasswordManager.pm view on Meta::CPAN
script => 'orgadb-sel',
description => <<'MARKDOWN',
A CLI to read entries from an addressbook file in a specific layout in Org
format. This tool can be used to read from a PGP-encrypted addressbook file, and
thus can also be used as a password retriever.
Pros:
- Standard tool and format for the data storage (PGP-encrypted Org file, which
can be edited with Emacs).
lib/Acme/CPANModules/CLI/PasswordManager.pm view on Meta::CPAN
},
],
};
1;
# ABSTRACT: List of various password manager CLIs on CPAN
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::CLI::PasswordManager - List of various password manager CLIs on CPAN
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::CLI::PasswordManager (from Perl distribution Acme-CPANModules-CLI-PasswordManager), released on 2025-01-06.
=head1 DESCRIPTION
Password manager CLIs are command-line tools which you can use to store and
retrieve password entries.
If you know of others, please drop me a message.
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<App::PasswordManager>
A simple script that lets you add, edit, list, and delete passwords from the
CLI. Passwords are stored in C<~/.password_manager.json> in a simple JSON object
(hash) structure. Currently a very early release that still needs to be updated.
Pros:
=over
lib/Acme/CPANModules/CLI/PasswordManager.pm view on Meta::CPAN
Cons:
=over
=item * At the time of this writing (version 1.0.0) only the password hash is stored
and returned, making this application unusable at the moment.
=item * Password must be entered as command-line argument, making it visible from
process list and shell history, unless you explicitly disable those.
lib/Acme/CPANModules/CLI/PasswordManager.pm view on Meta::CPAN
=item * Usernames are not encrypted.
=back
Script: L<password_manager>
=item L<App::orgadb>
A CLI to read entries from an addressbook file in a specific layout in Org
format. This tool can be used to read from a PGP-encrypted addressbook file, and
thus can also be used as a password retriever.
Pros:
=over
Acme-CPANModules-CryptingPassword
view release on metacpan or search on metacpan
lib/Acme/CPANModules/CryptingPassword.pm view on Meta::CPAN
our $DATE = '2023-07-21'; # DATE
our $DIST = 'Acme-CPANModules-CryptingPassword'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {
summary => 'List of modules/tools to crypt/hash a password',
description => <<'_',
Bascally, the Perl's builtin `crypt()` is all you need. It supports all the
hashing algorithms supported by your system's C library. You just need to supply
the salt in the right format to select the hashing algorithm. See the function's
lib/Acme/CPANModules/CryptingPassword.pm view on Meta::CPAN
module => 'Crypt::Password::Util',
description => <<'_',
This module offers a one-argument `crypt()` which generates an appropriate
("reasonably secure") salt for you. There are also utility functions to check
whether a string looks like a crypted password and to find out the type of the
crypted password.
_
},
{
module => 'App::bcrypt',
script => 'bcrypt',
description => <<'_',
The distribution provides a `bcrypt` CLI utility to crypt every input line with
bcrypt. It can also compare a password with its crypt.
_
},
],
};
1;
# ABSTRACT: List of modules/tools to crypt/hash a password
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::CryptingPassword - List of modules/tools to crypt/hash a password
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::CryptingPassword (from Perl distribution Acme-CPANModules-CryptingPassword), released on 2023-07-21.
lib/Acme/CPANModules/CryptingPassword.pm view on Meta::CPAN
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
This module offers a one-argument C<crypt()> which generates an appropriate
("reasonably secure") salt for you. There are also utility functions to check
whether a string looks like a crypted password and to find out the type of the
crypted password.
=item L<App::bcrypt>
Author: L<BDFOY|https://metacpan.org/author/BDFOY>
The distribution provides a C<bcrypt> CLI utility to crypt every input line with
bcrypt. It can also compare a password with its crypt.
Script: L<bcrypt>
=back
Acme-CPANModules-Import-CPANRatings-User-stevenharyanto
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-10-29'; # DATE
our $DIST = 'Acme-CPANModules-Import-CPANRatings-User-stevenharyanto'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {description=>"This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.",entries=>[{description=>"\n(REMOVED)\n",module=>"Log::Any",rating=>undef},{description=>"\nProvides a thin/lightweight OO interface for \$?, ...
1;
# ABSTRACT: List of modules mentioned by CPANRatings user stevenharyanto
__END__
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
Author: L<JOHNH|https://metacpan.org/author/JOHNH>
An interesting tool that has been developed since 1991 (which is roughly around the time the WWW and Linux was born, whew). Kudos to the author for the dedication and consistency.
<br><br>Since nowadays SQL is pretty much ubiquitous, users might also want to check out an alternative tool, App::fsql. For example (taking a similar example from the module's doc), to select entries in /etc/passwd where UID is between 1000 and 2000...
<br><br>$ ( echo -e "login\tpassword\tuid\tgid\tgecos\thome\tshell"; sed 's/:/\t/g' /etc/passwd ) | fsql --add-tsv - 'SELECT * FROM stdin WHERE uid >= 1000 AND uid <= 2000' --format text --aoh
=item L<Date::Tie>
Author: L<FGLOCK|https://metacpan.org/author/FGLOCK>
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
=item L<App::DBBrowser>
Author: L<KUERBIS|https://metacpan.org/author/KUERBIS>
A nice, minimalistic, terminal-based user interface for browsing your database and tables. Might be useful for simple cases.
<br><br>It would be I<much> more useful if usernames/passwords, queries, and other settings can be saved in a config/session file.
<br>
=item L<Locale::Maketext>
Acme-CPANModules-RandomData
view release on metacpan or search on metacpan
lib/Acme/CPANModules/FakeData.pm view on Meta::CPAN
dictionary word (default wordlist provided), date (in YYYY-MM-DD format), time
(in HH::MM:SS format), datetime, image (just a blank PNG with random size and
background color).
L<Data::Maker> can generate realistic fake data including IP address, email,
password, person (first name, middle name, last name, SSN). It focuses on
performance (200 records/sec number is cited).
L<Data::Faker> is yet another moduxsle, with plugins to generate company name,
person name, date/time, phone number, street address, domain/IP/email/username.
lib/Acme/CPANModules/FakeData.pm view on Meta::CPAN
names (probably copied from Data::Faker). There is no option to pick male/female
names.
Other: L<Text::Lorem>.
For more specific types of random data (person, password, etc), see other lists
mentioned in the See Also section.
Keywords: random data, fake data, mock data.
=head1 ACME::CPANMODULES ENTRIES
Acme-CPANModules-RandomPassword
view release on metacpan or search on metacpan
lib/Acme/CPANModules/GeneratingRandomPassword.pm view on Meta::CPAN
This document describes version 0.002 of Acme::CPANModules::GeneratingRandomPassword (from Perl distribution Acme-CPANModules-RandomPassword), released on 2023-04-10.
=head1 DESCRIPTION
L<App::genpw> can generate passwords with patterns and wordlists. It loads
secure random number generator if available. By default it generates 12-20
character-long passwords comprising of ASCII letters and digits. There are
several variants which are basically wrappers for convenience:
L<App::genpw::base64>, L<App::genpw::base58>, L<App::genpw::base56>,
L<App::genpw::wordlist> (use words from wordlists), L<App::genpw::ind> (use
Indonesian words). The module will use C<rand()> from C<Data::Entropy::Algorithms>
if the module is available, for stronger random number generation.
L<Crypt::GeneratePassword> creates secure random pronounceable passwords. It
provides function C<word()> which generates a sequence of letters with vocals in
between consonants so the word is still pronounceable, even though it's a
nonsense word. It also provides C<chars()> which produces a sequence of random
letters, digits, and some symbols. It still uses C<rand()> by default which is
not cryptographically secure.
L<Crypt::RandPasswd> implements the old FIPS 181 (1993, withdrawn 2015)
standard to generate pronounceable password, which is no longer recommended.
L<Crypt::PassGen>, yet another module to create random words that look like
real words. It does not use a secure random number generator by default.
L<Data::SimplePassword>
lib/Acme/CPANModules/GeneratingRandomPassword.pm view on Meta::CPAN
L<String::Random>
L<String::Urandom>
L<Crypt::XkcdPassword>, a password generator module inspired by
L<http://xkcd.com/936/>.
L<CtrlO::Crypt::XkcdPassword>, another password generator module inspired by
L<http://xkcd.com/936/>.
L<App::GenPass>
L<Crypt::PW44>
lib/Acme/CPANModules/GeneratingRandomPassword.pm view on Meta::CPAN
L<Text::Password::Pronounceable>
For other types of random data, see other lists mentioned in the See Also
section.
Keywords: random secure password
=head1 ACME::CPANMODULES ENTRIES
=over
Acme-CPANModules-WorkingWithPDF
view release on metacpan or search on metacpan
lib/Acme/CPANModules/WorkingWithPDF.pm view on Meta::CPAN
<pm:PDF::Cairo>
**Passwords**
<prog:add-pdf-password> (from <pm:App::PDFUtils>) adds password to PDF.
<prog:remove-pdf-password> (from <pm:App::PDFUtils>) strips password from PDF.
**Searching**
<prog:pdfgrep> (from <pm:App::pdfgrep>) converts PDF to text and performs grep
lib/Acme/CPANModules/WorkingWithPDF.pm view on Meta::CPAN
L<PDF::Cairo>
B<Passwords>
L<add-pdf-password> (from L<App::PDFUtils>) adds password to PDF.
L<remove-pdf-password> (from L<App::PDFUtils>) strips password from PDF.
B<Searching>
L<pdfgrep> (from L<App::pdfgrep>) converts PDF to text and performs grep
on it.
Acme-CPANModulesBundle-Import-MojoliciousAdvent-2017
view release on metacpan or search on metacpan
devdata/https_mojolicious.io_blog_2017_12_05_day-5-your-apps-built-in-commands view on Meta::CPAN
<p>How fun is that?!</p>
<ul>
<li>You can POST or PUT or DELETE data.</li>
<li>It handles HTTP basic authentication using <code>username:password@</code> in the URL.</li>
<li>You can submit forms, even with file uploads using the standard <code>@filename</code> syntax.</li>
<li>You can pipe data to the command if you just want to send the raw contents of a file rather than url-encode it.</li>
<li>See lots more examples in the <a href="http://mojolicious.org/perldoc/Mojolicious/Command/get#SYNOPSIS">documentation</a>.</li>
</ul>
Acme-CPANModulesBundle-Import-MojoliciousAdvent-2018
view release on metacpan or search on metacpan
devdata/https_mojolicious.io_blog_2018_12_08_authenticating-with-ldap_ view on Meta::CPAN
sub on_user_login {
my $self = shift;
my $username = $self->param('username');
my $password = $self->param('password');
if (check_credentials($username, $password)) {
$self->render(text => 'Hello Bender!');
}
else {
$self->render(
text => '<h2>Login failed</h2><a href="/login">Try again</a>',
devdata/https_mojolicious.io_blog_2018_12_08_authenticating-with-ldap_ view on Meta::CPAN
);
}
}
sub check_credentials {
my ($username, $password) = @_;
return $username eq 'Bender' && $password eq 'rocks';
}
</code></pre>
<h2>Storing passwords - MojoX::Auth::Simple</h2>
<p>We can agree that hard-coding usernames and passwords is not sustainable.
If you can connect to a database, any database that your Perl
<a href="https://metacpan.org/pod/DBI">DBI</a> module can connect to,
then you might think that
<a href="https://metacpan.org/pod/MojoX::Auth::Simple">MojoX::Auth::Simple</a>
will solve your problems. Further reading will tell you that it only
devdata/https_mojolicious.io_blog_2018_12_08_authenticating-with-ldap_ view on Meta::CPAN
authentication itself. But, since you're using a database now, you
could change the <code>check_credentials</code> to something better than this
(wot was cooked up on a Friday afternoon and not tested)</p>
<pre><code>sub check_credentials {
my ($username, $password) = @_;
my $statement = <<'SQL'; # NO! Don't do this!
SELECT username FROM user_passwd
WHERE username = ? AND password = ?
SQL
my $sth = $dbh->prepare($statement);
$sth->execute($username, $password) or return;
my @row = $sth->fetchrow_array();
$sth->finish();
return $username eq $row[0];
}
devdata/https_mojolicious.io_blog_2018_12_08_authenticating-with-ldap_ view on Meta::CPAN
And yes, you should prepare the SQL outside of the sub.
The <code>?</code> in the SQL statement are bind parameters, placeholders that make the database call faster and safer.</p>
<h4>Did you spot the HUGE mistake I made?</h4>
<p>Never, never, NEVER store passwords in plain text! (Blame it on Friday afternoon)
You should encrypt the password before storing it with an algorithm like AES or SHA-2.
So, how about this for a better untested example? You can encrypt with SQL</p>
<pre><code> my $statement = <<'SQL'; # better
SELECT username FROM user_passwd
WHERE username = ? AND password = SHA2(?, 256)
SQL
</code></pre>
<p>or encrypt with Perl</p>
<pre><code>use Crypt::Digest::SHA256 qw/ sha256 /;
sub check_credentials {
my ($username, $password) = @_;
my $encrypted = sha256($password);
...
$sth->execute($username, $encrypted) or return;
</code></pre>
<p>Technically, AES is an encryption algorithm and SHA-2 is a hashing algorithm,
meaning that the transformation is effectively one-way and is more secure.
Here are a couple of modules that make it easier and safer:</p>
<p>A nice module out there for handling passwords is, well,
<a href="https://metacpan.org/pod/Passwords">Passwords</a>.
It's just a wrapper around some other modules that gives you a simple API
and will use <a href="https://metacpan.org/pod/Crypt::Eksblowfish::Bcrypt">Bcrypt</a> by default.
So if you've hashed your password with the <code>password_hash</code> function
and stored the <code>$hash</code> value in your database like this</p>
<pre><code>my $hash = password_hash($initial_password);
my $sth = $dbh->prepare('INSERT INTO user_passwd (username, password) VALUES (?, ?)');
$sth->do($username, $hash);
</code></pre>
<p>you should be ok to change the sub to</p>
<pre><code>sub check_credentials {
my ($username, $password) = @_;
my $statement = 'SELECT password FROM user_passwd WHERE username = ?';
my $sth = $dbh->prepare($statement);
$sth->execute($username) or return;
my ($encoded) = $sth->fetchrow_array();
$sth->finish();
return password_verify($password, $encoded);
}
</code></pre>
<p><a href="https://metacpan.org/pod/Mojolicious::Plugin::Scrypt">Mojolicious::Plugin::Scrypt</a>
will use the Scrypt algorithm,
but can also use Argon2 (which was recommended to me at LPW), Bcrypt and more.
So, assuming that you've stored your password with
<code>my $encoded = $app->scrypt($password);</code>
the <code>on_user_login</code> sub becomes</p>
<pre><code>sub check_credentials {
my ($username, $password) = @_;
my $statement = 'SELECT password FROM user_passwd WHERE username = ?';
my $sth = $dbh->prepare($statement);
$sth->execute($username) or return;
my ($encoded) = $sth->fetchrow_array();
$sth->finish();
# WAIT! where did $self come from
return $self->scrypt_verify($password, $encoded);
}
</code></pre>
<p>Oh, dear. The above crashes because of a design decision made early on in the writing process.
I invoked <code>check_credentials</code> as a plain sub, not the method of an object.
devdata/https_mojolicious.io_blog_2018_12_08_authenticating-with-ldap_ view on Meta::CPAN
<pre><code>sub on_user_login {
my $self = shift;
...
if ($self->check_credentials($username, $password)) {
...
}
sub check_credentials {
my ($self, $username, $password) = @_;
...
return $self->scrypt_verify($password, $encoded);
}
</code></pre>
<p>Y'know, I'm sitting here on the Group W bench thinkin' ...
if I'm going to re-write this whole tutorial, maybe I should've started with
<a href="https://metacpan.org/pod/Mojolicious::Plugin::Authentication">Mojolicious::Plugin::Authentication</a>
and taken you through the code you needed for the <code>validate_user</code> option in the Plugin.
But let's leave that for next year.</p>
<p>Further reading on storing passwords:</p>
<ul>
<li><a href="https://crackstation.net/hashing-security.htm#properhashing">Secure Salted Password Hashing</a> by Defuse Security.</li>
</ul>
devdata/https_mojolicious.io_blog_2018_12_08_authenticating-with-ldap_ view on Meta::CPAN
<ol>
<li>Connect to the LDAP server</li>
<li><strong>Bind</strong> to the server</li>
<li>Search for the user's unique identifier in LDAP</li>
<li><strong>Bind</strong> as the user with their password</li>
<li>Check the result code from the server</li>
</ol>
<p>First, you need to make a network connection to the LDAP server.
Next, you <a href="https://metacpan.org/pod/Net::LDAP#METHODS">bind</a> to the server.
"Bind" is the term used in LDAP for connecting to a particular location
in the LDAP tree.
The LDAP server has a setting on whether it allows binding anonymously
and determines whether you can search directory without a password
as I've done in the example.
Then you search LDAP for the user (because the identifiers are <em>loooong</em>)
and then you bind as the user with the password they've provided.
If this connection as the user with their password succeeds,
then you must have used the correct password.
LDAP hands you back a result from the <code>bind</code> as a
<a href="https://metacpan.org/pod/distribution/perl-ldap/lib/Net/LDAP/Message.pod">Net::LDAP::Message</a>
object on either success or failure,
so check the Message <code>code</code> to find out whether you should authenticate the user.</p>
devdata/https_mojolicious.io_blog_2018_12_08_authenticating-with-ldap_ view on Meta::CPAN
= @{$config}{ qw/server baseDN username id/ };
...
sub check_credentials {
my ($username, $password) = @_;
return unless $username;
my $ldap = Net::LDAP->new( $LDAP_server )
or warn("Couldn't connect to LDAP server $LDAP_server: $@"), return;
my $message = $ldap->bind( $base_DN );
devdata/https_mojolicious.io_blog_2018_12_08_authenticating-with-ldap_ view on Meta::CPAN
attrs => [$user_id],
);
my $user_id = $search->pop_entry();
return unless $user_id; # does this user exist in LDAP?
# this is where we check the password
my $login = $ldap->bind( $user_id, password => $password );
# return 1 on success, 0 on failure with the ternary operator
return $login->code == LDAP_INVALID_CREDENTIALS ? 0
: 1;
}
Acme-CPANModulesBundle-Import-NEILB
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Import/NEILB/Passwords.pm view on Meta::CPAN
our $DATE = '2018-09-22'; # DATE
our $VERSION = '0.001'; # VERSION
our $LIST = {
description => "This list is generated by extracting module names mentioned in the article [http://neilb.org/reviews/passwords.html]. For the full article, visit the URL.",
entries => [
{ module => "App::Genpass" },
{ module => "Benchmark" },
{ module => "Crypt::GeneratePassword" },
{ module => "Crypt::PW44" },
lib/Acme/CPANModules/Import/NEILB/Passwords.pm view on Meta::CPAN
{ module => "String::MkPasswd" },
{ module => "String::Random" },
{ module => "String::Urandom" },
{ module => "Text::Password::Pronounceable" },
],
summary => "Generating passwords (2012)",
};
1;
# ABSTRACT: Generating passwords (2012)
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::Import::NEILB::Passwords - Generating passwords (2012)
=head1 VERSION
This document describes version 0.001 of Acme::CPANModules::Import::NEILB::Passwords (from Perl distribution Acme-CPANModulesBundle-Import-NEILB), released on 2018-09-22.
=head1 DESCRIPTION
Generating passwords (2012).
This list is generated by extracting module names mentioned in the article [http://neilb.org/reviews/passwords.html]. For the full article, visit the URL.
=head1 INCLUDED MODULES
=over
Acme-CPANModulesBundle-Import-PerlDancerAdvent-2018
view release on metacpan or search on metacpan
devdata/http_advent.perldancer.org_2018_17 view on Meta::CPAN
<div id="content">
<div class="pod-document"><h1><a name="dancer_and_email"></a>Dancer and Email</h1>
<p>Web applications regularly need to send email to its users, e.g. receipts or password reset links.
The <a href="https://metacpan.org/pod/Dancer2::Plugin::Email">Email</a> plugin for Dancer2 simplifies this task by
providing the <code>email</code> keyword and a sane default configuration.</p>
<p>So the unavoidable "Hello world" example would look like:</p>
<pre class="prettyprint">email {
from => 'foo@perl.dance',
devdata/http_advent.perldancer.org_2018_17 view on Meta::CPAN
SMTP:
ssl: 1
host: 'mail.perl.dance'
port: 465
sasl_username: 'foo@perl.dance'
sasl_password: 'nevairbe'</pre>
<p>In development you want to <b>prevent</b> email going out to <b>real users</b>.</p>
<p>This can be done with the <a href="https://metacpan.org/pod/Email::Sender::Transport::Redirect">Redirect</a> transport:</p>
<pre class="prettyprint">plugins:
Email:
Acme-ID-CompanyName
view release on metacpan or search on metacpan
script/gen-generic-ind-company-names view on Meta::CPAN
# pos => {},
# slurpy => {},
# greedy => {}, # old alias for slurpy, will be removed in Rinci 1.2
# partial => {},
# stream => {},
# is_password => {},
# cmdline_aliases => {
# _value_prop => {
# summary => {},
# description => {},
# schema => {},
( run in 1.267 second using v1.01-cache-2.11-cpan-49f99fa48dc )