Blowfish is capable of strong encryption and can use key sizes up to 56
bytes (a 448 bit key). You're encouraged to take advantage of the full key
size to ensure the strongest encryption possible from this module.

Perl-only implementation of the cryptographic cipher block chaining
mode (CBC).

An XS-based DES implementation for Perl.

_Crypt::OpenPGP_ is a pure-Perl implementation of the OpenPGP standard. In addition to support for the standard itself, _Crypt::OpenPGP_ claims compatibility with many other PGP implementations, both those that support the standard and those that preceded it.

_Crypt::OpenPGP_ provides signing/verification, encryption/decryption, keyring management, and key-pair generation; in short it should provide you with everything you need to PGP-enable yourself. Alternatively it can be used as part of a larger system; for example, perhaps you have a web-form-to-email generator written in Perl, and you'd like to encrypt outgoing messages, because they contain sensitive information. _Crypt::OpenPGP_ can be plugged into such a scenario, given your public key, and told to encrypt all messages; they will then be readable only by you.

This module currently supports 'RSA' and 'DSA' for digital signatures, and 'RSA' and 'ElGamal' for encryption/decryption. It supports the symmetric ciphers '3DES', 'Blowfish', 'IDEA', 'Twofish', 'CAST5', and 'Rijndael' ('AES'). 'Rijndael' is supported for key sizes of '128', '192', and '256' bits. _Crypt::OpenPGP_ supports the digest algorithms 'MD5', 'SHA-1', and 'RIPE-MD/160'. And it supports 'ZIP' and 'Zlib' compression.

PBKDF2 is a secure password hashing algorithm that uses the techniques of "key strengthening" to make the complexity of a brute-force attack arbitrarily high. PBKDF2 uses any other cryptographic hash or cipher (by convention, usually HMAC-SHA1, but Crypt::PBKDF2 is fully pluggable), and allows for an arbitrary number of iterations of the hashing function, and a nearly unlimited output hash size (up to 2**32 - 1 times the size of the output of the backend hash). The hash is salted, as any password hash should be, and the salt may also be of arbitrary size.

This module implements the Rijndael cipher, which has just been selected as
the Advanced Encryption Standard.

Authors:
--------
Rafael R. Sevilla
brian d foy,

NOTE: Automatically created during Factory devel project migration by admin.

This is a dynamic loadable curses module for Perl5. This package can
be found at any CPAN archive.

This module provide a single function called dump() that takes a list of
values as argument and produce a string as result. The string contains perl
code that when evaled will produce a deep copy of the original arguments. The
string is formatted for easy reading.

Hashes are great for storing named data, but if you want more than one
entry for a name, you have to use a list of pairs. Even then, this is
really boring to write:

$values = [
foo => undef,
bar => undef,
baz => undef,
xyz => { ... },
];

Just look at all those undefs! Don't worry, we can get rid of those:

$values = [
map { $_ => undef } qw(foo bar baz),
xyz => { ... },
];

Aaaauuugh! We've saved a little typing, but now it requires thought to
read, and thinking is even worse than typing.

With Data::OptList, you can do this instead:

$values = Data::OptList::mkopt([
qw(foo bar baz),
xyz => { ... },
]);

This works by assuming that any defined scalar is a name and any
reference following a name is its value.

ShowTable.pm is a Perl 5 module which defines subroutines to print
arrays of data in nicely formatted listings. It uses one of four
possible formats: simple table, boxed table, list style, and
HTML-formatting.

This package consists of a C library and a Perl module (which uses the
C library, internally) for all kinds of date calculations based on the
Gregorian calendar (the one used in all western countries today),
thereby complying with all relevant norms and standards: ISO/R
2015-1971, DIN 1355 and, to some extent, ISO 8601 (where applicable).

(See also http://www.engelschall.com/u/sb/download/Date-Calc/DIN1355/
for a scan of part of the "DIN 1355" document (in German)).

The module of course handles year numbers of 2000 and above correctly
("Year 2000" or "Y2K" compliance) -- actually all year numbers from 1
to the largest positive integer representable on your system (which is
at least 32767) can be dealt with.

Note that this package EXTRAPOLATES the Gregorian calendar BACK until
the year 1 A.D. -- even though the Gregorian calendar was only adopted
in 1582 by most (not all) European countries, in obedience to the
corresponding decree of catholic pope Gregor I in that year.

Some (mainly protestant) countries continued to use the Julian calendar
(used until then) until as late as the beginning of the 20th century.

Finally, note that this package is not intended to do everything you
could ever imagine automagically for you; it is rather intended to
serve as a toolbox (in the best of UNIX spirit and traditions) which
should, however, always get you where you want to go.

Date::Manip is a series of modules designed to make any common date/time
manipulation easy to do. Operations such as comparing two times,
calculating a time a given amount of time from another, or parsing
international times are all easily done. From the very beginning, the main
focus of Date::Manip has been to be able to do ANY desired date/time
operation easily, not necessarily quickly. Also, it is definitely oriented
towards the type of operations we (as people) tend to think of rather than
those operations used routinely by computers. There are other modules that
can do a subset of the operations available in Date::Manip much quicker
than those presented here, so be sure to read the section SHOULD I USE
DATE::MANIP in the Date::Manip::Misc document before deciding which of the
Date and Time modules from CPAN is for you.

Authors:
--------
Sullivan Beck

DateTime is a class for the representation of date/time combinations,
and is part of the Perl DateTime project. For details on this project
please see http://datetime.perl.org/. The DateTime site has a FAQ which
may help answer many "how do I do X?" questions. The FAQ is at
http://datetime.perl.org/?FAQ.

It represents the Gregorian calendar, extended backwards in time before
its creation (in 1582). This is sometimes known as the "proleptic
Gregorian calendar". In this calendar, the first day of the calendar
(the epoch), is the first day of year 1, which corresponds to the date
which was (incorrectly) believed to be the birth of Jesus Christ.

The calendar represented does have a year 0, and in that way differs
from how dates are often written using "BCE/CE" or "BC/AD".

For infinite datetimes, please see the DateTime::Infinite module.

Author: Dave Rolsky

DateTime::Locale is primarily a factory for the various locale subclasses.
It also provides some functions for getting information on all the
available locales.

If you want to know what methods are available for locale objects,
then please read the DateTime::Locale::Base documentation.

This class is the base class for all time zone objects. A time zone is represented internally as a set of observances, each of which describes the offset from GMT for a given time period.

Note that without the DateTime.pm module, this module does not do much. It's primary interface is through a DateTime object, and most users will not need to directly use DateTime::TimeZone methods.

*DBD::MariaDB* is the Perl5 Database Interface driver for MariaDB and MySQL databases. In other words: DBD::MariaDB is an interface between the Perl programming language and the MariaDB/MySQL programming API that comes with the MariaDB/MySQL relational database management system. Most functions provided by this programming API are supported. Some rarely used functions are missing, mainly because no-one ever requested them.

DBD::mysql is the Perl5 Database Interface driver for the MySQL database. In other words: DBD::mysql is an interface between the Perl programming language and the MySQL programming API that comes with the MySQL relational database management system. Most functions provided by this programming API are supported. Some rarely used functions are missing, mainly because noone ever requested them. :-)

The DBI is a database access module for the Perl programming language.
It defines a set of methods, variables, and conventions that provide a
consistent database interface, independent of the actual database
being used.

Authors:
--------
Tim Bunce

NOTE: Automatically created during Factory devel project migration by admin.

NOTE: Automatically created during Factory devel project migration by admin.

The Devel::StackTrace module contains two classes, Devel::StackTrace and
Devel::StackTraceFrame. The goal of this object is to encapsulate the
information that can found through using the caller() function, as well
as providing a simple interface to this data.

The Devel::StackTrace object contains a set of Devel::StackTraceFrame
objects, one for each level of the stack. The frames contain all the
data available from "caller()".

This code was created to support my Exception::Class::Base class (part
of Exception::Class) but may be useful in other contexts.

Authors: Dave Rolsky,

Devel::Symdump is a Perl module that provides a convenient way to
inspect Perl's symbol table and the class hierarchy within a running
program.

HMAC is used for message integrity checks between two parties that
share a secret key. HMAC works in combination with another Digest
algorithm, usually MD5 or SHA-1. The HMAC mechanism is described in RFC
2104.