FM / perl5

/usr/share/perl5

Name	Size	Mode	Actions
App/	-	0755	rm
Archive/	-	0755	rm
Attribute/	-	0755	rm
autodie/	-	0755	rm
B/	-	0755	rm
Carp/	-	0755	rm
CGI/	-	0755	rm
Class/	-	0755	rm
Config/	-	0755	rm
CPAN/	-	0755	rm
CPANPLUS/	-	0755	rm
DBIx/	-	0755	rm
DBM_Filter/	-	0755	rm
Devel/	-	0755	rm
Digest/	-	0755	rm
Encode/	-	0755	rm
encoding/	-	0755	rm
Exporter/	-	0755	rm
ExtUtils/	-	0755	rm
File/	-	0755	rm
Filter/	-	0755	rm
Getopt/	-	0755	rm
HTML/	-	0755	rm
I18N/	-	0755	rm
IO/	-	0755	rm
IPC/	-	0755	rm
JSON/	-	0755	rm
Locale/	-	0755	rm
Log/	-	0755	rm
Math/	-	0755	rm
Memoize/	-	0755	rm
Module/	-	0755	rm
Net/	-	0755	rm
Object/	-	0755	rm
overload/	-	0755	rm
Package/	-	0755	rm
Params/	-	0755	rm
Parse/	-	0755	rm
PerlIO/	-	0755	rm
Pod/	-	0755	rm
pod/	-	0755	rm
Search/	-	0755	rm
TAP/	-	0755	rm
Term/	-	0755	rm
Test/	-	0755	rm
Test2/	-	0755	rm
Text/	-	0755	rm
Thread/	-	0755	rm
Tie/	-	0755	rm
Time/	-	0755	rm
Unicode/	-	0755	rm
unicore/	-	0755	rm
URI/	-	0755	rm
User/	-	0755	rm
vendor_perl/	-	0755	rm
version/	-	0755	rm
warnings/	-	0755	rm
abbrev.pl	838	0644	edit dl rm
AnyDBM_File.pm	2594	0644	edit dl rm
assert.pl	1298	0644	edit dl rm
attributes.pm	14877	0644	edit dl rm
autodie.pm	11763	0644	edit dl rm
AutoLoader.pm	14997	0644	edit dl rm
AutoSplit.pm	19637	0644	edit dl rm
autouse.pm	4238	0644	edit dl rm
base.pm	6986	0644	edit dl rm
Benchmark.pm	28530	0644	edit dl rm
bigfloat.pl	7368	0644	edit dl rm
bigint.pl	8959	0644	edit dl rm
bigint.pm	17852	0644	edit dl rm
bignum.pm	18673	0644	edit dl rm
bigrat.pl	4476	0644	edit dl rm
bigrat.pm	14442	0644	edit dl rm
blib.pm	2106	0644	edit dl rm
bytes.pm	2384	0644	edit dl rm
bytes_heavy.pl	758	0644	edit dl rm
cacheout.pl	1122	0644	edit dl rm
Carp.pm	7611	0644	edit dl rm
CGI.pm	261478	0644	edit dl rm
charnames.pm	15670	0644	edit dl rm
complete.pl	3191	0644	edit dl rm
constant.pm	12528	0644	edit dl rm
CORE.pod	1569	0644	edit dl rm
CPAN.pm	130907	0644	edit dl rm
CPANPLUS.pm	7269	0644	edit dl rm
ctime.pl	1993	0644	edit dl rm
DB.pm	19202	0644	edit dl rm
DBM_Filter.pm	14415	0644	edit dl rm
diagnostics.pm	17380	0644	edit dl rm
Digest.pm	10412	0644	edit dl rm
DirHandle.pm	1937	0644	edit dl rm
dotsh.pl	2175	0644	edit dl rm
Dumpvalue.pm	16899	0644	edit dl rm
dumpvar.pl	15275	0644	edit dl rm
English.pm	4488	0644	edit dl rm
Env.pm	5170	0644	edit dl rm
exceptions.pl	1736	0644	edit dl rm
Expect.pm	54725	0644	edit dl rm
Expect.pod	43735	0644	edit dl rm
Exporter.pm	18595	0644	edit dl rm
fastcwd.pl	1019	0644	edit dl rm
Fatal.pm	40966	0644	edit dl rm
feature.pm	5092	0644	edit dl rm
fields.pm	9507	0644	edit dl rm
FileCache.pm	5570	0644	edit dl rm
FileHandle.pm	6778	0644	edit dl rm
filetest.pm	4003	0644	edit dl rm
find.pl	1185	0644	edit dl rm
FindBin.pm	5658	0644	edit dl rm
finddepth.pl	1130	0644	edit dl rm
flush.pl	642	0644	edit dl rm
getcwd.pl	1427	0644	edit dl rm
getopt.pl	1322	0644	edit dl rm
getopts.pl	1406	0644	edit dl rm
hostname.pl	727	0644	edit dl rm
if.pm	1166	0644	edit dl rm
importenv.pl	283	0644	edit dl rm
integer.pm	3266	0644	edit dl rm
less.pm	3084	0644	edit dl rm
locale.pm	820	0644	edit dl rm
look.pl	1255	0644	edit dl rm
Memoize.pm	35295	0644	edit dl rm
newgetopt.pl	2213	0644	edit dl rm
NEXT.pm	18481	0644	edit dl rm
ok.pm	967	0444	edit dl rm
open.pm	7740	0644	edit dl rm
open2.pl	185	0644	edit dl rm
open3.pl	185	0644	edit dl rm
overload.pm	48050	0644	edit dl rm
overloading.pm	1801	0644	edit dl rm
parent.pm	2998	0644	edit dl rm
perl5db.pl	317682	0644	edit dl rm
PerlIO.pm	11122	0644	edit dl rm
pwd.pl	1478	0644	edit dl rm
Safe.pm	24326	0644	edit dl rm
SelectSaver.pm	1076	0644	edit dl rm
SelfLoader.pm	17341	0644	edit dl rm
Shell.pm	8685	0644	edit dl rm
shellwords.pl	276	0644	edit dl rm
sigtrap.pm	7611	0644	edit dl rm
sort.pm	6093	0644	edit dl rm
stat.pl	590	0644	edit dl rm
strict.pm	3716	0644	edit dl rm
subs.pm	842	0644	edit dl rm
Switch.pm	28508	0644	edit dl rm
Symbol.pm	4794	0644	edit dl rm
syslog.pl	4806	0644	edit dl rm
tainted.pl	164	0644	edit dl rm
termcap.pl	4114	0644	edit dl rm
Test.pm	28800	0644	edit dl rm
Test2.pm	6393	0444	edit dl rm
Thread.pm	8285	0644	edit dl rm
timelocal.pl	690	0644	edit dl rm
UNIVERSAL.pm	6536	0644	edit dl rm
utf8.pm	6918	0644	edit dl rm
utf8_heavy.pl	8001	0644	edit dl rm
validate.pl	3731	0644	edit dl rm
vars.pm	2358	0644	edit dl rm
version.pm	1037	0644	edit dl rm
version.pod	12315	0644	edit dl rm
vmsish.pm	4328	0644	edit dl rm
warnings.pm	16133	0644	edit dl rm

Edit: /usr/share/perl5/Digest.pm (10412B)

package Digest;

use strict;
use vars qw($VERSION %MMAP $AUTOLOAD);

$VERSION = "1.16";

%MMAP = (
  "SHA-1"      => [["Digest::SHA", 1], "Digest::SHA1", ["Digest::SHA2", 1]],
  "SHA-224"    => [["Digest::SHA", 224]],
  "SHA-256"    => [["Digest::SHA", 256], ["Digest::SHA2", 256]],
  "SHA-384"    => [["Digest::SHA", 384], ["Digest::SHA2", 384]],
  "SHA-512"    => [["Digest::SHA", 512], ["Digest::SHA2", 512]],
  "HMAC-MD5"   => "Digest::HMAC_MD5",
  "HMAC-SHA-1" => "Digest::HMAC_SHA1",
  "CRC-16"     => [["Digest::CRC", type => "crc16"]],
  "CRC-32"     => [["Digest::CRC", type => "crc32"]],
  "CRC-CCITT"  => [["Digest::CRC", type => "crcccitt"]],
  "RIPEMD-160" => "Crypt::PIPEMD160",
);

sub new
{
    shift;  # class ignored
    my $algorithm = shift;
    my $impl = $MMAP{$algorithm} || do {
	$algorithm =~ s/\W+//;
	"Digest::$algorithm";
    };
    $impl = [$impl] unless ref($impl);
    my $err;
    for  (@$impl) {
	my $class = $_;
	my @args;
	($class, @args) = @$class if ref($class);
	no strict 'refs';
	unless (exists ${"$class\::"}{"VERSION"}) {
		my $pm_file = $class . ".pm";
		$pm_file =~ s{::}{/}g;
		eval { require $pm_file };
	    if ($@) {
		$err ||= $@;
		next;
	    }
	}
	return $class->new(@args, @_);
    }
    die $err;
}

sub AUTOLOAD
{
    my $class = shift;
    my $algorithm = substr($AUTOLOAD, rindex($AUTOLOAD, '::')+2);
    $class->new($algorithm, @_);
}

__END__

=head1 NAME

Digest - Modules that calculate message digests

=head1 SYNOPSIS

$md5  = Digest->new("MD5");
  $sha1 = Digest->new("SHA-1");
  $sha256 = Digest->new("SHA-256");
  $sha384 = Digest->new("SHA-384");
  $sha512 = Digest->new("SHA-512");

$hmac = Digest->HMAC_MD5($key);

=head1 DESCRIPTION

The C<Digest::> modules calculate digests, also called "fingerprints"
or "hashes", of some data, called a message.  The digest is (usually)
some small/fixed size string.  The actual size of the digest depend of
the algorithm used.  The message is simply a sequence of arbitrary
bytes or bits.

An important property of the digest algorithms is that the digest is
I<likely> to change if the message change in some way.  Another
property is that digest functions are one-way functions, that is it
should be I<hard> to find a message that correspond to some given
digest.  Algorithms differ in how "likely" and how "hard", as well as
how efficient they are to compute.

Note that the properties of the algorithms change over time, as the
algorithms are analyzed and machines grow faster.  If your application
for instance depends on it being "impossible" to generate the same
digest for a different message it is wise to make it easy to plug in
stronger algorithms as the one used grow weaker.  Using the interface
documented here should make it easy to change algorithms later.

All C<Digest::> modules provide the same programming interface.  A
functional interface for simple use, as well as an object oriented
interface that can handle messages of arbitrary length and which can
read files directly.

The digest can be delivered in three formats:

=over 8

=item I<binary>

This is the most compact form, but it is not well suited for printing
or embedding in places that can't handle arbitrary data.

=item I<hex>

A twice as long string of lowercase hexadecimal digits.

=item I<base64>

A string of portable printable characters.  This is the base64 encoded
representation of the digest with any trailing padding removed.  The
string will be about 30% longer than the binary version.
L<MIME::Base64> tells you more about this encoding.

=back

The functional interface is simply importable functions with the same
name as the algorithm.  The functions take the message as argument and
return the digest.  Example:

use Digest::MD5 qw(md5);
  $digest = md5($message);

There are also versions of the functions with "_hex" or "_base64"
appended to the name, which returns the digest in the indicated form.

=head1 OO INTERFACE

The following methods are available for all C<Digest::> modules:

=over 4

=item $ctx = Digest->XXX($arg,...)

=item $ctx = Digest->new(XXX => $arg,...)

=item $ctx = Digest::XXX->new($arg,...)

The constructor returns some object that encapsulate the state of the
message-digest algorithm.  You can add data to the object and finally
ask for the digest.  The "XXX" should of course be replaced by the proper
name of the digest algorithm you want to use.

The two first forms are simply syntactic sugar which automatically
load the right module on first use.  The second form allow you to use
algorithm names which contains letters which are not legal perl
identifiers, e.g. "SHA-1".  If no implementation for the given algorithm
can be found, then an exception is raised.

If new() is called as an instance method (i.e. $ctx->new) it will just
reset the state the object to the state of a newly created object.  No
new object is created in this case, and the return value is the
reference to the object (i.e. $ctx).

=item $other_ctx = $ctx->clone

The clone method creates a copy of the digest state object and returns
a reference to the copy.

=item $ctx->reset

This is just an alias for $ctx->new.

=item $ctx->add( $data )

=item $ctx->add( $chunk1, $chunk2, ... )

The string value of the $data provided as argument is appended to the
message we calculate the digest for.  The return value is the $ctx
object itself.

If more arguments are provided then they are all appended to the
message, thus all these lines will have the same effect on the state
of the $ctx object:

$ctx->add("a"); $ctx->add("b"); $ctx->add("c");
  $ctx->add("a")->add("b")->add("c");
  $ctx->add("a", "b", "c");
  $ctx->add("abc");

Most algorithms are only defined for strings of bytes and this method
might therefore croak if the provided arguments contain chars with
ordinal number above 255.

=item $ctx->addfile( $io_handle )

The $io_handle is read until EOF and the content is appended to the
message we calculate the digest for.  The return value is the $ctx
object itself.

The addfile() method will croak() if it fails reading data for some
reason.  If it croaks it is unpredictable what the state of the $ctx
object will be in. The addfile() method might have been able to read
the file partially before it failed.  It is probably wise to discard
or reset the $ctx object if this occurs.

In most cases you want to make sure that the $io_handle is in
"binmode" before you pass it as argument to the addfile() method.

=item $ctx->add_bits( $data, $nbits )

=item $ctx->add_bits( $bitstring )

The add_bits() method is an alternative to add() that allow partial
bytes to be appended to the message.  Most users should just ignore
this method as partial bytes is very unlikely to be of any practical
use.

The two argument form of add_bits() will add the first $nbits bits
from $data.  For the last potentially partial byte only the high order
C<< $nbits % 8 >> bits are used.  If $nbits is greater than C<<
length($data) * 8 >>, then this method would do the same as C<<
$ctx->add($data) >>.

The one argument form of add_bits() takes a $bitstring of "1" and "0"
chars as argument.  It's a shorthand for C<< $ctx->add_bits(pack("B*",
$bitstring), length($bitstring)) >>.

The return value is the $ctx object itself.

This example shows two calls that should have the same effect:

$ctx->add_bits("111100001010");
   $ctx->add_bits("\xF0\xA0", 12);

Most digest algorithms are byte based and for these it is not possible
to add bits that are not a multiple of 8, and the add_bits() method
will croak if you try.

=item $ctx->digest

Return the binary digest for the message.

Note that the C<digest> operation is effectively a destructive,
read-once operation. Once it has been performed, the $ctx object is
automatically C<reset> and can be used to calculate another digest
value.  Call $ctx->clone->digest if you want to calculate the digest
without resetting the digest state.

=item $ctx->hexdigest

Same as $ctx->digest, but will return the digest in hexadecimal form.

=item $ctx->b64digest

Same as $ctx->digest, but will return the digest as a base64 encoded
string.

=back

=head1 Digest speed

This table should give some indication on the relative speed of
different algorithms.  It is sorted by throughput based on a benchmark
done with of some implementations of this API:

Algorithm      Size    Implementation                  MB/s

MD4            128     Digest::MD4 v1.3               165.0
 MD5            128     Digest::MD5 v2.33               98.8
 SHA-256        256     Digest::SHA2 v1.1.0             66.7
 SHA-1          160     Digest::SHA v4.3.1              58.9
 SHA-1          160     Digest::SHA1 v2.10              48.8
 SHA-256        256     Digest::SHA v4.3.1              41.3
 Haval-256      256     Digest::Haval256 v1.0.4         39.8
 SHA-384        384     Digest::SHA2 v1.1.0             19.6
 SHA-512        512     Digest::SHA2 v1.1.0             19.3
 SHA-384        384     Digest::SHA v4.3.1              19.2
 SHA-512        512     Digest::SHA v4.3.1              19.2
 Whirlpool      512     Digest::Whirlpool v1.0.2        13.0
 MD2            128     Digest::MD2 v2.03                9.5

Adler-32        32     Digest::Adler32 v0.03            1.3
 CRC-16          16     Digest::CRC v0.05                1.1
 CRC-32          32     Digest::CRC v0.05                1.1
 MD5            128     Digest::Perl::MD5 v1.5           1.0
 CRC-CCITT       16     Digest::CRC v0.05                0.8

These numbers was achieved Apr 2004 with ActivePerl-5.8.3 running
under Linux on a P4 2.8 GHz CPU.  The last 5 entries differ by being
pure perl implementations of the algorithms, which explains why they
are so slow.

=head1 SEE ALSO

L<Digest::Adler32>, L<Digest::CRC>, L<Digest::Haval256>,
L<Digest::HMAC>, L<Digest::MD2>, L<Digest::MD4>, L<Digest::MD5>,
L<Digest::SHA>, L<Digest::SHA1>, L<Digest::SHA2>, L<Digest::Whirlpool>

New digest implementations should consider subclassing from L<Digest::base>.

L<MIME::Base64>

http://en.wikipedia.org/wiki/Cryptographic_hash_function

=head1 AUTHOR

Gisle Aas <gisle@aas.no>

The C<Digest::> interface is based on the interface originally
developed by Neil Winton for his C<MD5> module.

This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=cut

cmd: