dslinux/user/perl/ext/Digest/MD5 Changes MD5.pm MD5.xs Makefile.PL README typemap
cayenne
dslinux_cayenne at user.in-berlin.de
Tue Dec 5 05:26:34 CET 2006
Update of /cvsroot/dslinux/dslinux/user/perl/ext/Digest/MD5
In directory antilope:/tmp/cvs-serv7729/ext/Digest/MD5
Added Files:
Changes MD5.pm MD5.xs Makefile.PL README typemap
Log Message:
Adding fresh perl source to HEAD to branch from
--- NEW FILE: Makefile.PL ---
#!perl -w
BEGIN { require 5.006 }
use strict;
use Config qw(%Config);
use ExtUtils::MakeMaker;
my $PERL_CORE = grep $_ eq "PERL_CORE=1", @ARGV;
my @extra;
@extra = (DEFINE => "-DU32_ALIGNMENT_REQUIRED") unless free_u32_alignment();
if ($^O eq 'VMS') {
if (defined($Config{ccname})) {
if (grep(/VMS_VAX/, @INC) && ($Config{ccname} eq 'DEC')) {
# VAX compiler optimizer even as late as v6.4 gets stuck
push(@extra, OPTIMIZE => "/Optimize=(NODISJOINT)");
}
}
}
push(@extra, 'INSTALLDIRS' => 'perl') if $] >= 5.008;
push(@extra, 'MAN3PODS' => {}) if $PERL_CORE; # Pods built by installman.
WriteMakefile(
'NAME' => 'Digest::MD5',
'VERSION_FROM' => 'MD5.pm',
'PREREQ_PM' => { 'File::Spec' => 0,
'Digest::base' => '1.00',
},
@extra,
'dist' => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', },
);
sub free_u32_alignment
{
$|=1;
if (exists $Config{d_u32align}) {
print "Perl's config says that U32 access must ";
print "not " unless $Config{d_u32align};
print "be aligned.\n";
return !$Config{d_u32align};
}
if ($^O eq 'VMS' || $^O eq 'MSWin32') {
print "Assumes that $^O implies free alignment for U32 access.\n";
return 1;
}
if ($^O eq 'hpux' && $Config{osvers} < 11.0) {
print "Will not test for free alignment on older HP-UX.\n";
return 0;
}
print "Testing alignment requirements for U32... ";
open(ALIGN_TEST, ">u32align.c") or die "$!";
print ALIGN_TEST <<'EOT'; close(ALIGN_TEST);
/*--------------------------------------------------------------*/
/* This program allocates a buffer of U8 (char) and then tries */
/* to access it through a U32 pointer at every offset. The */
/* program is expected to die with a bus error/seg fault for */
/* machines that do not support unaligned integer read/write */
/*--------------------------------------------------------------*/
#include <stdio.h>
#include "EXTERN.h"
#include "perl.h"
#ifdef printf
#undef printf
#endif
int main(int argc, char** argv, char** env)
{
#if BYTEORDER == 0x1234 || BYTEORDER == 0x4321
U8 buf[] = "\0\0\0\1\0\0\0\0";
U32 *up;
int i;
if (sizeof(U32) != 4) {
printf("sizeof(U32) is not 4, but %d\n", sizeof(U32));
exit(1);
}
fflush(stdout);
for (i = 0; i < 4; i++) {
up = (U32*)(buf + i);
if (! ((*up == 1 << (8*i)) || /* big-endian */
(*up == 1 << (8*(3-i))) /* little-endian */
)
)
{
printf("read failed (%x)\n", *up);
exit(2);
}
}
/* write test */
for (i = 0; i < 4; i++) {
up = (U32*)(buf + i);
*up = 0xBeef;
if (*up != 0xBeef) {
printf("write failed (%x)\n", *up);
exit(3);
}
}
printf("no restrictions\n");
exit(0);
#else
printf("unusual byteorder, playing safe\n");
exit(1);
#endif
return 0;
}
/*--------------------------------------------------------------*/
EOT
my $cc_cmd = "$Config{cc} $Config{ccflags} -I$Config{archlibexp}/CORE";
my $exe = "u32align$Config{exe_ext}";
$cc_cmd .= " -o $exe";
my $rc;
$rc = system("$cc_cmd $Config{ldflags} u32align.c $Config{libs}");
if ($rc) {
print "Can't compile test program. Will ensure alignment to play safe.\n\n";
unlink("u32align.c", $exe, "u32align$Config{obj_ext}");
return 0;
}
$rc = system("./$exe");
unlink("u32align.c", $exe, "u32align$Config{obj_ext}");
return 1 unless $rc;
if ($rc > 0x80) {
(my $cp = $rc) >>= 8;
print "Test program exit status was $cp\n";
}
if ($rc & 0x80) {
$rc &= ~0x80;
unlink("core") && print "Core dump deleted\n";
}
print "signal $rc\n" if $rc && $rc < 0x80;
return 0;
}
--- NEW FILE: MD5.pm ---
package Digest::MD5;
use strict;
use vars qw($VERSION @ISA @EXPORT_OK);
$VERSION = '2.36'; # $Date: 2006-12-05 04:26:32 $
require Exporter;
*import = \&Exporter::import;
@EXPORT_OK = qw(md5 md5_hex md5_base64);
eval {
require Digest::base;
push(@ISA, 'Digest::base');
};
if ($@) {
my $err = $@;
*add_bits = sub { die $err };
}
eval {
require XSLoader;
XSLoader::load('Digest::MD5', $VERSION);
};
if ($@) {
my $olderr = $@;
eval {
# Try to load the pure perl version
require Digest::Perl::MD5;
Digest::Perl::MD5->import(qw(md5 md5_hex md5_base64));
push(@ISA, "Digest::Perl::MD5"); # make OO interface work
};
if ($@) {
# restore the original error
die $olderr;
}
}
else {
*reset = \&new;
}
1;
__END__
=head1 NAME
Digest::MD5 - Perl interface to the MD5 Algorithm
=head1 SYNOPSIS
# Functional style
use Digest::MD5 qw(md5 md5_hex md5_base64);
$digest = md5($data);
$digest = md5_hex($data);
$digest = md5_base64($data);
# OO style
use Digest::MD5;
$ctx = Digest::MD5->new;
$ctx->add($data);
$ctx->addfile(*FILE);
$digest = $ctx->digest;
$digest = $ctx->hexdigest;
$digest = $ctx->b64digest;
=head1 DESCRIPTION
The C<Digest::MD5> module allows you to use the RSA Data Security
Inc. MD5 Message Digest algorithm from within Perl programs. The
algorithm takes as input a message of arbitrary length and produces as
output a 128-bit "fingerprint" or "message digest" of the input.
Note that the MD5 algorithm is not as strong as it used to be. It has
since 2005 been easy to generate different messages that produce the
same MD5 digest. It still seems hard to generate messages that
produce a given digest, but it is probably wise to move to stronger
algorithms for applications that depend on the digest to uniquely identify
a message.
The C<Digest::MD5> module provide a procedural interface for simple
use, as well as an object oriented interface that can handle messages
of arbitrary length and which can read files directly.
=head1 FUNCTIONS
The following functions are provided by the C<Digest::MD5> module.
None of these functions are exported by default.
=over 4
=item md5($data,...)
This function will concatenate all arguments, calculate the MD5 digest
of this "message", and return it in binary form. The returned string
will be 16 bytes long.
The result of md5("a", "b", "c") will be exactly the same as the
result of md5("abc").
=item md5_hex($data,...)
Same as md5(), but will return the digest in hexadecimal form. The
length of the returned string will be 32 and it will only contain
characters from this set: '0'..'9' and 'a'..'f'.
=item md5_base64($data,...)
Same as md5(), but will return the digest as a base64 encoded string.
The length of the returned string will be 22 and it will only contain
characters from this set: 'A'..'Z', 'a'..'z', '0'..'9', '+' and
'/'.
Note that the base64 encoded string returned is not padded to be a
multiple of 4 bytes long. If you want interoperability with other
base64 encoded md5 digests you might want to append the redundant
string "==" to the result.
=back
=head1 METHODS
The object oriented interface to C<Digest::MD5> is described in this
section. After a C<Digest::MD5> object has been created, you will add
data to it and finally ask for the digest in a suitable format. A
single object can be used to calculate multiple digests.
The following methods are provided:
=over 4
=item $md5 = Digest::MD5->new
The constructor returns a new C<Digest::MD5> object which encapsulate
the state of the MD5 message-digest algorithm.
If called as an instance method (i.e. $md5->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.
=item $md5->reset
This is just an alias for $md5->new.
=item $md5->clone
This a copy of the $md5 object. It is useful when you do not want to
destroy the digests state, but need an intermediate value of the
digest, e.g. when calculating digests iteratively on a continuous data
stream. Example:
my $md5 = Digest::MD5->new;
while (<>) {
$md5->add($_);
print "Line $.: ", $md5->clone->hexdigest, "\n";
}
=item $md5->add($data,...)
The $data provided as argument are appended to the message we
calculate the digest for. The return value is the $md5 object itself.
All these lines will have the same effect on the state of the $md5
object:
$md5->add("a"); $md5->add("b"); $md5->add("c");
$md5->add("a")->add("b")->add("c");
$md5->add("a", "b", "c");
$md5->add("abc");
=item $md5->addfile($io_handle)
The $io_handle will be read until EOF and its content appended to the
message we calculate the digest for. The return value is the $md5
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 $md5
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 $md5 object if this occurs.
In most cases you want to make sure that the $io_handle is in
C<binmode> before you pass it as argument to the addfile() method.
=item $md5->add_bits($data, $nbits)
=item $md5->add_bits($bitstring)
Since the MD5 algorithm is byte oriented you might only add bits as
multiples of 8, so you probably want to just use add() instead. The
add_bits() method is provided for compatibility with other digest
implementations. See L<Digest> for description of the arguments
that add_bits() take.
=item $md5->digest
Return the binary digest for the message. The returned string will be
16 bytes long.
Note that the C<digest> operation is effectively a destructive,
read-once operation. Once it has been performed, the C<Digest::MD5>
object is automatically C<reset> and can be used to calculate another
digest value. Call $md5->clone->digest if you want to calculate the
digest without resetting the digest state.
=item $md5->hexdigest
Same as $md5->digest, but will return the digest in hexadecimal
form. The length of the returned string will be 32 and it will only
contain characters from this set: '0'..'9' and 'a'..'f'.
=item $md5->b64digest
Same as $md5->digest, but will return the digest as a base64 encoded
string. The length of the returned string will be 22 and it will only
contain characters from this set: 'A'..'Z', 'a'..'z', '0'..'9', '+'
and '/'.
The base64 encoded string returned is not padded to be a multiple of 4
bytes long. If you want interoperability with other base64 encoded
md5 digests you might want to append the string "==" to the result.
=back
=head1 EXAMPLES
The simplest way to use this library is to import the md5_hex()
function (or one of its cousins):
use Digest::MD5 qw(md5_hex);
print "Digest is ", md5_hex("foobarbaz"), "\n";
The above example would print out the message:
Digest is 6df23dc03f9b54cc38a0fc1483df6e21
The same checksum can also be calculated in OO style:
use Digest::MD5;
$md5 = Digest::MD5->new;
$md5->add('foo', 'bar');
$md5->add('baz');
$digest = $md5->hexdigest;
print "Digest is $digest\n";
With OO style you can break the message arbitrary. This means that we
are no longer limited to have space for the whole message in memory, i.e.
we can handle messages of any size.
This is useful when calculating checksum for files:
use Digest::MD5;
my $file = shift || "/etc/passwd";
open(FILE, $file) or die "Can't open '$file': $!";
binmode(FILE);
$md5 = Digest::MD5->new;
while (<FILE>) {
$md5->add($_);
}
close(FILE);
print $md5->b64digest, " $file\n";
Or we can use the addfile method for more efficient reading of
the file:
use Digest::MD5;
my $file = shift || "/etc/passwd";
open(FILE, $file) or die "Can't open '$file': $!";
binmode(FILE);
print Digest::MD5->new->addfile(*FILE)->hexdigest, " $file\n";
Perl 5.8 support Unicode characters in strings. Since the MD5
algorithm is only defined for strings of bytes, it can not be used on
strings that contains chars with ordinal number above 255. The MD5
functions and methods will croak if you try to feed them such input
data:
use Digest::MD5 qw(md5_hex);
my $str = "abc\x{300}";
print md5_hex($str), "\n"; # croaks
# Wide character in subroutine entry
What you can do is calculate the MD5 checksum of the UTF-8
representation of such strings. This is achieved by filtering the
string through encode_utf8() function:
use Digest::MD5 qw(md5_hex);
use Encode qw(encode_utf8);
my $str = "abc\x{300}";
print md5_hex(encode_utf8($str)), "\n";
# 8c2d46911f3f5a326455f0ed7a8ed3b3
=head1 SEE ALSO
L<Digest>,
L<Digest::MD2>,
L<Digest::SHA1>,
L<Digest::HMAC>
L<md5sum(1)>
RFC 1321
http://en.wikipedia.org/wiki/MD5
The paper "How to Break MD5 and Other Hash Functions" by Xiaoyun Wang
and Hongbo Yu.
=head1 COPYRIGHT
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
Copyright 1998-2003 Gisle Aas.
Copyright 1995-1996 Neil Winton.
Copyright 1991-1992 RSA Data Security, Inc.
The MD5 algorithm is defined in RFC 1321. This implementation is
derived from the reference C code in RFC 1321 which is covered by
the following copyright statement:
=over 4
=item
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
=back
This copyright does not prohibit distribution of any version of Perl
containing this extension under the terms of the GNU or Artistic
licenses.
=head1 AUTHORS
The original C<MD5> interface was written by Neil Winton
(C<N.Winton at axion.bt.co.uk>).
The C<Digest::MD5> module is written by Gisle Aas <gisle at ActiveState.com>.
=cut
--- NEW FILE: MD5.xs ---
/* $Id: MD5.xs,v 1.1 2006-12-05 04:26:32 dslinux_cayenne Exp $ */
/*
* This library is free software; you can redistribute it and/or
* modify it under the same terms as Perl itself.
*
* Copyright 1998-2000 Gisle Aas.
* Copyright 1995-1996 Neil Winton.
* Copyright 1991-1992 RSA Data Security, Inc.
*
* This code is derived from Neil Winton's MD5-1.7 Perl module, which in
* turn is derived from the reference implementation in RFC 1321 which
* comes with this message:
*
* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
* rights reserved.
*
* License to copy and use this software is granted provided that it
* is identified as the "RSA Data Security, Inc. MD5 Message-Digest
* Algorithm" in all material mentioning or referencing this software
* or this function.
*
* License is also granted to make and use derivative works provided
* that such works are identified as "derived from the RSA Data
* Security, Inc. MD5 Message-Digest Algorithm" in all material
* mentioning or referencing the derived work.
*
* RSA Data Security, Inc. makes no representations concerning either
* the merchantability of this software or the suitability of this
* software for any particular purpose. It is provided "as is"
* without express or implied warranty of any kind.
*
* These notices must be retained in any copies of any part of this
* documentation and/or software.
*/
#ifdef __cplusplus
extern "C" {
#endif
#define PERL_NO_GET_CONTEXT /* we want efficiency */
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#ifdef __cplusplus
}
#endif
#ifndef PERL_VERSION
# include <patchlevel.h>
# if !(defined(PERL_VERSION) || (SUBVERSION > 0 && defined(PATCHLEVEL)))
# include <could_not_find_Perl_patchlevel.h>
# endif
# define PERL_REVISION 5
# define PERL_VERSION PATCHLEVEL
# define PERL_SUBVERSION SUBVERSION
#endif
#if PERL_VERSION <= 4 && !defined(PL_dowarn)
#define PL_dowarn dowarn
#endif
#ifdef G_WARN_ON
#define DOWARN (PL_dowarn & G_WARN_ON)
#else
#define DOWARN PL_dowarn
#endif
#ifdef SvPVbyte
#if PERL_REVISION == 5 && PERL_VERSION < 7
/* SvPVbyte does not work in perl-5.6.1, borrowed version for 5.7.3 */
#undef SvPVbyte
#define SvPVbyte(sv, lp) \
((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
? ((lp = SvCUR(sv)), SvPVX(sv)) : my_sv_2pvbyte(aTHX_ sv, &lp))
static char *
my_sv_2pvbyte(pTHX_ register SV *sv, STRLEN *lp)
{
sv_utf8_downgrade(sv,0);
return SvPV(sv,*lp);
}
#endif
#else
#define SvPVbyte SvPV
#endif
#ifndef dTHX
#define pTHX_
#define aTHX_
#endif
/* Perl does not guarantee that U32 is exactly 32 bits. Some system
* has no integral type with exactly 32 bits. For instance, A Cray has
* short, int and long all at 64 bits so we need to apply this macro
* to reduce U32 values to 32 bits at appropriate places. If U32
* really does have 32 bits then this is a no-op.
*/
#if BYTEORDER > 0x4321 || defined(TRUNCATE_U32)
#define TO32(x) ((x) & 0xFFFFffff)
#define TRUNC32(x) ((x) &= 0xFFFFffff)
#else
#define TO32(x) (x)
#define TRUNC32(x) /*nothing*/
#endif
/* The MD5 algorithm is defined in terms of little endian 32-bit
* values. The following macros (and functions) allow us to convert
* between native integers and such values.
*/
#undef BYTESWAP
#ifndef U32_ALIGNMENT_REQUIRED
#if BYTEORDER == 0x1234 /* 32-bit little endian */
#define BYTESWAP(x) (x) /* no-op */
#elif BYTEORDER == 0x4321 /* 32-bit big endian */
#define BYTESWAP(x) ((((x)&0xFF)<<24) \
|(((x)>>24)&0xFF) \
|(((x)&0x0000FF00)<<8) \
|(((x)&0x00FF0000)>>8) )
#endif
#endif
#ifndef BYTESWAP
static void u2s(U32 u, U8* s)
{
*s++ = (U8)(u & 0xFF);
*s++ = (U8)((u >> 8) & 0xFF);
*s++ = (U8)((u >> 16) & 0xFF);
*s = (U8)((u >> 24) & 0xFF);
}
#define s2u(s,u) ((u) = (U32)(*s) | \
((U32)(*(s+1)) << 8) | \
((U32)(*(s+2)) << 16) | \
((U32)(*(s+3)) << 24))
#endif
#define MD5_CTX_SIGNATURE 200003165
/* This stucture keeps the current state of algorithm.
*/
typedef struct {
U32 signature; /* safer cast in get_md5_ctx() */
U32 A, B, C, D; /* current digest */
U32 bytes_low; /* counts bytes in message */
U32 bytes_high; /* turn it into a 64-bit counter */
U8 buffer[128]; /* collect complete 64 byte blocks */
} MD5_CTX;
/* Padding is added at the end of the message in order to fill a
* complete 64 byte block (- 8 bytes for the message length). The
* padding is also the reason the buffer in MD5_CTX have to be
* 128 bytes.
*/
static const unsigned char PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
/* Constants for MD5Transform routine.
*/
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
/* F, G, H and I are basic MD5 functions.
*/
#define F(x, y, z) ((((x) & ((y) ^ (z))) ^ (z)))
#define G(x, y, z) F(z, x, y)
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
/* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) (((x) << (n) | ((x) >> (32-(n)))))
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
* Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, s, ac) \
(a) += F ((b), (c), (d)) + (NEXTx) + (U32)(ac); \
TRUNC32((a)); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
TRUNC32((a));
#define GG(a, b, c, d, x, s, ac) \
(a) += G ((b), (c), (d)) + X[x] + (U32)(ac); \
TRUNC32((a)); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
TRUNC32((a));
#define HH(a, b, c, d, x, s, ac) \
(a) += H ((b), (c), (d)) + X[x] + (U32)(ac); \
TRUNC32((a)); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
TRUNC32((a));
#define II(a, b, c, d, x, s, ac) \
(a) += I ((b), (c), (d)) + X[x] + (U32)(ac); \
TRUNC32((a)); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
TRUNC32((a));
static void
MD5Init(MD5_CTX *ctx)
{
/* Start state */
ctx->A = 0x67452301;
ctx->B = 0xefcdab89;
ctx->C = 0x98badcfe;
ctx->D = 0x10325476;
/* message length */
ctx->bytes_low = ctx->bytes_high = 0;
}
static void
MD5Transform(MD5_CTX* ctx, const U8* buf, STRLEN blocks)
{
#ifdef MD5_DEBUG
static int tcount = 0;
#endif
U32 A = ctx->A;
U32 B = ctx->B;
U32 C = ctx->C;
U32 D = ctx->D;
#ifndef U32_ALIGNMENT_REQUIRED
const U32 *x = (U32*)buf; /* really just type casting */
#endif
do {
U32 a = A;
U32 b = B;
U32 c = C;
U32 d = D;
#if BYTEORDER == 0x1234 && !defined(U32_ALIGNMENT_REQUIRED)
const U32 *X = x;
#define NEXTx (*x++)
#else
U32 X[16]; /* converted values, used in round 2-4 */
U32 *uptr = X;
U32 tmp;
#ifdef BYTESWAP
#define NEXTx (tmp=*x++, *uptr++ = BYTESWAP(tmp))
#else
#define NEXTx (s2u(buf,tmp), buf += 4, *uptr++ = tmp)
#endif
#endif
#ifdef MD5_DEBUG
if (buf == ctx->buffer)
fprintf(stderr,"%5d: Transform ctx->buffer", ++tcount);
else
fprintf(stderr,"%5d: Transform %p (%d)", ++tcount, buf, blocks);
{
int i;
fprintf(stderr,"[");
for (i = 0; i < 16; i++) {
fprintf(stderr,"%x,", x[i]);
}
fprintf(stderr,"]\n");
}
#endif
/* Round 1 */
FF (a, b, c, d, S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, S13, 0x242070db); /* 3 */
FF (b, c, d, a, S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, S13, 0xa8304613); /* 7 */
FF (b, c, d, a, S14, 0xfd469501); /* 8 */
FF (a, b, c, d, S11, 0x698098d8); /* 9 */
FF (d, a, b, c, S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, S11, 0x6b901122); /* 13 */
FF (d, a, b, c, S12, 0xfd987193); /* 14 */
FF (c, d, a, b, S13, 0xa679438e); /* 15 */
FF (b, c, d, a, S14, 0x49b40821); /* 16 */
/* Round 2 */
GG (a, b, c, d, 1, S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, 6, S22, 0xc040b340); /* 18 */
GG (c, d, a, b, 11, S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, 0, S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, 5, S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, 10, S22, 0x2441453); /* 22 */
GG (c, d, a, b, 15, S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, 4, S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, 9, S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, 14, S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, 3, S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, 8, S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, 13, S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, 2, S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, 7, S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, 12, S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH (a, b, c, d, 5, S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, 8, S32, 0x8771f681); /* 34 */
HH (c, d, a, b, 11, S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, 14, S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, 1, S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, 4, S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, 7, S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, 10, S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, 13, S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, 0, S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, 3, S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, 6, S34, 0x4881d05); /* 44 */
HH (a, b, c, d, 9, S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, 12, S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, 15, S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, 2, S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II (a, b, c, d, 0, S41, 0xf4292244); /* 49 */
II (d, a, b, c, 7, S42, 0x432aff97); /* 50 */
II (c, d, a, b, 14, S43, 0xab9423a7); /* 51 */
II (b, c, d, a, 5, S44, 0xfc93a039); /* 52 */
II (a, b, c, d, 12, S41, 0x655b59c3); /* 53 */
II (d, a, b, c, 3, S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, 10, S43, 0xffeff47d); /* 55 */
II (b, c, d, a, 1, S44, 0x85845dd1); /* 56 */
II (a, b, c, d, 8, S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, 15, S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, 6, S43, 0xa3014314); /* 59 */
II (b, c, d, a, 13, S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, 4, S41, 0xf7537e82); /* 61 */
II (d, a, b, c, 11, S42, 0xbd3af235); /* 62 */
II (c, d, a, b, 2, S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, 9, S44, 0xeb86d391); /* 64 */
A += a; TRUNC32(A);
B += b; TRUNC32(B);
C += c; TRUNC32(C);
D += d; TRUNC32(D);
} while (--blocks);
ctx->A = A;
ctx->B = B;
ctx->C = C;
ctx->D = D;
}
#ifdef MD5_DEBUG
static char*
ctx_dump(MD5_CTX* ctx)
{
static char buf[1024];
sprintf(buf, "{A=%x,B=%x,C=%x,D=%x,%d,%d(%d)}",
ctx->A, ctx->B, ctx->C, ctx->D,
ctx->bytes_low, ctx->bytes_high, (ctx->bytes_low&0x3F));
return buf;
}
#endif
static void
MD5Update(MD5_CTX* ctx, const U8* buf, STRLEN len)
{
STRLEN blocks;
STRLEN fill = ctx->bytes_low & 0x3F;
#ifdef MD5_DEBUG
static int ucount = 0;
fprintf(stderr,"%5i: Update(%s, %p, %d)\n", ++ucount, ctx_dump(ctx),
buf, len);
#endif
ctx->bytes_low += len;
if (ctx->bytes_low < len) /* wrap around */
ctx->bytes_high++;
if (fill) {
STRLEN missing = 64 - fill;
if (len < missing) {
Copy(buf, ctx->buffer + fill, len, U8);
return;
}
Copy(buf, ctx->buffer + fill, missing, U8);
MD5Transform(ctx, ctx->buffer, 1);
buf += missing;
len -= missing;
}
blocks = len >> 6;
if (blocks)
MD5Transform(ctx, buf, blocks);
if ( (len &= 0x3F)) {
Copy(buf + (blocks << 6), ctx->buffer, len, U8);
}
}
static void
MD5Final(U8* digest, MD5_CTX *ctx)
{
STRLEN fill = ctx->bytes_low & 0x3F;
STRLEN padlen = (fill < 56 ? 56 : 120) - fill;
U32 bits_low, bits_high;
#ifdef MD5_DEBUG
fprintf(stderr," Final: %s\n", ctx_dump(ctx));
#endif
Copy(PADDING, ctx->buffer + fill, padlen, U8);
fill += padlen;
bits_low = ctx->bytes_low << 3;
bits_high = (ctx->bytes_high << 3) | (ctx->bytes_low >> 29);
#ifdef BYTESWAP
*(U32*)(ctx->buffer + fill) = BYTESWAP(bits_low); fill += 4;
*(U32*)(ctx->buffer + fill) = BYTESWAP(bits_high); fill += 4;
#else
u2s(bits_low, ctx->buffer + fill); fill += 4;
u2s(bits_high, ctx->buffer + fill); fill += 4;
#endif
MD5Transform(ctx, ctx->buffer, fill >> 6);
#ifdef MD5_DEBUG
fprintf(stderr," Result: %s\n", ctx_dump(ctx));
#endif
#ifdef BYTESWAP
*(U32*)digest = BYTESWAP(ctx->A); digest += 4;
*(U32*)digest = BYTESWAP(ctx->B); digest += 4;
*(U32*)digest = BYTESWAP(ctx->C); digest += 4;
*(U32*)digest = BYTESWAP(ctx->D);
#else
u2s(ctx->A, digest);
u2s(ctx->B, digest+4);
u2s(ctx->C, digest+8);
u2s(ctx->D, digest+12);
#endif
}
#ifndef INT2PTR
#define INT2PTR(any,d) (any)(d)
#endif
static MD5_CTX* get_md5_ctx(pTHX_ SV* sv)
{
if (SvROK(sv)) {
sv = SvRV(sv);
if (SvIOK(sv)) {
MD5_CTX* ctx = INT2PTR(MD5_CTX*, SvIV(sv));
if (ctx && ctx->signature == MD5_CTX_SIGNATURE) {
return ctx;
}
}
}
croak("Not a reference to a Digest::MD5 object");
return (MD5_CTX*)0; /* some compilers insist on a return value */
}
static char* hex_16(const unsigned char* from, char* to)
{
static const char hexdigits[] = "0123456789abcdef";
const unsigned char *end = from + 16;
char *d = to;
while (from < end) {
*d++ = hexdigits[(*from >> 4)];
*d++ = hexdigits[(*from & 0x0F)];
from++;
}
*d = '\0';
return to;
}
static char* base64_16(const unsigned char* from, char* to)
{
static const char base64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const unsigned char *end = from + 16;
unsigned char c1, c2, c3;
char *d = to;
while (1) {
c1 = *from++;
*d++ = base64[c1>>2];
if (from == end) {
*d++ = base64[(c1 & 0x3) << 4];
break;
}
c2 = *from++;
c3 = *from++;
*d++ = base64[((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4)];
*d++ = base64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
*d++ = base64[c3 & 0x3F];
}
*d = '\0';
return to;
}
/* Formats */
#define F_BIN 0
#define F_HEX 1
#define F_B64 2
static SV* make_mortal_sv(pTHX_ const unsigned char *src, int type)
{
STRLEN len;
char result[33];
char *ret;
switch (type) {
case F_BIN:
ret = (char*)src;
len = 16;
break;
case F_HEX:
ret = hex_16(src, result);
len = 32;
break;
case F_B64:
ret = base64_16(src, result);
len = 22;
break;
default:
croak("Bad convertion type (%d)", type);
break;
}
return sv_2mortal(newSVpv(ret,len));
}
/********************************************************************/
typedef PerlIO* InputStream;
MODULE = Digest::MD5 PACKAGE = Digest::MD5
PROTOTYPES: DISABLE
void
new(xclass)
SV* xclass
PREINIT:
MD5_CTX* context;
PPCODE:
if (!SvROK(xclass)) {
STRLEN my_na;
char *sclass = SvPV(xclass, my_na);
New(55, context, 1, MD5_CTX);
context->signature = MD5_CTX_SIGNATURE;
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), sclass, (void*)context);
SvREADONLY_on(SvRV(ST(0)));
} else {
context = get_md5_ctx(aTHX_ xclass);
}
MD5Init(context);
XSRETURN(1);
void
clone(self)
SV* self
PREINIT:
MD5_CTX* cont = get_md5_ctx(aTHX_ self);
char *myname = sv_reftype(SvRV(self),TRUE);
MD5_CTX* context;
PPCODE:
New(55, context, 1, MD5_CTX);
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), myname , (void*)context);
SvREADONLY_on(SvRV(ST(0)));
memcpy(context,cont,sizeof(MD5_CTX));
XSRETURN(1);
void
DESTROY(context)
MD5_CTX* context
CODE:
Safefree(context);
void
add(self, ...)
SV* self
PREINIT:
MD5_CTX* context = get_md5_ctx(aTHX_ self);
int i;
unsigned char *data;
STRLEN len;
PPCODE:
for (i = 1; i < items; i++) {
data = (unsigned char *)(SvPVbyte(ST(i), len));
MD5Update(context, data, len);
}
XSRETURN(1); /* self */
void
addfile(self, fh)
SV* self
InputStream fh
PREINIT:
MD5_CTX* context = get_md5_ctx(aTHX_ self);
STRLEN fill = context->bytes_low & 0x3F;
#ifdef USE_HEAP_INSTEAD_OF_STACK
unsigned char* buffer;
#else
unsigned char buffer[4096];
#endif
int n;
CODE:
if (fh) {
#ifdef USE_HEAP_INSTEAD_OF_STACK
New(0, buffer, 4096, unsigned char);
assert(buffer);
#endif
if (fill) {
/* The MD5Update() function is faster if it can work with
* complete blocks. This will fill up any buffered block
* first.
*/
STRLEN missing = 64 - fill;
if ( (n = PerlIO_read(fh, buffer, missing)) > 0)
MD5Update(context, buffer, n);
else
XSRETURN(1); /* self */
}
/* Process blocks until EOF or error */
while ( (n = PerlIO_read(fh, buffer, sizeof(buffer))) > 0) {
MD5Update(context, buffer, n);
}
#ifdef USE_HEAP_INSTEAD_OF_STACK
Safefree(buffer);
#endif
if (PerlIO_error(fh)) {
croak("Reading from filehandle failed");
}
}
else {
croak("No filehandle passed");
}
XSRETURN(1); /* self */
void
digest(context)
MD5_CTX* context
ALIAS:
Digest::MD5::digest = F_BIN
Digest::MD5::hexdigest = F_HEX
Digest::MD5::b64digest = F_B64
PREINIT:
unsigned char digeststr[16];
PPCODE:
MD5Final(digeststr, context);
MD5Init(context); /* In case it is reused */
ST(0) = make_mortal_sv(aTHX_ digeststr, ix);
XSRETURN(1);
void
md5(...)
ALIAS:
Digest::MD5::md5 = F_BIN
Digest::MD5::md5_hex = F_HEX
Digest::MD5::md5_base64 = F_B64
PREINIT:
MD5_CTX ctx;
int i;
unsigned char *data;
STRLEN len;
unsigned char digeststr[16];
PPCODE:
MD5Init(&ctx);
if (DOWARN) {
char *msg = 0;
if (items == 1) {
if (SvROK(ST(0))) {
SV* sv = SvRV(ST(0));
if (SvOBJECT(sv) && strEQ(HvNAME(SvSTASH(sv)), "Digest::MD5"))
msg = "probably called as method";
else
msg = "called with reference argument";
}
}
else if (items > 1) {
data = (unsigned char *)SvPVbyte(ST(0), len);
if (len == 11 && memEQ("Digest::MD5", data, 11)) {
msg = "probably called as class method";
}
}
if (msg) {
char *f = (ix == F_BIN) ? "md5" :
(ix == F_HEX) ? "md5_hex" : "md5_base64";
warn("&Digest::MD5::%s function %s", f, msg);
}
}
for (i = 0; i < items; i++) {
data = (unsigned char *)(SvPVbyte(ST(i), len));
MD5Update(&ctx, data, len);
}
MD5Final(digeststr, &ctx);
ST(0) = make_mortal_sv(aTHX_ digeststr, ix);
XSRETURN(1);
--- NEW FILE: README ---
The Digest::MD5 module allows you to use the RSA Data Security
Inc. MD5 Message Digest algorithm from within Perl programs. The
algorithm takes as input a message of arbitrary length and produces as
output a 128-bit "fingerprint" or "message digest" of the input.
MD5 is described in RFC 1321.
You will need perl version 5.6 or better to install this module.
Copyright 1998-2003 Gisle Aas.
Copyright 1995-1996 Neil Winton.
Copyright 1990-1992 RSA Data Security, Inc.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
--- NEW FILE: Changes ---
2005-11-30 Gisle Aas <gisle at ActiveState.com>
Release 2.36
Fix documentation typo.
2005-11-26 Gisle Aas <gisle at ActiveState.com>
Release 2.35
Forgot to incorporate fixes already applied to bleadperl :-(
- doc typo
- consting
- unused my_na
- USE_HEAP_INSTEAD_OF_STACK for Symbian
2005-11-26 Gisle Aas <gisle at ActiveState.com>
Release 2.34
Document that it is now easy to generate different messages that produce the
same MD5 digest.
Use XSLoader; perl-5.6 is now required.
Tweaks to the processing of $? after running the test program.
2003-12-07 Gisle Aas <gisle at ActiveState.com>
Release 2.33
Enable explicit context passing for slight performance
improvement in threaded perls.
Tweaks to the Makefile.PL so that it is suitable both for
core and CPAN use.
2003-12-05 Gisle Aas <gisle at ActiveState.com>
Release 2.32
Don't run u32align test program on HP-UX 10.20 as it
will hang. Patch by H.Merijn Brand <h.m.brand at hccnet.nl>.
Fixed documentation typo.
2003-11-28 Gisle Aas <gisle at ActiveState.com>
Release 2.31
Inherit add_bits() from Digest::base if available.
2003-10-09 Gisle Aas <gisle at ActiveState.com>
Release 2.30
Some tweaks to make the module build on perl-5.004 and
perl-5.005 again.
2003-10-06 Gisle Aas <gisle at ActiveState.com>
Release 2.29
Another try. Forgot to update the test checksums.
2003-10-06 Gisle Aas <gisle at ActiveState.com>
Release 2.28
Fix minor documentation typo.
2003-08-04 Gisle Aas <gisle at ActiveState.com>
Release 2.27
Avoid having to figure how to compile alignment test program
on MS-Windows by just assume free alignment as for i386. Source
builds on Windows was apparently broken.
2003-07-21 Gisle Aas <gisle at ActiveState.com>
Release 2.26
Don't assume PerlIO_read() works like fread() even though
it was documented like that for perl 5.6. It returns negative
on read failure.
Kill test #3 in t/badfile.t. I don't know a reliable way
to test read failures on a file handle. Seems better not to
test than to make many worry.
2003-07-04 Gisle Aas <gisle at ActiveState.com>
Release 2.25
The $md5->addfile method now croaks if it discovers
errors on the handle after reading from it. This should
make it more difficult to end up with the wrong digest
just because you are to lazy to check the error status
on your file handles after reading from them.
Improved documentation.
Sync up with bleadperl; even safer patchlevel include.
2003-03-09 Gisle Aas <gisle at ActiveState.com>
Release 2.24
Don't let the $^W test get confused by lexical warnings.
Sync up with bleadperl; safer patchlevel include.
2003-01-18 Gisle Aas <gisle at ActiveState.com>
Release 2.23
Override INSTALLDIRS for 5.8 as suggested by
Guido Ostkamp <Guido.Ostkamp at t-online.de>.
2003-01-04 Gisle Aas <gisle at ActiveState.com>
Release 2.22.
Added clone method.
Contributed by Holger Smolinski <holger at kunterbunt.bb.bawue.de>
2002-12-27 Gisle Aas <gisle at ActiveState.com>
Release 2.21
Minor tweaks sync up with bleadperl:
- VMS optimizer tweaks to the Makefile.PL
- MacOS support
- Added alignment test
Added example to the MD5 POD that shows how to calculate the
digest of Unicode strings.
2002-05-05 Gisle Aas <gisle at ActiveState.com>
Release 2.20
More synchronization with tweaks Jarkko have done to the
bleadperl test suite. This time various EBCDIC hacks.
Outside PERL_CORE the md5-aaa.t test loaded the wrong version of
the module (and would fail if no previous Digest::MD5 was installed).
Patch by Mike Stok <mike at stok.co.uk>
2002-05-01 Gisle Aas <gisle at ActiveState.com>
Release 2.19
One more test suite update from Jarkko to sync it
even better with bleadperl.
2002-05-01 Gisle Aas <gisle at ActiveState.com>
Release 2.18
Changes #12954 and #16173 from bleadperl. Documentation typo fix
and some signed/unsigned mismatches that Microsoft's C compiler
complained about.
The EBCDIC-aware md5-aaa.t from bleadperl.
2002-04-25 Gisle Aas <gisle at ActiveState.com>
Release 2.17
The SvPVbyte in perl-5.6.1 is buggy. Use the one from 5.7.3
instead.
Give warning if the function interface is used as instance
methods: $md5->md5_hex().
2001-09-07 Gisle Aas <gisle at ActiveState.com>
Release 2.16
Sync up with the bleadperl version:
- use SvPVbyte() if available
- fixes to make the code 'gcc -Wall'-clean
2001-08-27 Gisle Aas <gisle at ActiveState.com>
Release 2.15
Avoid exit() in Makefile.PL and bleadperl redefinition of printf
in the alignment test program.
Patch by Doug MacEachern <dougm at covalent.net>.
2001-07-18 Gisle Aas <gisle at ActiveState.com>
Release 2.14
Try to warn if the functional interface is used as methods,
i.e. Digest::MD5->md5_hex("foo") will make noise if -w is
enabled.
Document the missing padding for the base64 digests.
If both XS bootstrap and locating Digest::Perl::MD5 fails
re-raise the original XS bootstrap exception.
2001-03-13 Gisle Aas <gisle at ActiveState.com>
Release 2.13
Moved all other Digest:: modules out of the Digest-MD5 dist.
2000-09-18 Gisle Aas <gisle at ActiveState.com>
Release 2.12
Avoid pointer cast warning for machines with bigger ints
than pointers. Patch by Robin Barker <rmb1 at cise.npl.co.uk>.
2000-08-19 Gisle Aas <gisle at ActiveState.com>
Release 2.11
The fallback code introduced in 2.10 did only work for
perl-5.6.0. It should now for for perl5.004 and 5.005
as well. Patch by Ville Skyttä <ville at office.popsystems.com>.
2000-08-18 Gisle Aas <gisle at ActiveState.com>
Release 2.10
Digest::MD5 will now try to fallback to the pure perl
implementation of Digest::Perl::MD5 if bootstrap fails.
Added a bit internal paranoia about casting the IV
in the Digest::MD5 object to the MD5_CTX* pointer.
1999-08-06 Gisle Aas <gisle at aas.no>
Release 2.09
Documentation update.
1999-07-28 Gisle Aas <gisle at aas.no>
Release 2.08
The addfile() methods could trigger a core dump when passed
a filehandle that had failed to open.
1999-04-26 Gisle Aas <gisle at aas.no>
Release 2.07
The Digest::SHA1 module failed on some 64-bit systems, because I
assumed there was a correspondence between the U32 size and
BYTEORDER. This version use 'unsigned long' as Uwe's original
SHA module did.
The module should now work better when liked statically with perl,
because we now use a safer module-loaded test in Digest.pm.
Assume we know the outcome of the alignment test on VMS. Patch by
Chuck Lane <lane at duphy4.physics.drexel.edu>
1999-03-26 Gisle Aas <gisle at aas.no>
Release 2.06
Avoid LONG and BYTE types in SHA.xs as they was in conflict
with similar definitions in <winnt.h>.
Patch by Marko Asplund <aspa at hip.fi> to make the the alignment
test program link successfully with sfio-perl.
Fixed a typo in MD5.xs that might have affected 64-bit systems.
Spotted by Nick Ing-Simmons
1999-03-15 Gisle Aas <gisle at aas.no>
Release 2.05
Included Digest::SHA1 based on Uwe Hollerbach's SHA module.
1999-03-05 Gisle Aas <gisle at aas.no>
Release 2.04
Avoid the -o option when compiling alignment test program
for Win32 as suggested by Gurusamy Sarathy.
DEC Compiler bug workaround. Contributed by D Roland Walker
<walker at ncbi.nlm.nih.gov>
Having references to a local variable called "na" was not
very safe either. Some older versions of Perl can apparently
macroize this into something completely different.
1999-02-27 Gisle Aas <gisle at aas.no>
Release 2.03
Patch from Christopher J. Madsen <chris_madsen at geocities.com> that
should help getting the u32align test program to compile with
Visual C++ 5 on Windows NT.
Got rid of references to PL_na.
1999-01-31 Gisle Aas <gisle at aas.no>
Release 2.02
Added a hints file as workaround for an IRIX compiler bug.
Contributed by D Roland Walker <walker at ncbi.nlm.nih.gov>.
Note that the rfc2202 test can still fail on some DEC Alpha,
because of a compiler bug that affects the perl 'x' operator.
The Digest:: modules should work and be safe to install anyway.
1998-12-18 Gisle Aas <aas at sn.no>
Release 2.01
Some casts and tweaks to make picky compilers more happy.
1998-11-04 Gisle Aas <aas at sn.no>
Release 2.00.
Taken out Digest::SHA1 as this module will be provided from Uwe
Hollerbach later.
Some tweaks to MD2.xs and MD5.xs since "na" disappeared in
perl5.005_53
1998-10-30 Gisle Aas <aas at sn.no>
Release 1.99_60
The 1.99_59 release introduced compilation problems for big-endian
systems with free U32 alignment. Bug reported, and fix suggested
by Paul J. Schinder <schinder at pobox.com>.
1998-10-28 Gisle Aas <aas at sn.no>
Release 1.99_59
Makefile.PL will run a test program to find out if U32 values can
be aligned anywhere. This hopefully cures the core dumps reported
on Solaris and other big endian systems. Thanks to Graham Barr for
debugging this.
1998-10-28 Gisle Aas <aas at sn.no>
Release 1.99_58
Should be very close to a 2.00 release now. Need some success
reports from people running on big-endian machines first I think.
Added a Digest::MD2 implementation.
Wrote Digest.pm documentation. This define the interface that all
Digest:: modules should provide.
Avoided some code duplication in MD5.xs
Fixed typo, that prevented Digest::SHA1::sha1_base64() from working.
1998-10-27 Gisle Aas <aas at sn.no>
Release 1.99_57
Rewritten most of the MD5 C code to make it real fast (especially
on little-endian machines without alignment restrictions for U32).
Compared to MD5-1.7 we can process files 4 times as fast and we
digest small stuff in memory 7 times faster. I came to these
conclusions after these tests (gcc -O2, i586, Linux):
First tested calculation of the digest of a 31 MB file, using
perl -le 'print Digest::MD5->new->addfile(*STDIN)->hexdigest'
and similar stuff:
MD5-1.7: 21.06s
Digest::MD5-1.99_57: 5.23s
md5sum (GNU textutils): 4.90s
As you can see, we do nearly as good as the md5sum program. I
think the reason we don't beat md5sum is that perl always insist on
loading extra modules like Config.pm, Carp.pm, strict.pm, vars.pm,
AutoLoader.pm and DynaLoader.pm. When I simply wrapped the MD5.xs
hasher code in a C program I managed to process the file in 4.68s.
Then we calculated the digest of the same 6 byte sting, 20000
times:
MD5-1.7: 11.81s
Digest::MD5-1.99_57: 1.68s
Digest::MD5 benefit from making this into a plain procedure call
instead of a static method call.
Other changes in this release are:
Documentation update
Internal MD5.xs cleanup.
$md5->digest will automatically reset now.
Digest::HMAC methods add() and addfile() did not return the
correct object.
Added Digest.pm loading module. I am not sure this is a good idea.
Added Digest::SHA1 and Digest::HMAC_SHA1 module. The Digest::SHA1
module is just a wrapper around SHA.pm. I hope to get the author
of SHA.pm to move his module to the Digest:: category.
1998-10-25 Gisle Aas <aas at sn.no>
Release 1.99_56
Fix memcpy_byteswap() function in MD5.xs. Must be careful with
htovl() as it might evaluate its arguments more than once.
1998-10-25 Gisle Aas <aas at sn.no>
Release 1.99_55
Grahams HMAC_MD5.pm splitted into two modules. Digest::HMAC and
Digest::HMAC_MD5. Also provide functional interface. Documentation
is still lacking.
Included RFC 2202 based test for HMAC-MD5.
1998-10-24 Gisle Aas <aas at sn.no>
Release 1.99_54
Included HMAC_MD5.pm, contributed by Graham Barr <gbarr at ti.com>.
I have a hard time to make up my mind :-) md5_bin() renamed back
to md5(). Functions are not exported by default any more.
Try to Encode/Decode with memcpy_byteswap for 32-bit big-endian
machines.
1998-10-23 Gisle Aas <aas at sn.no>
Release 1.99_53
Renamed core module as Digest::MD5. Leave a MD5.pm stub for
legacy code.
The md5() function renamed as md5_bin().
The constructor, Digest::MD5->new, no longer takes any extra
arguments.
Added some new tests.
Updated the documentation.
$md5->b64digest implemented with same base64 encoder as md5_base64.
1998-10-23 Gisle Aas <aas at sn.no>
Release 1.99_52
Patch from Graham Barr which make it work for big-endian machines
again.
1998-10-22 Gisle Aas <aas at sn.no>
Release 1.99_51
The MD5 class is now subclassable.
The add() and addfile() methods now return $self.
The reset() method is just an alias for new().
The constructor (MD5->new) now takes optional arguments which are
automatically added. It means that we can now write:
MD5->new($data)->hexdigest;
New $md5->b64digest method.
New functions that are exported on request: md5, md5_hex, md5_base64
Included RFC 1321
Barely started to update the documentation.
1998-10-22 Gisle Aas <aas at sn.no>
Release 1.99_50
Much better performance (more than twice as fast now). Mostly
because we use Copy/Zero instead of the original MD5_memcpy and
MD5_memset functions.
The addfile() and hexdigest() methods are now XS implemented.
All RSA functions now included in MD5.xs and made static.
Use perl's Copy/Zero.
Random cleanup, simplifications and reformatting.
Merged things better with the perl configuration.
Neil Winton's versions below:
*** 96/06/20 Version 1.7
MD5 is now completely 64-bit clean (I hope). The basic MD5 code uses
32-bit quantities and requires a typedef UINT4 to be defined in
global.h. Perl configuration data (the value of BYTEORDER) is used to
determine if unsigned longs have 4 or 8 bytes. On 64-bit platforms (eg
DEC Alpha) then it assumes that "unsigned int" will be a 32-bit type.
If this is incorrect then adding -DUINT4_IS_LONG to the DEFINES line in
Makefile.PL will override this.
On some machines (at least Cray that I know of) there is no 32-bit
integer type. In this case defining TRUNCATE_UINT4 (which is done
automatically for a Cray) will ensure that 64-bit values are masked
down to 32 bits. I have done my best to test this but without easy
access to a true 64-bit machine I can not totally guarantee it (unless
anyone wants to lend me a spare Cray :-)
There is one remaining limitation for 64-bit enabled processors. The
amount of data passed to any single call to the underlying MD5
routines is limited to (2^32 - 1) bytes -- that's 4 gigabytes. I'm
sorry if that's a real problem for you ...
And finally, a minor compilation warning (unsigned char * used with
function having char * prototype) has also been eliminated.
*** 96/04/09 Version 1.6
Re-generated module framework using h2xs to pick up the latest module
conventions for versions etc. You can now say "use MD5 1.6;" and things
should work correctly. MD5.pod has been integrated into MD5.pm and
CHANGES renamed to Changes. There is a fairly comprehensive test.pl
which can be invoked via "make test". There are no functional changes
to the MD5 routines themselves.
*** 96/03/14 Version 1.5.3
Fixed addfile method to accept type-glob references for the file-handle
(eg \*STDOUT). This is more consistent with other routines and is now the
recommended way of passing file-handles. The documentation now gives more
examples as to how the routines might be used.
*** 96/03/12 Version 1.5.2
Minor fixes from Christopher J Madsen <madsen at computek.net> to provide
support for building on OS/2 (and to work around a perl -w bug).
Remove warning about possible difference between add('foo', 'bar') and
add('foobar'). This is not true (it may have been true in the earliest
version of the module but is no longer the case).
*** 96/03/08 Version 1.5.1
Add CHANGES file to make it easier for people to figure out what has
been going on. (Meant to do this as part of 1.5)
*** 96/03/05 Version 1.5
Add hash() and hexhash() methods at the suggestion/request of Gary
Howland <gary at kampai.euronet.nl> before inclusion in a wider library
of cryptography modules.
*** 96/02/27 Version 1.4
Finally fixed the pesky Solaris dynamic loading bug. All kudos to Ken
Pizzini <kenp at spry.com>!
*** 95/11/29 Version 1.3.1
Add explanations of current known problems.
*** 95/06/02 Version 1.3
Fix problems with scope resolution in addfile() reported by
Jean-Claude Giese <Jean-Claude.Giese at loria.fr>. Basically ARGV is
always implicitly in package main while other filehandles aren't.
*** 95/05/23 Version 1.2.1
[Changes pre 1.2.1 not recorded]
--- NEW FILE: typemap ---
MD5_CTX* T_MD5_CTX
INPUT
T_MD5_CTX
$var = get_md5_ctx(aTHX_ $arg)
More information about the dslinux-commit
mailing list