81 some small/fixed size string.  The actual size of the digest depend of
82 the algorithm used.  The message is simply a sequence of arbitrary
85 An important property of the digest algorithms is that the digest is
86 I<likely> to change if the message change in some way.  Another
92 Note that the properties of the algorithms change over time, as the
94 for instance depends on it being "impossible" to generate the same
96 stronger algorithms as the one used grow weaker.  Using the interface
99 All C<Digest::> modules provide the same programming interface.  A
110 This is the most compact form, but it is not well suited for printing
119 A string of portable printable characters.  This is the base64 encoded
120 representation of the digest with any trailing padding removed.  The
121 string will be about 30% longer than the binary version.
127 The functional interface is simply importable functions with the same
128 name as the algorithm.  The functions take the message as argument and
129 return the digest.  Example:
134 There are also versions of the functions with "_hex" or "_base64"
135 appended to the name, which returns the digest in the indicated form.
149 The constructor returns some object that encapsulate the state of the
150 message-digest algorithm.  You can add data to the object and finally
151 ask for the digest.  The "XXX" should of course be replaced by the proper
152 name of the digest algorithm you want to use.
155 load the right module on first use.  The second form allow you to use
157 identifiers, e.g. "SHA-1".  If no implementation for the given algorithm
161 reset the state the object to the state of a newly created object.  No
162 new object is created in this case, and the return value is the
163 reference to the object (i.e. $ctx).
167 The clone method creates a copy of the digest state object and returns
168 a reference to the copy.
178 The string value of the $data provided as argument is appended to the
179 message we calculate the digest for.  The return value is the $ctx
182 If more arguments are provided then they are all appended to the
183 message, thus all these lines will have the same effect on the state
184 of the $ctx object:
192 might therefore croak if the provided arguments contain chars with
197 The $io_handle is read until EOF and the content is appended to the
198 message we calculate the digest for.  The return value is the $ctx
202 reason.  If it croaks it is unpredictable what the state of the $ctx
204 the file partially before it failed.  It is probably wise to discard
205 or reset the $ctx object if this occurs.
207 In most cases you want to make sure that the $io_handle is in
208 "binmode" before you pass it as argument to the addfile() method.
215 bytes to be appended to the message.  Most users should just ignore
219 The two argument form of add_bits() will add the first $nbits bits
220 from $data.  For the last potentially partial byte only the high order
222 length($data) * 8 >>, then this method would do the same as C<<
229 The return value is the $ctx object itself.
231 This example shows two calls that should have the same effect:
237 to add bits that are not a multiple of 8, and the add_bits() method
242 Return the binary digest for the message.
244 Note that the C<digest> operation is effectively a destructive,
245 read-once operation. Once it has been performed, the $ctx object is
247 value.  Call $ctx->clone->digest if you want to calculate the digest
248 without resetting the digest state.
252 Same as $ctx->digest, but will return the digest in hexadecimal form.
256 Same as $ctx->digest, but will return the digest as a base64 encoded
263 This table should give some indication on the relative speed of
291 pure perl implementations of the algorithms, which explains why they
310 The C<Digest::> interface is based on the interface originally
314 modify it under the same terms as Perl itself.

Indexes created Tue Jul 24 14:28:13 CEST 2018