This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
384dfc826680f0547b6b7f6cb04e99e6696631fa
[perl5.git] / cpan / Digest / Digest.pm
1 package Digest;
2
3 use strict;
4 use vars qw($VERSION %MMAP $AUTOLOAD);
5
6 $VERSION = "1.16";
7
8 %MMAP = (
9   "SHA-1"      => [["Digest::SHA", 1], "Digest::SHA1", ["Digest::SHA2", 1]],
10   "SHA-224"    => [["Digest::SHA", 224]],
11   "SHA-256"    => [["Digest::SHA", 256], ["Digest::SHA2", 256]],
12   "SHA-384"    => [["Digest::SHA", 384], ["Digest::SHA2", 384]],
13   "SHA-512"    => [["Digest::SHA", 512], ["Digest::SHA2", 512]],
14   "HMAC-MD5"   => "Digest::HMAC_MD5",
15   "HMAC-SHA-1" => "Digest::HMAC_SHA1",
16   "CRC-16"     => [["Digest::CRC", type => "crc16"]],
17   "CRC-32"     => [["Digest::CRC", type => "crc32"]],
18   "CRC-CCITT"  => [["Digest::CRC", type => "crcccitt"]],
19   "RIPEMD-160" => "Crypt::PIPEMD160",
20 );
21
22 sub new
23 {
24     shift;  # class ignored
25     my $algorithm = shift;
26     my $impl = $MMAP{$algorithm} || do {
27         $algorithm =~ s/\W+//;
28         "Digest::$algorithm";
29     };
30     $impl = [$impl] unless ref($impl);
31     my $err;
32     for  (@$impl) {
33         my $class = $_;
34         my @args;
35         ($class, @args) = @$class if ref($class);
36         no strict 'refs';
37         unless (exists ${"$class\::"}{"VERSION"}) {
38             eval "require $class";
39             if ($@) {
40                 $err ||= $@;
41                 next;
42             }
43         }
44         return $class->new(@args, @_);
45     }
46     die $err;
47 }
48
49 sub AUTOLOAD
50 {
51     my $class = shift;
52     my $algorithm = substr($AUTOLOAD, rindex($AUTOLOAD, '::')+2);
53     $class->new($algorithm, @_);
54 }
55
56 1;
57
58 __END__
59
60 =head1 NAME
61
62 Digest - Modules that calculate message digests
63
64 =head1 SYNOPSIS
65
66   $md5  = Digest->new("MD5");
67   $sha1 = Digest->new("SHA-1");
68   $sha256 = Digest->new("SHA-256");
69   $sha384 = Digest->new("SHA-384");
70   $sha512 = Digest->new("SHA-512");
71
72   $hmac = Digest->HMAC_MD5($key);
73
74 =head1 DESCRIPTION
75
76 The C<Digest::> modules calculate digests, also called "fingerprints"
77 or "hashes", of some data, called a message.  The digest is (usually)
78 some small/fixed size string.  The actual size of the digest depend of
79 the algorithm used.  The message is simply a sequence of arbitrary
80 bytes or bits.
81
82 An important property of the digest algorithms is that the digest is
83 I<likely> to change if the message change in some way.  Another
84 property is that digest functions are one-way functions, that is it
85 should be I<hard> to find a message that correspond to some given
86 digest.  Algorithms differ in how "likely" and how "hard", as well as
87 how efficient they are to compute.
88
89 Note that the properties of the algorithms change over time, as the
90 algorithms are analyzed and machines grow faster.  If your application
91 for instance depends on it being "impossible" to generate the same
92 digest for a different message it is wise to make it easy to plug in
93 stronger algorithms as the one used grow weaker.  Using the interface
94 documented here should make it easy to change algorithms later.
95
96 All C<Digest::> modules provide the same programming interface.  A
97 functional interface for simple use, as well as an object oriented
98 interface that can handle messages of arbitrary length and which can
99 read files directly.
100
101 The digest can be delivered in three formats:
102
103 =over 8
104
105 =item I<binary>
106
107 This is the most compact form, but it is not well suited for printing
108 or embedding in places that can't handle arbitrary data.
109
110 =item I<hex>
111
112 A twice as long string of lowercase hexadecimal digits.
113
114 =item I<base64>
115
116 A string of portable printable characters.  This is the base64 encoded
117 representation of the digest with any trailing padding removed.  The
118 string will be about 30% longer than the binary version.
119 L<MIME::Base64> tells you more about this encoding.
120
121 =back
122
123
124 The functional interface is simply importable functions with the same
125 name as the algorithm.  The functions take the message as argument and
126 return the digest.  Example:
127
128   use Digest::MD5 qw(md5);
129   $digest = md5($message);
130
131 There are also versions of the functions with "_hex" or "_base64"
132 appended to the name, which returns the digest in the indicated form.
133
134 =head1 OO INTERFACE
135
136 The following methods are available for all C<Digest::> modules:
137
138 =over 4
139
140 =item $ctx = Digest->XXX($arg,...)
141
142 =item $ctx = Digest->new(XXX => $arg,...)
143
144 =item $ctx = Digest::XXX->new($arg,...)
145
146 The constructor returns some object that encapsulate the state of the
147 message-digest algorithm.  You can add data to the object and finally
148 ask for the digest.  The "XXX" should of course be replaced by the proper
149 name of the digest algorithm you want to use.
150
151 The two first forms are simply syntactic sugar which automatically
152 load the right module on first use.  The second form allow you to use
153 algorithm names which contains letters which are not legal perl
154 identifiers, e.g. "SHA-1".  If no implementation for the given algorithm
155 can be found, then an exception is raised.
156
157 If new() is called as an instance method (i.e. $ctx->new) it will just
158 reset the state the object to the state of a newly created object.  No
159 new object is created in this case, and the return value is the
160 reference to the object (i.e. $ctx).
161
162 =item $other_ctx = $ctx->clone
163
164 The clone method creates a copy of the digest state object and returns
165 a reference to the copy.
166
167 =item $ctx->reset
168
169 This is just an alias for $ctx->new.
170
171 =item $ctx->add( $data )
172
173 =item $ctx->add( $chunk1, $chunk2, ... )
174
175 The string value of the $data provided as argument is appended to the
176 message we calculate the digest for.  The return value is the $ctx
177 object itself.
178
179 If more arguments are provided then they are all appended to the
180 message, thus all these lines will have the same effect on the state
181 of the $ctx object:
182
183   $ctx->add("a"); $ctx->add("b"); $ctx->add("c");
184   $ctx->add("a")->add("b")->add("c");
185   $ctx->add("a", "b", "c");
186   $ctx->add("abc");
187
188 Most algorithms are only defined for strings of bytes and this method
189 might therefore croak if the provided arguments contain chars with
190 ordinal number above 255.
191
192 =item $ctx->addfile( $io_handle )
193
194 The $io_handle is read until EOF and the content is appended to the
195 message we calculate the digest for.  The return value is the $ctx
196 object itself.
197
198 The addfile() method will croak() if it fails reading data for some
199 reason.  If it croaks it is unpredictable what the state of the $ctx
200 object will be in. The addfile() method might have been able to read
201 the file partially before it failed.  It is probably wise to discard
202 or reset the $ctx object if this occurs.
203
204 In most cases you want to make sure that the $io_handle is in
205 "binmode" before you pass it as argument to the addfile() method.
206
207 =item $ctx->add_bits( $data, $nbits )
208
209 =item $ctx->add_bits( $bitstring )
210
211 The add_bits() method is an alternative to add() that allow partial
212 bytes to be appended to the message.  Most users should just ignore
213 this method as partial bytes is very unlikely to be of any practical
214 use.
215
216 The two argument form of add_bits() will add the first $nbits bits
217 from $data.  For the last potentially partial byte only the high order
218 C<< $nbits % 8 >> bits are used.  If $nbits is greater than C<<
219 length($data) * 8 >>, then this method would do the same as C<<
220 $ctx->add($data) >>.
221
222 The one argument form of add_bits() takes a $bitstring of "1" and "0"
223 chars as argument.  It's a shorthand for C<< $ctx->add_bits(pack("B*",
224 $bitstring), length($bitstring)) >>.
225
226 The return value is the $ctx object itself.
227
228 This example shows two calls that should have the same effect:
229
230    $ctx->add_bits("111100001010");
231    $ctx->add_bits("\xF0\xA0", 12);
232
233 Most digest algorithms are byte based and for these it is not possible
234 to add bits that are not a multiple of 8, and the add_bits() method
235 will croak if you try.
236
237 =item $ctx->digest
238
239 Return the binary digest for the message.
240
241 Note that the C<digest> operation is effectively a destructive,
242 read-once operation. Once it has been performed, the $ctx object is
243 automatically C<reset> and can be used to calculate another digest
244 value.  Call $ctx->clone->digest if you want to calculate the digest
245 without resetting the digest state.
246
247 =item $ctx->hexdigest
248
249 Same as $ctx->digest, but will return the digest in hexadecimal form.
250
251 =item $ctx->b64digest
252
253 Same as $ctx->digest, but will return the digest as a base64 encoded
254 string.
255
256 =back
257
258 =head1 Digest speed
259
260 This table should give some indication on the relative speed of
261 different algorithms.  It is sorted by throughput based on a benchmark
262 done with of some implementations of this API:
263
264  Algorithm      Size    Implementation                  MB/s
265
266  MD4            128     Digest::MD4 v1.3               165.0
267  MD5            128     Digest::MD5 v2.33               98.8
268  SHA-256        256     Digest::SHA2 v1.1.0             66.7
269  SHA-1          160     Digest::SHA v4.3.1              58.9
270  SHA-1          160     Digest::SHA1 v2.10              48.8
271  SHA-256        256     Digest::SHA v4.3.1              41.3
272  Haval-256      256     Digest::Haval256 v1.0.4         39.8
273  SHA-384        384     Digest::SHA2 v1.1.0             19.6
274  SHA-512        512     Digest::SHA2 v1.1.0             19.3
275  SHA-384        384     Digest::SHA v4.3.1              19.2
276  SHA-512        512     Digest::SHA v4.3.1              19.2
277  Whirlpool      512     Digest::Whirlpool v1.0.2        13.0
278  MD2            128     Digest::MD2 v2.03                9.5
279
280  Adler-32        32     Digest::Adler32 v0.03            1.3
281  CRC-16          16     Digest::CRC v0.05                1.1
282  CRC-32          32     Digest::CRC v0.05                1.1
283  MD5            128     Digest::Perl::MD5 v1.5           1.0
284  CRC-CCITT       16     Digest::CRC v0.05                0.8
285
286 These numbers was achieved Apr 2004 with ActivePerl-5.8.3 running
287 under Linux on a P4 2.8 GHz CPU.  The last 5 entries differ by being
288 pure perl implementations of the algorithms, which explains why they
289 are so slow.
290
291 =head1 SEE ALSO
292
293 L<Digest::Adler32>, L<Digest::CRC>, L<Digest::Haval256>,
294 L<Digest::HMAC>, L<Digest::MD2>, L<Digest::MD4>, L<Digest::MD5>,
295 L<Digest::SHA>, L<Digest::SHA1>, L<Digest::SHA2>, L<Digest::Whirlpool>
296
297 New digest implementations should consider subclassing from L<Digest::base>.
298
299 L<MIME::Base64>
300
301 http://en.wikipedia.org/wiki/Cryptographic_hash_function
302
303 =head1 AUTHOR
304
305 Gisle Aas <gisle@aas.no>
306
307 The C<Digest::> interface is based on the interface originally
308 developed by Neil Winton for his C<MD5> module.
309
310 This library is free software; you can redistribute it and/or
311 modify it under the same terms as Perl itself.
312
313     Copyright 1998-2006 Gisle Aas.
314     Copyright 1995,1996 Neil Winton.
315
316 =cut