Move Digest::SHA from ext/ to cpan/

Move the shasum binary to the top level, to remove the need for a MAP entry in
Maintainers.PL

34 files changed, 4191 insertions, 0 deletions

diff --git a/cpan/Digest-SHA/Changes b/cpan/Digest-SHA/Changes
new file mode 100644
index 0000000000..ad5bd06b35
--- /dev/null
+++ b/cpan/Digest-SHA/Changes
@@ -0,0 +1,411 @@
+Revision history for Perl extension Digest::SHA.
+
+5.47  Wed Apr 30 04:00:54 MST 2008
+	- modified Makefile.PL to install in core for Perls >= 5.10
+		-- thanks to Jerry Hedden for patch
+	- changed from #include <> to #include "" in SHA.xs
+		-- some platforms not able to find SHA source files
+			-- thanks to Alexandr Ciornii for testing
+	- moved .pm file to appropriate lib directory
+	- minor addition to META.yml
+
+5.46  Wed Apr  9 05:04:00 MST 2008
+	- modified Addfile to recognize leading and trailing
+		whitespace in filenames (ref. rt.cpan.org #34690)
+	- minor C source code modification (ref. hmac.c)
+	- use const in sha.c for clean builds with -Wwrite-strings
+		-- thanks to Robin Barker for patch
+
+5.45  Tue Jun 26 02:36:00 MST 2007
+	- extended portability to earlier Perls
+		-- works on Perl 5.003 and later
+		-- thanks to Jim Doble for testing on legacy platforms
+	- updated META.yml to conform to current META spec (1.3)
+	- minor documentation fixes
+
+5.44  Sat Oct 14 00:42:44 MST 2006
+	- removed SIGNATURE file from distribution
+		-- spurious errors from CPANPLUS can break build
+	- eliminated ppport.h header file
+		-- significantly reduces size of distribution
+	- modified C functions in src/hmac.c to use ANSI prototypes
+		-- thanks to Jarkko Hietaniemi for patch
+
+5.43  Sat Aug  5 02:36:18 MST 2006
+	- undid Perl Best Practice of favoring 3-argument "open"
+		-- 3-arg version uses different semantics for "-"
+			causing bugs in addfile and shasum
+	- modified underlying C functions to use ANSI prototypes
+		-- requested by Steve Hay (ref. Smoke [5.9.4] 28630)
+		-- K&R style was causing numerous warnings from
+			Borland compiler
+
+5.42  Mon Jul 24 04:04:40 MST 2006
+	- minor code changes suggested by Perl::Critic
+		-- e.g. no bareword filehandles, no 2-argument open's
+	- updated public key (ref. B538C51C)
+		-- previous one (0AF563FE) expired July 2, 2006
+	- added documentation to warn that Base64 digests are NOT padded
+		-- padding must be done by user if interoperability
+			with other software is required
+
+5.41  Sat Jun  3 01:50:46 MST 2006
+	- corrected addfile
+		-- process $file argument as a filehandle unless passed
+			as a SCALAR (which indicates a file name)
+
+5.40  Fri Jun  2 04:00:30 MST 2006
+	- modified addfile to accept indirect filehandles
+		-- ref. rt.cpan.org #19627 and #19641
+
+5.39  Sun May 28 03:22:24 MST 2006
+	- modified shasum to warn rather than die for file errors
+		-- to follow conventions of GNU sha1sum/md5sum
+
+5.38  Thu May 25 02:02:02 MST 2006
+	- added new capabilities to the "addfile" method
+		-- now able to accept file names as well as handles
+		-- includes mode for portable digest calculation
+			-- thanks to Adam Kennedy for emails and ideas
+				ref. File::LocalizeNewlines
+	- used expanded addfile interface to simplify shasum (sumfile)
+		-- regex a tad less general than 5.37, but handles all
+			known newline variants in UNIX/Windows/MacOS
+	- enhanced WARNING messages from shasum checkfile processing
+		-- to mimic behavior of md5sum
+
+5.37  Mon May  8 04:30:09 MST 2006
+	- modified shasum to avoid file slurping (ref. sub sumfile)
+	- improved error handling of checksum files in shasum
+		-- to better mimic the behavior of md5sum
+	- refined line-break regex in shasum (ref. sub sumfile)
+		-- catches multiple CR's preceding LF
+			thanks to Gisle Aas for suggested patch
+	- changed loop vars to signed int's in shadump (ref. src/sha.c)
+		-- to prevent type mismatch warnings
+
+5.36  Mon May  8 01:38:36 MST 2006
+	- fixed the "portable" option in shasum
+		-- normalize line-breaks in text files only
+
+5.35  Thu May  4 16:54:42 MST 2006
+	- added "portable" option to shasum
+		-- to make digests match across Windows/Unix/MacOS
+	- enabled bundling of shasum command line options
+		-- to mimic behavior of md5sum
+	- removed \r's from text files in t/nist directory
+		-- resolves SIGNATURE clashes (rt.cpan.org #18983)
+	- changed suffix on SHA64_MAX (src/sha.h) to ULL
+		-- eliminates gcc warnings (rt.cpan.org #18988)
+	- specified minimum Perl version for module and Makefile.PL
+		-- closes rt.cpan.org #18984
+
+5.34  Thu Feb  2 18:55:40 MST 2006
+	- removed Unix-style pathnames in test scripts
+		-- causing problems on OpenVMS
+		-- thanks to Steve Peters for patch
+	- included latest version of Perl Portability header (ppport.h)
+	- added PERL_CORE check to test scripts
+		-- allows module to be built into Perl distribution
+
+5.32  Fri Dec  2 02:32:20 MST 2005
+	- added POD section to shasum script
+		-- thanks to Gunnar Wolf for patch
+	- made minor code changes to silence compiler warnings
+		-- resulting from signed/unsigned integer mixing
+	- inserted code in test scripts for POD checking
+		-- to recover gracefully if Test::More isn't installed
+
+5.31  Mon Sep  5 00:52:42 MST 2005
+	- added standard tests for pod and pod-coverage checking
+	- inserted subtest to check for failure when using
+		unrecognized SHA algorithm
+
+5.30  Sat Aug 20 16:46:08 MST 2005
+	- updated docs with recent NIST statement on SHA-1
+		-- advises use of larger and stronger hash functions
+			(i.e. SHA-224/256/384/512) for new developments
+
+5.29  Sun Aug 14 04:48:34 MST 2005
+	- added explicit casts in "shaload" routine (ref. "ldvals")
+		-- thanks to E. Allen Smith for pointing out SGI compiler
+			warnings on IPxx-irix platforms
+	- updated docs with cautionary note about SHA-1
+
+5.28  Wed Nov 10 15:33:20 MST 2004
+	- provided more flexible formatting of SHA state files
+		-- entries may now contain embedded whitespace
+			for improved readability
+	- minor code cleanups
+
+5.27  Sun Oct 24 02:54:00 MST 2004
+	- minor code cleanups
+		-- reduces size of dump files for SHA-1/224/256
+
+5.26  Thu Oct  7 14:52:00 MST 2004
+	- streamlined distribution
+		-- reduced NIST vector tests from 200 to 20
+			-- former number was overkill
+			-- distro now downloads and builds more quickly
+	- rewrote SYNOPSIS sections in pod file
+	- made additional tweaks to t/8-shasum.t for portability
+	- cleaned up test scripts
+
+5.25  Sun Sep 12 18:48:00 MST 2004
+	- removed non-essential test script
+		-- t/8-shasum.t causes problems on sparc64-linux
+	- reverted to using eval "require $module" in shasum
+
+5.24  Sun Sep 12 02:50:18 MST 2004
+	- modified shasum to use barewords in "require" statements
+		-- ref. perl.cpan.testers (157305)
+
+5.23  Thu Sep  9 23:06:18 MST 2004
+	- corrected bug in test script
+		-- use blib when invoking perl as an external
+			command in t/8-shasum.t
+
+5.22  Tue Sep  7 19:12:40 MST 2004
+	- broadened SHA-384/512 support
+		-- to compilers with no ULLONG_MAX in limits.h
+			-- e.g IBM C (xlC 6.0.0) on AIX 4.3.3
+			-- thanks to Chris Carey for suggestions
+				and technical expertise
+	- improved use of static storage class in transforms
+		-- detection of Intel arch. now done in Makefile.PL
+		-- NB: static not used if compiling for thread safety
+	- minor changes to documentation
+
+5.21  Mon Aug 23 04:02:00 MST 2004
+	- removed 64-bit constant expressions from #if statements
+		-- ref. src/sha.h (lines 55, 58, and 61)
+		-- even if compiler supports long long's, preprocessor
+			may use long's when evaluating expressions
+	- improved test script for "shasum" (t/8-shasum.t)
+		-- exercises check file option (-c)
+
+5.20  Sun Aug 15 04:24:48 MST 2004
+	- introduced "shasum" script
+		-- mimics the usage and behavior of "md5sum"
+		-- adds "-a" option to select SHA algorithm
+		-- for help, just type "shasum -h"
+
+5.10  Fri Aug  6 02:04:38 MST 2004
+	- simplified module documentation
+		-- made it consistent with Digest::SHA::PurePerl docs
+
+5.03  Sat Jul 31 00:00:48 MST 2004
+	- corrected HMAC-SHA-384/512 bug (cpan #7181, Adam Woodbury)
+		-- code was using hardwired blocksize for SHA-1/256
+			-- ref. src/hmac.c, src/hmac.h
+
+5.02  Thu Jul 29 02:48:00 MST 2004
+	- updated documentation and "dump-load.t" test script
+		-- to be consistent with Digest::SHA::PurePerl
+	- included a SIGNATURE file
+		-- for stronger authentication of module contents
+			-- ref. Module::Signature on CPAN
+	- corrected embarrassing misspelling in docs
+		-- apologies to Gisle Aas
+
+5.01  Fri May 21 13:08:12 MST 2004
+	- check for undefined SHA handle when calling "shaclose()"
+		-- prevents intermittent cleanup errors during
+			global object destruction
+
+5.00  Fri May 14 04:45:00 MST 2004
+	- minor documentation fixes
+	- restored classical style of version numbering (X.YZ)
+		-- previous X.Y.Z style caused installation difficulties
+			when using CPANPLUS
+
+4.3.3 Wed May  5 00:30:40 MST 2004
+	- fixed bug in "strto64()" function
+		-- caused problems in state files with CR/LF pairs
+		-- thanks to Martin Thurn for testing support
+
+4.3.2 Wed Apr 28 03:56:00 MST 2004
+	- added Makefile.PL options
+		-- thread-safety: -t
+		-- exclude 384/512 support: -x
+		-- e.g. perl Makefile.PL -t
+	- temporarily suppress dump/load tests for SHA-384/512
+		-- pending clarification of problem on sun4u sparc
+
+4.3.1 Thu Mar  4 02:54:00 MST 2004
+	- removed unused functions from XS file
+		-- reduces size of compiled objects
+	- simplified implementation of Digest::SHA object
+		-- now a blessed SHAPtr ref instead of blessed array ref
+		-- results in slight speed-up of OO operations
+	- streamlined underlying C source
+		-- used macros to consolidate repetitive code
+	- rewrote test scripts to depend on Test rather than Test::More
+		-- allows module to be checked in minimal Perl environments
+	- added compilation option for thread-safety
+		-- overrides use of static arrays
+
+4.3.0 Sat Feb  7 02:58:00 MST 2004
+	- included SHA-384/512 support if using Microsoft C/C++
+		-- uses MSVC's __int64 in place of "long long"
+	- enhanced portability and efficiency on diverse platforms
+		-- automatically sets up optimal types for 32/64-bit ops
+	- improved test scripts for better reporting
+		-- many thanks to Alex Muntada for helpful suggestions
+
+4.2.2 Sat Jan 31 17:10:20 MST 2004
+	- repaired 32-bit SHA operations for 8-byte longs
+
+4.2.1 Sat Jan 24 00:56:54 MST 2004
+	- modified I/O and memory management in underlying C code
+		-- uses Perl libraries when compiled as CPAN module
+			-- otherwise defaults to ANSI C libraries
+		-- bypasses problems in MSWin multi-threaded Perls
+			-- avoids "Free to wrong pool" error
+		-- special thanks to Robert Gilmour and Brian Gladman
+			for technical guidance and testing
+
+4.2.0 Sat Dec 27 16:08:00 MST 2003
+	- added support for recently-announced SHA-224 algorithm
+		-- ref. FIPS 180-2 Change Notice 1
+		-- also includes HMAC-SHA-224
+
+4.1.0 Thu Dec 25 00:58:00 MST 2003
+	- repaired "nist-vectors" test scripts for MSWin32 portability
+		-- use binmode for data files
+
+4.0.9 Wed Dec 24 02:58:22 MST 2003
+	- use canonical file specs in test scripts
+		-- enhances portability across different OSes
+	- modify type declarations of objects in XS file
+		-- re-declare as (SV *) and cast to (AV *) SvRV(self)
+			-- in response to AVPtr problem on MSWin32
+
+4.0.8 Thu Dec 18 23:32:00 MST 2003
+	- inherits from Digest::base if installed
+		-- also checks for MIME::Base64
+		-- still fully-functional if neither are installed
+	- added buffer overflow protection in underlying C code
+		-- ref. shahex() and shabase64() routines
+		-- prior code appeared impossible to exploit, but ...
+			-- better safe than sorry
+		-- does not impact runtime efficiency
+	- minor code cleanup
+
+4.0.7 Sat Dec 13 00:48:24 MST 2003
+	- check for undefined SHA handle when calling "shaclose()"
+		-- was causing cleanup err during global destruction
+
+4.0.6 Thu Dec 11 02:18:00 MST 2003
+	- more optimization and streamlining
+		-- a bit faster on non-big-endians (e.g. Intel)
+	- rewrote time-critical functions and methods in XS
+	- removed unused C functions from source files
+
+4.0.5 Sat Dec  6 00:02:24 MST 2003
+	- performance optimizations
+		-- rewrote "add" method in XS
+		-- unrolled loops in sha256 transform
+
+4.0.4 Thu Dec  4 00:07:00 MST 2003
+	- made Digest::SHA into a self-contained module
+		-- no longer depends on Digest::base
+		-- more convenient for users
+			-- no need to install Digest:: module
+
+4.0.3 Wed Dec  3 00:01:20 MST 2003
+	- Digest::SHA now a subclass of Digest::base
+		-- inherits hexdigest/b64digest/addfile methods
+	- added "hashsize" method
+	- removed old "shaopen()/shawrite()/..." legacy code
+		-- in favor of standard, streamlined OO interface
+	- renamed test vector files from NIST
+		-- prevents problems on 8+3 filesystems
+	- added test for Dave Ireland's SHA-256 vector
+
+4.0.0 Sat Nov 29 21:14:09 MST 2003
+	- major streamlining of interface (hence, major version change)
+		-- coordinated with Gisle Aas and J. Duque
+			-- goal is to produce a single SHA module
+		-- adheres to OO and functional styles of Digest::
+		-- greatly reduces the number of interface functions
+		-- old functions still supported
+			-- use Digest::SHA ':legacy'
+			-- will be deprecated in near future
+	- rewrote all test scripts to match new interface
+		-- very easy to modify all 281 tests
+		-- old interface maps cleanly to new one
+
+3.0   Wed Nov 26 05:02:34 MST 2003
+	- added functions that conform to Digest:: interface
+		-- both functional and OO styles
+			-- byte-oriented data only
+		-- continue to support original interface as well
+			-- necessary for bit-oriented data
+	- supplied formal test vectors for HMAC-SHA-256
+		-- from draft-ietf-ipsec-ciph-sha-256-01.txt
+	- included tests for all OO methods
+
+2.4   Sat Nov 22 17:10:22 MST 2003
+	- code cleanup
+		-- "sha.c" now completely free of #ifdef's
+	- modularized all 64-bit (long long) code
+	- improved readability of header files
+	- simplified logic of "fixdump" utility
+
+2.3   Wed Nov 19 03:54:31 MST 2003
+	- minor optimizations and code cleanup
+		-- improved maintainability by reducing #ifdef's
+		-- sha1 transform code now easier to follow
+	- streamlined shadump/shaload file format
+		-- eliminated special "HQ" entry
+		-- state now held in "H" for all transforms
+		-- supplied "fixdump" utility to convert old format
+	- SHA-384/512 functions now return NULL for no 64-bit operations
+		-- previously they were undefined
+		-- no longer necessary to use eval's to test for presence
+
+2.2   Sun Nov 16 01:54:00 MST 2003
+	- optimized the performance of the SHA-1 transform
+		-- around 20-30% faster than previous version
+		-- achieved by loop unrolling and assignment consolidation
+	- enhanced shaload/shadump to allow interaction with stdin/stdout
+		-- "$filename" argument now optional
+
+2.1   Sun Nov  9 03:28:04 MST 2003
+	- simplified data input routines
+		-- length argument now optional for byte data
+			(special thanks to Jeffrey Friedl for this idea)
+		-- interface still compatible with earlier versions
+			-- changes will not affect existing client code
+	- streamlined underlying C code for easier maintenance
+	- provided additional tests for persistent data
+
+2.0   Sat Nov  1 03:55:36 MST 2003
+	- added functions for HMAC-SHA-1/256/384/512 (FIPS PUB 198)
+	- shadump/shaload files now compatible between 32/64-bit machines
+
+1.01  Sat Oct 25 02:44:55 MST 2003
+	- package now downloads and installs much faster
+	- reduced distribution size by 80%
+		-- pruned extensive NIST vectors to a useful subset
+		-- still possible to test all vectors if desired
+			--- see "t/nist/COPYRIGHT" file for details
+	- added routines to provide persistent storage of SHA states
+		-- shadump() and shaload()
+	- reduced runtime of large bitstring tests (gillogly-hard)
+		-- illustrates usefulness of shadump()/shaload()
+
+1.0   Sat Oct 18 17:35:07 MST 2003
+	- documentation fixes
+	- code cleanup: no more compiler warnings from gcc -Wall
+	- added code to allow reading of intermediate digest state
+		-- shahex() prior to shafinish() returns current state
+
+0.9   Thu Oct  9 20:43:54 MST 2003
+	- version updated to reflect portability check and passing
+		of all tests (1401)
+
+0.01  Wed Oct  8 22:28:05 2003
+	- original version; created by h2xs 1.22 with options
+		-x -A -n Digest::SHA sha.h
diff --git a/cpan/Digest-SHA/Makefile.PL b/cpan/Digest-SHA/Makefile.PL
new file mode 100644
index 0000000000..df63c2bfbf
--- /dev/null
+++ b/cpan/Digest-SHA/Makefile.PL
@@ -0,0 +1,46 @@
+require 5.003000;
+
+use ExtUtils::MakeMaker;
+use Getopt::Std;
+use Config;
+
+my $PM = 'lib/Digest/SHA.pm';
+
+my $PERL_CORE = 0;
+$PERL_CORE = 1 if grep { $_ eq 'PERL_CORE=1' } @ARGV;
+
+my %opts;
+getopts('tx', \%opts);
+
+my @defines;
+push(@defines, '-DSHA_PERL_MODULE') if $] >= 5.004;
+push(@defines, '-DSHA_THREAD_SAFE') if $opts{'t'};
+push(@defines, '-DNO_SHA_384_512')  if $opts{'x'};
+
+	# Configure SHA source to use static arrays for
+	# message schedules if compiling on Intel platforms.
+	# This seems to speed things up a bit.  However,
+	# DON'T do this if thread-safe option is in force.
+	
+if ($Config{archname} =~ /^i[3456]86/) {
+	push(@defines, '-DSHA_STO_CLASS=static') unless $opts{'t'};
+}
+
+my $define = join(' ', @defines);
+
+my %att = (
+	'NAME'		=> 'Digest::SHA',
+	'VERSION_FROM'	=> $PM,
+	'LIBS'		=> [''],
+	'DEFINE'	=> $define,
+	'INC'		=> '-I.',
+	$PERL_CORE ? () : (
+	    'EXE_FILES'		=> [ 'shasum' ],
+	    'INSTALLDIRS'	=> ($] >= 5.010) ? 'perl' : 'site',
+	),
+);
+
+my $MMversion = $ExtUtils::MakeMaker::VERSION || 0;
+$att{NO_META} = 1 unless $MMversion < 6.10_03;
+
+WriteMakefile(%att);
diff --git a/cpan/Digest-SHA/README b/cpan/Digest-SHA/README
new file mode 100644
index 0000000000..8cd68bd837
--- /dev/null
+++ b/cpan/Digest-SHA/README
@@ -0,0 +1,44 @@
+Digest::SHA version 5.47
+========================
+
+Digest::SHA is a complete implementation of the NIST Secure Hash
+Standard.  It gives Perl programmers a convenient way to calculate
+SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512 message digests.
+The module can handle all types of input, including partial-byte
+data.
+
+Digest::SHA is written in C for speed.  If your platform lacks a
+C compiler, you can install the functionally-equivalent (but much
+slower) Digest::SHA::PurePerl module.
+
+The tests subdirectory (t/*.t) contains an extensive set of SHA
+vectors compiled from various sources.
+
+INSTALLATION
+
+To install this module type the following:
+
+	perl Makefile.PL [ options ]
+	make
+	make test
+	make install
+
+The Makefile.PL options are:
+
+	-t : build a thread-safe version of module
+	-x : exclude support for SHA-384/512
+
+DEPENDENCIES
+
+	None
+
+COPYRIGHT AND LICENSE
+
+Copyright (C) 2003-2008 Mark Shelor
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+Please refer to the Perl Artistic License for details:
+
+http://search.cpan.org/perldoc?perlartistic
diff --git a/cpan/Digest-SHA/SHA.xs b/cpan/Digest-SHA/SHA.xs
new file mode 100644
index 0000000000..7c394e98a8
--- /dev/null
+++ b/cpan/Digest-SHA/SHA.xs
@@ -0,0 +1,203 @@
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#include "src/sha.c"
+#include "src/hmac.c"
+
+static int ix2alg[] =
+	{1,1,1,224,224,224,256,256,256,384,384,384,512,512,512};
+
+MODULE = Digest::SHA		PACKAGE = Digest::SHA		
+
+PROTOTYPES: ENABLE
+
+#include "src/sha.h"
+#include "src/hmac.h"
+
+#ifndef INT2PTR
+#define INT2PTR(p, i) (p) (i)
+#endif
+
+int
+shaclose(s)
+	SHA *	s
+
+int
+shadump(file, s)
+	char *	file
+	SHA *	s
+
+SHA *
+shadup(s)
+	SHA *	s
+
+SHA *
+shaload(file)
+	char *	file
+
+SHA *
+shaopen(alg)
+	int	alg
+
+void
+sharewind(s)
+	SHA *	s
+
+unsigned long
+shawrite(bitstr, bitcnt, s)
+	unsigned char *	bitstr
+	unsigned long	bitcnt
+	SHA *	s
+
+void
+sha1(...)
+ALIAS:
+	Digest::SHA::sha1 = 0
+	Digest::SHA::sha1_hex = 1
+	Digest::SHA::sha1_base64 = 2
+	Digest::SHA::sha224 = 3
+	Digest::SHA::sha224_hex = 4
+	Digest::SHA::sha224_base64 = 5
+	Digest::SHA::sha256 = 6
+	Digest::SHA::sha256_hex = 7
+	Digest::SHA::sha256_base64 = 8
+	Digest::SHA::sha384 = 9
+	Digest::SHA::sha384_hex = 10
+	Digest::SHA::sha384_base64 = 11
+	Digest::SHA::sha512 = 12
+	Digest::SHA::sha512_hex = 13
+	Digest::SHA::sha512_base64 = 14
+PREINIT:
+	int i;
+	unsigned char *data;
+	STRLEN len;
+	SHA *state;
+	char *result;
+PPCODE:
+	if ((state = shaopen(ix2alg[ix])) == NULL)
+		XSRETURN_UNDEF;
+	for (i = 0; i < items; i++) {
+		data = (unsigned char *) (SvPV(ST(i), len));
+		shawrite(data, len << 3, state);
+	}
+	shafinish(state);
+	len = 0;
+	if (ix % 3 == 0) {
+		result = (char *) shadigest(state);
+		len = shadsize(state);
+	}
+	else if (ix % 3 == 1)
+		result = shahex(state);
+	else
+		result = shabase64(state);
+	ST(0) = sv_2mortal(newSVpv(result, len));
+	shaclose(state);
+	XSRETURN(1);
+
+void
+hmac_sha1(...)
+ALIAS:
+	Digest::SHA::hmac_sha1 = 0
+	Digest::SHA::hmac_sha1_hex = 1
+	Digest::SHA::hmac_sha1_base64 = 2
+	Digest::SHA::hmac_sha224 = 3
+	Digest::SHA::hmac_sha224_hex = 4
+	Digest::SHA::hmac_sha224_base64 = 5
+	Digest::SHA::hmac_sha256 = 6
+	Digest::SHA::hmac_sha256_hex = 7
+	Digest::SHA::hmac_sha256_base64 = 8
+	Digest::SHA::hmac_sha384 = 9
+	Digest::SHA::hmac_sha384_hex = 10
+	Digest::SHA::hmac_sha384_base64 = 11
+	Digest::SHA::hmac_sha512 = 12
+	Digest::SHA::hmac_sha512_hex = 13
+	Digest::SHA::hmac_sha512_base64 = 14
+PREINIT:
+	int i;
+	unsigned char *key;
+	unsigned char *data;
+	STRLEN len;
+	HMAC *state;
+	char *result;
+PPCODE:
+	key = (unsigned char *) (SvPV(ST(items-1), len));
+	if ((state = hmacopen(ix2alg[ix], key, len)) == NULL)
+		XSRETURN_UNDEF;
+	for (i = 0; i < items - 1; i++) {
+		data = (unsigned char *) (SvPV(ST(i), len));
+		hmacwrite(data, len << 3, state);
+	}
+	hmacfinish(state);
+	len = 0;
+	if (ix % 3 == 0) {
+		result = (char *) hmacdigest(state);
+		len = shadsize(state->osha);
+	}
+	else if (ix % 3 == 1)
+		result = hmachex(state);
+	else
+		result = hmacbase64(state);
+	ST(0) = sv_2mortal(newSVpv(result, len));
+	hmacclose(state);
+	XSRETURN(1);
+
+void
+hashsize(self)
+	SV *	self
+ALIAS:
+	Digest::SHA::hashsize = 0
+	Digest::SHA::algorithm = 1
+PREINIT:
+	SHA *state;
+	int result;
+PPCODE:
+	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
+	result = shadsize(state) << 3;
+	if (ix == 1 && result == 160)
+		result = 1;
+	ST(0) = sv_2mortal(newSViv(result));
+	XSRETURN(1);
+
+void
+add(self, ...)
+	SV *	self
+PREINIT:
+	int i;
+	unsigned char *data;
+	STRLEN len;
+	SHA *state;
+PPCODE:
+	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
+	for (i = 1; i < items; i++) {
+		data = (unsigned char *) (SvPV(ST(i), len));
+		shawrite(data, len << 3, state);
+	}
+	XSRETURN(1);
+
+void
+digest(self)
+	SV *	self
+ALIAS:
+	Digest::SHA::digest = 0
+	Digest::SHA::Hexdigest = 1
+	Digest::SHA::B64digest = 2
+PREINIT:
+	STRLEN len;
+	SHA *state;
+	char *result;
+PPCODE:
+	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
+	shafinish(state);
+	len = 0;
+	if (ix == 0) {
+		result = (char *) shadigest(state);
+		len = shadsize(state);
+	}
+	else if (ix == 1)
+		result = shahex(state);
+	else
+		result = shabase64(state);
+	ST(0) = sv_2mortal(newSVpv(result, len));
+	sharewind(state);
+	XSRETURN(1);
diff --git a/cpan/Digest-SHA/lib/Digest/SHA.pm b/cpan/Digest-SHA/lib/Digest/SHA.pm
new file mode 100644
index 0000000000..d57c16fce5
--- /dev/null
+++ b/cpan/Digest-SHA/lib/Digest/SHA.pm
@@ -0,0 +1,669 @@
+package Digest::SHA;
+
+require 5.003000;
+
+use strict;
+use integer;
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);
+
+$VERSION = '5.47';
+
+require Exporter;
+require DynaLoader;
+@ISA = qw(Exporter DynaLoader);
+@EXPORT_OK = qw(
+	hmac_sha1	hmac_sha1_base64	hmac_sha1_hex
+	hmac_sha224	hmac_sha224_base64	hmac_sha224_hex
+	hmac_sha256	hmac_sha256_base64	hmac_sha256_hex
+	hmac_sha384	hmac_sha384_base64	hmac_sha384_hex
+	hmac_sha512	hmac_sha512_base64	hmac_sha512_hex
+	sha1		sha1_base64		sha1_hex
+	sha224		sha224_base64		sha224_hex
+	sha256		sha256_base64		sha256_hex
+	sha384		sha384_base64		sha384_hex
+	sha512		sha512_base64		sha512_hex);
+
+# If possible, inherit from Digest::base (which depends on MIME::Base64)
+
+*addfile = \&Addfile;
+
+eval {
+	require MIME::Base64;
+	require Digest::base;
+	push(@ISA, 'Digest::base');
+};
+if ($@) {
+	*hexdigest = \&Hexdigest;
+	*b64digest = \&B64digest;
+}
+
+# The following routines aren't time-critical, so they can be left in Perl
+
+sub new {
+	my($class, $alg) = @_;
+	$alg =~ s/\D+//g if defined $alg;
+	if (ref($class)) {	# instance method
+		unless (defined($alg) && ($alg != $class->algorithm)) {
+			sharewind($$class);
+			return($class);
+		}
+		shaclose($$class) if $$class;
+		$$class = shaopen($alg) || return;
+		return($class);
+	}
+	$alg = 1 unless defined $alg;
+	my $state = shaopen($alg) || return;
+	my $self = \$state;
+	bless($self, $class);
+	return($self);
+}
+
+sub DESTROY {
+	my $self = shift;
+	shaclose($$self) if $$self;
+}
+
+sub clone {
+	my $self = shift;
+	my $state = shadup($$self) || return;
+	my $copy = \$state;
+	bless($copy, ref($self));
+	return($copy);
+}
+
+*reset = \&new;
+
+sub add_bits {
+	my($self, $data, $nbits) = @_;
+	unless (defined $nbits) {
+		$nbits = length($data);
+		$data = pack("B*", $data);
+	}
+	shawrite($data, $nbits, $$self);
+	return($self);
+}
+
+sub _bail {
+	my $msg = shift;
+
+        require Carp;
+        Carp::croak("$msg: $!");
+}
+
+sub _addfile {  # this is "addfile" from Digest::base 1.00
+    my ($self, $handle) = @_;
+
+    my $n;
+    my $buf = "";
+
+    while (($n = read($handle, $buf, 4096))) {
+        $self->add($buf);
+    }
+    _bail("Read failed") unless defined $n;
+
+    $self;
+}
+
+sub Addfile {
+	my ($self, $file, $mode) = @_;
+
+	return(_addfile($self, $file)) unless ref(\$file) eq 'SCALAR';
+
+	$mode = defined($mode) ? $mode : "";
+	my ($binary, $portable) = map { $_ eq $mode } ("b", "p");
+	my $text = -T $file;
+
+	local *FH;
+		# protect any leading or trailing whitespace in $file;
+		# otherwise, 2-arg "open" will ignore them
+	$file =~ s#^(\s)#./$1#;
+	open(FH, "< $file\0") or _bail("Open failed");
+	binmode(FH) if $binary || $portable;
+
+	unless ($portable && $text) {
+		$self->_addfile(*FH);
+		close(FH);
+		return($self);
+	}
+
+	my ($n1, $n2);
+	my ($buf1, $buf2) = ("", "");
+
+	while (($n1 = read(FH, $buf1, 4096))) {
+		while (substr($buf1, -1) eq "\015") {
+			$n2 = read(FH, $buf2, 4096);
+			_bail("Read failed") unless defined $n2;
+			last unless $n2;
+			$buf1 .= $buf2;
+		}
+		$buf1 =~ s/\015?\015\012/\012/g; 	# DOS/Windows
+		$buf1 =~ s/\015/\012/g;          	# early MacOS
+		$self->add($buf1);
+	}
+	_bail("Read failed") unless defined $n1;
+	close(FH);
+
+	$self;
+}
+
+sub dump {
+	my $self = shift;
+	my $file = shift || "";
+
+	shadump($file, $$self) || return;
+	return($self);
+}
+
+sub load {
+	my $class = shift;
+	my $file = shift || "";
+	if (ref($class)) {	# instance method
+		shaclose($$class) if $$class;
+		$$class = shaload($file) || return;
+		return($class);
+	}
+	my $state = shaload($file) || return;
+	my $self = \$state;
+	bless($self, $class);
+	return($self);
+}
+
+Digest::SHA->bootstrap($VERSION);
+
+1;
+__END__
+
+=head1 NAME
+
+Digest::SHA - Perl extension for SHA-1/224/256/384/512
+
+=head1 SYNOPSIS
+
+In programs:
+
+		# Functional interface
+
+	use Digest::SHA qw(sha1 sha1_hex sha1_base64 ...);
+
+	$digest = sha1($data);
+	$digest = sha1_hex($data);
+	$digest = sha1_base64($data);
+
+	$digest = sha256($data);
+	$digest = sha384_hex($data);
+	$digest = sha512_base64($data);
+
+		# Object-oriented
+
+	use Digest::SHA;
+
+	$sha = Digest::SHA->new($alg);
+
+	$sha->add($data);		# feed data into stream
+
+	$sha->addfile(*F);
+	$sha->addfile($filename);
+
+	$sha->add_bits($bits);
+	$sha->add_bits($data, $nbits);
+
+	$sha_copy = $sha->clone;	# if needed, make copy of
+	$sha->dump($file);		#	current digest state,
+	$sha->load($file);		#	or save it on disk
+
+	$digest = $sha->digest;		# compute digest
+	$digest = $sha->hexdigest;
+	$digest = $sha->b64digest;
+
+From the command line:
+
+	$ shasum files
+
+	$ shasum --help
+
+=head1 SYNOPSIS (HMAC-SHA)
+
+		# Functional interface only
+
+	use Digest::SHA qw(hmac_sha1 hmac_sha1_hex ...);
+
+	$digest = hmac_sha1($data, $key);
+	$digest = hmac_sha224_hex($data, $key);
+	$digest = hmac_sha256_base64($data, $key);
+
+=head1 ABSTRACT
+
+Digest::SHA is a complete implementation of the NIST Secure Hash
+Standard.  It gives Perl programmers a convenient way to calculate
+SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512 message digests.
+The module can handle all types of input, including partial-byte
+data.
+
+=head1 DESCRIPTION
+
+Digest::SHA is written in C for speed.  If your platform lacks a
+C compiler, you can install the functionally equivalent (but much
+slower) L<Digest::SHA::PurePerl> module.
+
+The programming interface is easy to use: it's the same one found
+in CPAN's L<Digest> module.  So, if your applications currently
+use L<Digest::MD5> and you'd prefer the stronger security of SHA,
+it's a simple matter to convert them.
+
+The interface provides two ways to calculate digests:  all-at-once,
+or in stages.  To illustrate, the following short program computes
+the SHA-256 digest of "hello world" using each approach:
+
+	use Digest::SHA qw(sha256_hex);
+
+	$data = "hello world";
+	@frags = split(//, $data);
+
+	# all-at-once (Functional style)
+	$digest1 = sha256_hex($data);
+
+	# in-stages (OOP style)
+	$state = Digest::SHA->new(256);
+	for (@frags) { $state->add($_) }
+	$digest2 = $state->hexdigest;
+
+	print $digest1 eq $digest2 ?
+		"whew!\n" : "oops!\n";
+
+To calculate the digest of an n-bit message where I<n> is not a
+multiple of 8, use the I<add_bits()> method.  For example, consider
+the 446-bit message consisting of the bit-string "110" repeated
+148 times, followed by "11".  Here's how to display its SHA-1
+digest:
+
+	use Digest::SHA;
+	$bits = "110" x 148 . "11";
+	$sha = Digest::SHA->new(1)->add_bits($bits);
+	print $sha->hexdigest, "\n";
+
+Note that for larger bit-strings, it's more efficient to use the
+two-argument version I<add_bits($data, $nbits)>, where I<$data> is
+in the customary packed binary format used for Perl strings.
+
+The module also lets you save intermediate SHA states to disk, or
+display them on standard output.  The I<dump()> method generates
+portable, human-readable text describing the current state of
+computation.  You can subsequently retrieve the file with I<load()>
+to resume where the calculation left off.
+
+To see what a state description looks like, just run the following:
+
+	use Digest::SHA;
+	Digest::SHA->new->add("Shaw" x 1962)->dump;
+
+As an added convenience, the Digest::SHA module offers routines to
+calculate keyed hashes using the HMAC-SHA-1/224/256/384/512
+algorithms.  These services exist in functional form only, and
+mimic the style and behavior of the I<sha()>, I<sha_hex()>, and
+I<sha_base64()> functions.
+
+	# Test vector from draft-ietf-ipsec-ciph-sha-256-01.txt
+
+	use Digest::SHA qw(hmac_sha256_hex);
+	print hmac_sha256_hex("Hi There", chr(0x0b) x 32), "\n";
+
+=head1 NIST STATEMENT ON SHA-1
+
+I<NIST was recently informed that researchers had discovered a way
+to "break" the current Federal Information Processing Standard SHA-1
+algorithm, which has been in effect since 1994. The researchers
+have not yet published their complete results, so NIST has not
+confirmed these findings. However, the researchers are a reputable
+research team with expertise in this area.>
+
+I<Due to advances in computing power, NIST already planned to phase
+out SHA-1 in favor of the larger and stronger hash functions (SHA-224,
+SHA-256, SHA-384 and SHA-512) by 2010. New developments should use
+the larger and stronger hash functions.>
+
+ref. L<http://www.csrc.nist.gov/pki/HashWorkshop/NIST%20Statement/Burr_Mar2005.html>
+
+=head1 PADDING OF BASE64 DIGESTS
+
+By convention, CPAN Digest modules do B<not> pad their Base64 output.
+Problems can occur when feeding such digests to other software that
+expects properly padded Base64 encodings.
+
+For the time being, any necessary padding must be done by the user.
+Fortunately, this is a simple operation: if the length of a Base64-encoded
+digest isn't a multiple of 4, simply append "=" characters to the end
+of the digest until it is:
+
+	while (length($b64_digest) % 4) {
+		$b64_digest .= '=';
+	}
+
+To illustrate, I<sha256_base64("abc")> is computed to be
+
+	ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0
+
+which has a length of 43.  So, the properly padded version is
+
+	ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0=
+
+=head1 EXPORT
+
+None by default.
+
+=head1 EXPORTABLE FUNCTIONS
+
+Provided your C compiler supports a 64-bit type (e.g. the I<long
+long> of C99, or I<__int64> used by Microsoft C/C++), all of these
+functions will be available for use.  Otherwise, you won't be able
+to perform the SHA-384 and SHA-512 transforms, both of which require
+64-bit operations.
+
+I<Functional style>
+
+=over 4
+
+=item B<sha1($data, ...)>
+
+=item B<sha224($data, ...)>
+
+=item B<sha256($data, ...)>
+
+=item B<sha384($data, ...)>
+
+=item B<sha512($data, ...)>
+
+Logically joins the arguments into a single string, and returns
+its SHA-1/224/256/384/512 digest encoded as a binary string.
+
+=item B<sha1_hex($data, ...)>
+
+=item B<sha224_hex($data, ...)>
+
+=item B<sha256_hex($data, ...)>
+
+=item B<sha384_hex($data, ...)>
+
+=item B<sha512_hex($data, ...)>
+
+Logically joins the arguments into a single string, and returns
+its SHA-1/224/256/384/512 digest encoded as a hexadecimal string.
+
+=item B<sha1_base64($data, ...)>
+
+=item B<sha224_base64($data, ...)>
+
+=item B<sha256_base64($data, ...)>
+
+=item B<sha384_base64($data, ...)>
+
+=item B<sha512_base64($data, ...)>
+
+Logically joins the arguments into a single string, and returns
+its SHA-1/224/256/384/512 digest encoded as a Base64 string.
+
+It's important to note that the resulting string does B<not> contain
+the padding characters typical of Base64 encodings.  This omission is
+deliberate, and is done to maintain compatibility with the family of
+CPAN Digest modules.  See L</"PADDING OF BASE64 DIGESTS"> for details.
+
+=back
+
+I<OOP style>
+
+=over 4
+
+=item B<new($alg)>
+
+Returns a new Digest::SHA object.  Allowed values for I<$alg> are
+1, 224, 256, 384, or 512.  It's also possible to use common string
+representations of the algorithm (e.g. "sha256", "SHA-384").  If
+the argument is missing, SHA-1 will be used by default.
+
+Invoking I<new> as an instance method will not create a new object;
+instead, it will simply reset the object to the initial state
+associated with I<$alg>.  If the argument is missing, the object
+will continue using the same algorithm that was selected at creation.
+
+=item B<reset($alg)>
+
+This method has exactly the same effect as I<new($alg)>.  In fact,
+I<reset> is just an alias for I<new>.
+
+=item B<hashsize>
+
+Returns the number of digest bits for this object.  The values are
+160, 224, 256, 384, and 512 for SHA-1, SHA-224, SHA-256, SHA-384,
+and SHA-512, respectively.
+
+=item B<algorithm>
+
+Returns the digest algorithm for this object.  The values are 1,
+224, 256, 384, and 512 for SHA-1, SHA-224, SHA-256, SHA-384, and
+SHA-512, respectively.
+
+=item B<clone>
+
+Returns a duplicate copy of the object.
+
+=item B<add($data, ...)>
+
+Logically joins the arguments into a single string, and uses it to
+update the current digest state.  In other words, the following
+statements have the same effect:
+
+	$sha->add("a"); $sha->add("b"); $sha->add("c");
+	$sha->add("a")->add("b")->add("c");
+	$sha->add("a", "b", "c");
+	$sha->add("abc");
+
+The return value is the updated object itself.
+
+=item B<add_bits($data, $nbits)>
+
+=item B<add_bits($bits)>
+
+Updates the current digest state by appending bits to it.  The
+return value is the updated object itself.
+
+The first form causes the most-significant I<$nbits> of I<$data>
+to be appended to the stream.  The I<$data> argument is in the
+customary binary format used for Perl strings.
+
+The second form takes an ASCII string of "0" and "1" characters as
+its argument.  It's equivalent to
+
+	$sha->add_bits(pack("B*", $bits), length($bits));
+
+So, the following two statements do the same thing:
+
+	$sha->add_bits("111100001010");
+	$sha->add_bits("\xF0\xA0", 12);
+
+=item B<addfile(*FILE)>
+
+Reads from I<FILE> until EOF, and appends that data to the current
+state.  The return value is the updated object itself.
+
+=item B<addfile($filename [, $mode])>
+
+Reads the contents of I<$filename>, and appends that data to the current
+state.  The return value is the updated object itself.
+
+By default, I<$filename> is simply opened and read; no special modes
+or I/O disciplines are used.  To change this, set the optional I<$mode>
+argument to one of the following values:
+
+	"b"	read file in binary mode
+
+	"p"	use portable mode
+
+The "p" mode is handy since it ensures that the digest value of
+I<$filename> will be the same when computed on different operating
+systems.  It accomplishes this by internally translating all newlines in
+text files to UNIX format before calculating the digest.  Binary files
+are read in raw mode with no translation whatsoever.
+
+For a fuller discussion of newline formats, refer to CPAN module
+L<File::LocalizeNewlines>.  Its "universal line separator" regex forms
+the basis of I<addfile>'s portable mode processing.
+
+=item B<dump($filename)>
+
+Provides persistent storage of intermediate SHA states by writing
+a portable, human-readable representation of the current state to
+I<$filename>.  If the argument is missing, or equal to the empty
+string, the state information will be written to STDOUT.
+
+=item B<load($filename)>
+
+Returns a Digest::SHA object representing the intermediate SHA
+state that was previously dumped to I<$filename>.  If called as a
+class method, a new object is created; if called as an instance
+method, the object is reset to the state contained in I<$filename>.
+If the argument is missing, or equal to the empty string, the state
+information will be read from STDIN.
+
+=item B<digest>
+
+Returns the digest encoded as a binary string.
+
+Note that the I<digest> method is a read-once operation. Once it
+has been performed, the Digest::SHA object is automatically reset
+in preparation for calculating another digest value.  Call
+I<$sha-E<gt>clone-E<gt>digest> if it's necessary to preserve the
+original digest state.
+
+=item B<hexdigest>
+
+Returns the digest encoded as a hexadecimal string.
+
+Like I<digest>, this method is a read-once operation.  Call
+I<$sha-E<gt>clone-E<gt>hexdigest> if it's necessary to preserve
+the original digest state.
+
+This method is inherited if L<Digest::base> is installed on your
+system.  Otherwise, a functionally equivalent substitute is used.
+
+=item B<b64digest>
+
+Returns the digest encoded as a Base64 string.
+
+Like I<digest>, this method is a read-once operation.  Call
+I<$sha-E<gt>clone-E<gt>b64digest> if it's necessary to preserve
+the original digest state.
+
+This method is inherited if L<Digest::base> is installed on your
+system.  Otherwise, a functionally equivalent substitute is used.
+
+It's important to note that the resulting string does B<not> contain
+the padding characters typical of Base64 encodings.  This omission is
+deliberate, and is done to maintain compatibility with the family of
+CPAN Digest modules.  See L</"PADDING OF BASE64 DIGESTS"> for details.
+
+=back
+
+I<HMAC-SHA-1/224/256/384/512>
+
+=over 4
+
+=item B<hmac_sha1($data, $key)>
+
+=item B<hmac_sha224($data, $key)>
+
+=item B<hmac_sha256($data, $key)>
+
+=item B<hmac_sha384($data, $key)>
+
+=item B<hmac_sha512($data, $key)>
+
+Returns the HMAC-SHA-1/224/256/384/512 digest of I<$data>/I<$key>,
+with the result encoded as a binary string.  Multiple I<$data>
+arguments are allowed, provided that I<$key> is the last argument
+in the list.
+
+=item B<hmac_sha1_hex($data, $key)>
+
+=item B<hmac_sha224_hex($data, $key)>
+
+=item B<hmac_sha256_hex($data, $key)>
+
+=item B<hmac_sha384_hex($data, $key)>
+
+=item B<hmac_sha512_hex($data, $key)>
+
+Returns the HMAC-SHA-1/224/256/384/512 digest of I<$data>/I<$key>,
+with the result encoded as a hexadecimal string.  Multiple I<$data>
+arguments are allowed, provided that I<$key> is the last argument
+in the list.
+
+=item B<hmac_sha1_base64($data, $key)>
+
+=item B<hmac_sha224_base64($data, $key)>
+
+=item B<hmac_sha256_base64($data, $key)>
+
+=item B<hmac_sha384_base64($data, $key)>
+
+=item B<hmac_sha512_base64($data, $key)>
+
+Returns the HMAC-SHA-1/224/256/384/512 digest of I<$data>/I<$key>,
+with the result encoded as a Base64 string.  Multiple I<$data>
+arguments are allowed, provided that I<$key> is the last argument
+in the list.
+
+It's important to note that the resulting string does B<not> contain
+the padding characters typical of Base64 encodings.  This omission is
+deliberate, and is done to maintain compatibility with the family of
+CPAN Digest modules.  See L</"PADDING OF BASE64 DIGESTS"> for details.
+
+=back
+
+=head1 SEE ALSO
+
+L<Digest>, L<Digest::SHA::PurePerl>
+
+The Secure Hash Standard (FIPS PUB 180-2) can be found at:
+
+L<http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf>
+
+The Keyed-Hash Message Authentication Code (HMAC):
+
+L<http://csrc.nist.gov/publications/fips/fips198/fips-198a.pdf>
+
+=head1 AUTHOR
+
+	Mark Shelor	<mshelor@cpan.org>
+
+=head1 ACKNOWLEDGMENTS
+
+The author is particularly grateful to
+
+	Gisle Aas
+	Chris Carey
+	Alexandr Ciornii
+	Jim Doble
+	Julius Duque
+	Jeffrey Friedl
+	Robert Gilmour
+	Brian Gladman
+	Adam Kennedy
+	Andy Lester
+	Alex Muntada
+	Steve Peters
+	Chris Skiscim
+	Martin Thurn
+	Gunnar Wolf
+	Adam Woodbury
+
+for their valuable comments and suggestions.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2003-2008 Mark Shelor
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+L<perlartistic>
+
+=cut
diff --git a/cpan/Digest-SHA/shasum b/cpan/Digest-SHA/shasum
new file mode 100755
index 0000000000..a349ed7181
--- /dev/null
+++ b/cpan/Digest-SHA/shasum
@@ -0,0 +1,268 @@
+#!perl -w
+
+	# shasum: filter for computing SHA digests (analogous to sha1sum)
+	#
+	# Copyright (C) 2003-2008 Mark Shelor, All Rights Reserved
+	#
+	# Version: 5.47
+	# Wed Apr 30 04:00:54 MST 2008
+
+=head1 NAME
+
+shasum - Print or Check SHA Checksums
+
+=head1 SYNOPSIS
+
+ Usage: shasum [OPTION] [FILE]...
+    or: shasum [OPTION] --check [FILE]
+ Print or check SHA checksums.
+ With no FILE, or when FILE is -, read standard input.
+
+  -a, --algorithm    1 (default), 224, 256, 384, 512
+  -b, --binary       read files in binary mode (default on DOS/Windows)
+  -c, --check        check SHA sums against given list
+  -p, --portable     read files in portable mode
+                         produces same digest on Windows/Unix/Mac
+  -t, --text         read files in text mode (default)
+
+ The following two options are useful only when verifying checksums:
+
+  -s, --status       don't output anything, status code shows success
+  -w, --warn         warn about improperly formatted SHA checksum lines
+
+  -h, --help         display this help and exit
+  -v, --version      output version information and exit
+
+ The sums are computed as described in FIPS PUB 180-2.  When checking,
+ the input should be a former output of this program.  The default mode
+ is to print a line with checksum, a character indicating type (`*'
+ for binary, `?' for portable, ` ' for text), and name for each FILE.
+
+=head1 DESCRIPTION
+
+The I<shasum> script provides the easiest and most convenient way to
+compute SHA message digests.  Rather than writing a program, the user
+simply feeds data to the script via the command line, and waits for
+the results to be printed on standard output.  Data can be fed to
+I<shasum> through files, standard input, or both.
+
+The following command shows how easy it is to compute digests for typical
+inputs such as the NIST test vector "abc":
+
+	perl -e "print qw(abc)" | shasum
+
+Or, if you want to use SHA-256 instead of the default SHA-1, simply say:
+
+	perl -e "print qw(abc)" | shasum -a 256
+
+Since I<shasum> uses the same interface employed by the familiar
+I<sha1sum> program (and its somewhat outmoded anscestor I<md5sum>),
+you can install this script as a convenient drop-in replacement.
+
+=head1 AUTHOR
+
+Copyright (c) 2003-2008 Mark Shelor <mshelor@cpan.org>.
+
+=head1 SEE ALSO
+
+shasum is implemented using the Perl module L<Digest::SHA> or
+L<Digest::SHA::PurePerl>.
+
+=cut
+
+use strict;
+use FileHandle;
+use Getopt::Long;
+
+my $VERSION = "5.47";
+
+
+	# Try to use Digest::SHA, since it's faster.  If not installed,
+	# use Digest::SHA::PurePerl instead.
+
+my $MOD_PREFER = "Digest::SHA";
+my $MOD_SECOND = "Digest::SHA::PurePerl";
+
+my $module = $MOD_PREFER;
+eval "require $module";
+if ($@) {
+	$module = $MOD_SECOND;
+	eval "require $module";
+	die "Unable to find $MOD_PREFER or $MOD_SECOND\n" if $@;
+}
+
+
+	# Usage statement adapted from Ulrich Drepper's md5sum.
+	# Include an "-a" option for algorithm selection,
+	# and a "-p" option for portable digest computation.
+
+sub usage {
+	my($err, $msg) = @_;
+
+	$msg = "" unless defined $msg;
+	if ($err) {
+		warn($msg . "Type shasum -h for help\n");
+		exit($err);
+	}
+	print <<'END_OF_USAGE';
+Usage: shasum [OPTION] [FILE]...
+   or: shasum [OPTION] --check [FILE]
+Print or check SHA checksums.
+With no FILE, or when FILE is -, read standard input.
+
+  -a, --algorithm    1 (default), 224, 256, 384, 512
+  -b, --binary       read files in binary mode (default on DOS/Windows)
+  -c, --check        check SHA sums against given list
+  -p, --portable     read files in portable mode
+                         produces same digest on Windows/Unix/Mac
+  -t, --text         read files in text mode (default)
+
+The following two options are useful only when verifying checksums:
+  -s, --status       don't output anything, status code shows success
+  -w, --warn         warn about improperly formatted SHA checksum lines
+
+  -h, --help         display this help and exit
+  -v, --version      output version information and exit
+
+The sums are computed as described in FIPS PUB 180-2.  When checking, the
+input should be a former output of this program.  The default mode is to
+print a line with checksum, a character indicating type (`*' for binary,
+`?' for portable, ` ' for text), and name for each FILE.
+
+Report bugs to <mshelor@cpan.org>.
+END_OF_USAGE
+	exit($err);
+}
+
+
+	# Collect options from command line
+
+my ($alg, $binary, $check, $text, $status, $warn, $help, $version);
+my ($portable);
+
+eval { Getopt::Long::Configure ("bundling") };
+GetOptions(
+	'b|binary' => \$binary, 'c|check' => \$check,
+	't|text' => \$text, 'a|algorithm=i' => \$alg,
+	's|status' => \$status, 'w|warn' => \$warn,
+	'h|help' => \$help, 'v|version' => \$version,
+	'p|portable' => \$portable
+) or usage(1, "");
+
+
+	# Deal with help requests and incorrect uses
+
+usage(0)
+	if $help;
+usage(1, "shasum: Ambiguous file mode\n")
+	if scalar(grep { defined $_ } ($binary, $portable, $text)) > 1;
+usage(1, "shasum: --warn option used only when verifying checksums\n")
+	if $warn && !$check;
+usage(1, "shasum: --status option used only when verifying checksums\n")
+	if $status && !$check;
+
+
+	# Default to SHA-1 unless overriden by command line option
+
+$alg = 1 unless $alg;
+grep { $_ == $alg } (1, 224, 256, 384, 512)
+	or usage(1, "shasum: Unrecognized algorithm\n");
+
+
+	# Display version information if requested
+
+if ($version) {
+	print "$VERSION\n";
+	exit(0);
+}
+
+
+	# Try to figure out if the OS is DOS-like.  If it is,
+	# default to binary mode when reading files, unless
+	# explicitly overriden by command line "--text" or
+	# "--portable" options.
+
+my $isDOSish = ($^O =~ /^(MSWin\d\d|os2|dos|mint|cygwin)$/);
+if ($isDOSish) { $binary = 1 unless $text || $portable }
+
+my $modesym = $binary ? '*' : ($portable ? '?' : ' ');
+
+
+	# Read from STDIN (-) if no files listed on command line
+
+@ARGV = ("-") unless @ARGV;
+
+
+	# sumfile($file): computes SHA digest of $file
+
+sub sumfile {
+	my $file = shift;
+
+	my $mode = $portable ? 'p' : ($binary ? 'b' : '');
+	my $digest = eval { $module->new($alg)->addfile($file, $mode) };
+	if ($@) {
+		warn "shasum: $file: $!\n";
+		return;
+	}
+
+	$digest->hexdigest;
+}
+
+
+	# %len2alg: maps hex digest length to SHA algorithm
+
+my %len2alg = (40 => 1, 56 => 224, 64 => 256, 96 => 384, 128 => 512);
+
+
+	# Verify checksums if requested
+
+if ($check) {
+	my $checkfile = shift(@ARGV);
+	my ($err, $read_errs, $match_errs) = (0, 0, 0);
+	my ($num_files, $num_checksums) = (0, 0);
+	my ($fh, $sum, $fname, $rsp, $digest);
+
+	die "shasum: $checkfile: $!\n"
+		unless $fh = FileHandle->new($checkfile, "r");
+	while (<$fh>) {
+		s/\s+$//;
+		($sum, $modesym, $fname) = /^(\S+) (.)(.*)$/;
+		($binary, $portable, $text) =
+			map { $_ eq $modesym } ('*', '?', ' ');
+		unless ($alg = $len2alg{length($sum)}) {
+			warn("shasum: $checkfile: $.: improperly " .
+				"formatted SHA checksum line\n") if $warn;
+			next;
+		}
+		$rsp = "$fname: "; $num_files++;
+		unless ($digest = sumfile($fname)) {
+			$rsp .= "FAILED open or read\n";
+			$err = 1; $read_errs++;
+		}
+		else {
+			$num_checksums++;
+			if (lc($sum) eq $digest) { $rsp .= "OK\n" }
+			else { $rsp .= "FAILED\n"; $err = 1; $match_errs++ }
+		}
+		print $rsp unless $status;
+	}
+	$fh->close;
+	unless ($status) {
+		warn("shasum: WARNING: $read_errs of $num_files listed " .
+			"files could not be read\n") if $read_errs;
+		warn("shasum: WARNING: $match_errs of $num_checksums " .
+			"computed checksums did NOT match\n") if $match_errs;
+	}
+	exit($err);
+}
+
+
+	# Compute and display SHA checksums of requested files
+
+my($file, $digest);
+
+for $file (@ARGV) {
+	if ($digest = sumfile($file)) {
+		print "$digest $modesym", "$file\n";
+	}
+}
diff --git a/cpan/Digest-SHA/src/hmac.c b/cpan/Digest-SHA/src/hmac.c
new file mode 100644
index 0000000000..ca5536e67a
--- /dev/null
+++ b/cpan/Digest-SHA/src/hmac.c
@@ -0,0 +1,103 @@
+/*
+ * hmac.c: routines to compute HMAC-SHA-1/224/256/384/512 digests
+ *
+ * Ref: FIPS PUB 198 The Keyed-Hash Message Authentication Code
+ *
+ * Copyright (C) 2003-2008 Mark Shelor, All Rights Reserved
+ *
+ * Version: 5.47
+ * Wed Apr 30 04:00:54 MST 2008
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "hmac.h"
+#include "sha.h"
+
+/* hmacopen: creates a new HMAC-SHA digest object */
+HMAC *hmacopen(int alg, unsigned char *key, unsigned int keylen)
+{
+	unsigned int i;
+	HMAC *h;
+
+	SHA_newz(0, h, 1, HMAC);
+	if (h == NULL)
+		return(NULL);
+	if ((h->isha = shaopen(alg)) == NULL) {
+		SHA_free(h);
+		return(NULL);
+	}
+	if ((h->osha = shaopen(alg)) == NULL) {
+		shaclose(h->isha);
+		SHA_free(h);
+		return(NULL);
+	}
+	if (keylen <= h->osha->blocksize / 8)
+		memcpy(h->key, key, keylen);
+	else {
+		if ((h->ksha = shaopen(alg)) == NULL) {
+			shaclose(h->isha);
+			shaclose(h->osha);
+			SHA_free(h);
+			return(NULL);
+		}
+		shawrite(key, keylen * 8, h->ksha);
+		shafinish(h->ksha);
+		memcpy(h->key, shadigest(h->ksha), h->ksha->digestlen);
+		shaclose(h->ksha);
+	}
+	for (i = 0; i < h->osha->blocksize / 8; i++)
+		h->key[i] ^= 0x5c;
+	shawrite(h->key, h->osha->blocksize, h->osha);
+	for (i = 0; i < h->isha->blocksize / 8; i++)
+		h->key[i] ^= (0x5c ^ 0x36);
+	shawrite(h->key, h->isha->blocksize, h->isha);
+	memset(h->key, 0, sizeof(h->key));
+	return(h);
+}
+
+/* hmacwrite: triggers a state update using data in bitstr/bitcnt */
+unsigned long hmacwrite(unsigned char *bitstr, unsigned long bitcnt, HMAC *h)
+{
+	return(shawrite(bitstr, bitcnt, h->isha));
+}
+
+/* hmacfinish: computes final digest state */
+void hmacfinish(HMAC *h)
+{
+	shafinish(h->isha);
+	shawrite(shadigest(h->isha), h->isha->digestlen * 8, h->osha);
+	shaclose(h->isha);
+	shafinish(h->osha);
+}
+
+/* hmacdigest: returns pointer to digest (binary) */
+unsigned char *hmacdigest(HMAC *h)
+{
+	return(shadigest(h->osha));
+}
+
+/* hmachex: returns pointer to digest (hexadecimal) */
+char *hmachex(HMAC *h)
+{
+	return(shahex(h->osha));
+}
+
+/* hmacbase64: returns pointer to digest (Base 64) */
+char *hmacbase64(HMAC *h)
+{
+	return(shabase64(h->osha));
+}
+
+/* hmacclose: de-allocates digest object */
+int hmacclose(HMAC *h)
+{
+	if (h != NULL) {
+		shaclose(h->osha);
+		memset(h, 0, sizeof(HMAC));
+		SHA_free(h);
+	}
+	return(0);
+}
diff --git a/cpan/Digest-SHA/src/hmac.h b/cpan/Digest-SHA/src/hmac.h
new file mode 100644
index 0000000000..b2f5795f05
--- /dev/null
+++ b/cpan/Digest-SHA/src/hmac.h
@@ -0,0 +1,58 @@
+/*
+ * hmac.h: header file for HMAC-SHA-1/224/256/384/512 routines
+ *
+ * Ref: FIPS PUB 198 The Keyed-Hash Message Authentication Code
+ *
+ * Copyright (C) 2003-2008 Mark Shelor, All Rights Reserved
+ *
+ * Version: 5.47
+ * Wed Apr 30 04:00:54 MST 2008
+ *
+ */
+
+#ifndef _INCLUDE_HMAC_H_
+#define _INCLUDE_HMAC_H_
+
+#include "sha.h"
+
+typedef struct {
+	SHA *ksha;
+	SHA *isha;
+	SHA *osha;
+	unsigned char key[SHA_MAX_BLOCK_BITS/8];
+} HMAC;
+
+#define _HMAC_STATE	HMAC *h
+#define _HMAC_ALG	int alg
+#define _HMAC_DATA	unsigned char *bitstr, unsigned long bitcnt
+#define _HMAC_KEY	unsigned char *key, unsigned int keylen
+
+HMAC		*hmacopen 	(_HMAC_ALG, _HMAC_KEY);
+unsigned long	 hmacwrite	(_HMAC_DATA, _HMAC_STATE);
+void		 hmacfinish	(_HMAC_STATE);
+unsigned char	*hmacdigest	(_HMAC_STATE);
+char		*hmachex	(_HMAC_STATE);
+char		*hmacbase64	(_HMAC_STATE);
+int		 hmacclose	(_HMAC_STATE);
+
+#ifndef SHA_PERL_MODULE
+
+unsigned char	*hmac1digest	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac1hex	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac1base64	(_HMAC_DATA, _HMAC_KEY);
+unsigned char	*hmac224digest	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac224hex	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac224base64	(_HMAC_DATA, _HMAC_KEY);
+unsigned char	*hmac256digest	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac256hex	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac256base64	(_HMAC_DATA, _HMAC_KEY);
+unsigned char	*hmac384digest	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac384hex	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac384base64	(_HMAC_DATA, _HMAC_KEY);
+unsigned char	*hmac512digest	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac512hex	(_HMAC_DATA, _HMAC_KEY);
+char		*hmac512base64	(_HMAC_DATA, _HMAC_KEY);
+
+#endif
+
+#endif	/* _INCLUDE_HMAC_H_ */
diff --git a/cpan/Digest-SHA/src/hmacxtra.c b/cpan/Digest-SHA/src/hmacxtra.c
new file mode 100644
index 0000000000..041a291041
--- /dev/null
+++ b/cpan/Digest-SHA/src/hmacxtra.c
@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <string.h>
+#include "hmac.h"
+
+static unsigned char *hmaccomp(alg, fmt, bitstr, bitcnt, key, keylen)
+int alg;
+int fmt;
+unsigned char *bitstr;
+unsigned long bitcnt;
+unsigned char *key;
+unsigned int keylen;
+{
+	HMAC *h;
+	static unsigned char digest[SHA_MAX_HEX_LEN+1];
+	unsigned char *ret = digest;
+
+	if ((h = hmacopen(alg, key, keylen)) == NULL)
+		return(NULL);
+	hmacwrite(bitstr, bitcnt, h);
+	hmacfinish(h);
+	if (fmt == SHA_FMT_RAW)
+		memcpy(digest, hmacdigest(h), h->osha->digestlen);
+	else if (fmt == SHA_FMT_HEX)
+		strcpy((char *) digest, hmachex(h));
+	else if (fmt == SHA_FMT_BASE64)
+		strcpy((char *) digest, hmacbase64(h));
+	else
+		ret = NULL;
+	hmacclose(h);
+	return(ret);
+}
+
+#define HMAC_DIRECT(type, name, alg, fmt) 			\
+type name(bitstr, bitcnt, key, keylen)				\
+unsigned char *bitstr;						\
+unsigned long bitcnt;						\
+unsigned char *key;						\
+unsigned int keylen;						\
+{								\
+	return((type) hmaccomp(alg, fmt, bitstr, bitcnt,	\
+					key, keylen));		\
+}
+
+HMAC_DIRECT(unsigned char *, hmac1digest, SHA1, SHA_FMT_RAW)
+HMAC_DIRECT(char *, hmac1hex, SHA1, SHA_FMT_HEX)
+HMAC_DIRECT(char *, hmac1base64, SHA1, SHA_FMT_BASE64)
+
+HMAC_DIRECT(unsigned char *, hmac224digest, SHA224, SHA_FMT_RAW)
+HMAC_DIRECT(char *, hmac224hex, SHA224, SHA_FMT_HEX)
+HMAC_DIRECT(char *, hmac224base64, SHA224, SHA_FMT_BASE64)
+
+HMAC_DIRECT(unsigned char *, hmac256digest, SHA256, SHA_FMT_RAW)
+HMAC_DIRECT(char *, hmac256hex, SHA256, SHA_FMT_HEX)
+HMAC_DIRECT(char *, hmac256base64, SHA256, SHA_FMT_BASE64)
+
+HMAC_DIRECT(unsigned char *, hmac384digest, SHA384, SHA_FMT_RAW)
+HMAC_DIRECT(char *, hmac384hex, SHA384, SHA_FMT_HEX)
+HMAC_DIRECT(char *, hmac384base64, SHA384, SHA_FMT_BASE64)
+
+HMAC_DIRECT(unsigned char *, hmac512digest, SHA512, SHA_FMT_RAW)
+HMAC_DIRECT(char *, hmac512hex, SHA512, SHA_FMT_HEX)
+HMAC_DIRECT(char *, hmac512base64, SHA512, SHA_FMT_BASE64)
diff --git a/cpan/Digest-SHA/src/sha.c b/cpan/Digest-SHA/src/sha.c
new file mode 100644
index 0000000000..eec969bc32
--- /dev/null
+++ b/cpan/Digest-SHA/src/sha.c
@@ -0,0 +1,640 @@
+/*
+ * sha.c: routines to compute SHA-1/224/256/384/512 digests
+ *
+ * Ref: NIST FIPS PUB 180-2 Secure Hash Standard
+ *
+ * Copyright (C) 2003-2008 Mark Shelor, All Rights Reserved
+ *
+ * Version: 5.47
+ * Wed Apr 30 04:00:54 MST 2008
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <ctype.h>
+#include "sha.h"
+#include "sha64bit.h"
+
+#define W32	SHA32			/* useful abbreviations */
+#define C32	SHA32_CONST
+#define SR32	SHA32_SHR
+#define SL32	SHA32_SHL
+#define LO32	SHA_LO32
+#define UCHR	unsigned char
+#define UINT	unsigned int
+#define ULNG	unsigned long
+#define VP	void *
+
+#define ROTR(x, n)	(SR32(x, n) | SL32(x, 32-(n)))
+#define ROTL(x, n)	(SL32(x, n) | SR32(x, 32-(n)))
+
+#define Ch(x, y, z)	((z) ^ ((x) & ((y) ^ (z))))
+#define Pa(x, y, z)	((x) ^ (y) ^ (z))
+#define Ma(x, y, z)	(((x) & (y)) | ((z) & ((x) | (y))))
+
+#define SIGMA0(x)	(ROTR(x,  2) ^ ROTR(x, 13) ^ ROTR(x, 22))
+#define SIGMA1(x)	(ROTR(x,  6) ^ ROTR(x, 11) ^ ROTR(x, 25))
+#define sigma0(x)	(ROTR(x,  7) ^ ROTR(x, 18) ^ SR32(x,  3))
+#define sigma1(x)	(ROTR(x, 17) ^ ROTR(x, 19) ^ SR32(x, 10))
+
+#define K1	C32(0x5a827999)		/* SHA-1 constants */
+#define K2	C32(0x6ed9eba1)
+#define K3	C32(0x8f1bbcdc)
+#define K4	C32(0xca62c1d6)
+
+static W32 K256[64] =			/* SHA-224/256 constants */
+{
+	C32(0x428a2f98), C32(0x71374491), C32(0xb5c0fbcf), C32(0xe9b5dba5),
+	C32(0x3956c25b), C32(0x59f111f1), C32(0x923f82a4), C32(0xab1c5ed5),
+	C32(0xd807aa98), C32(0x12835b01), C32(0x243185be), C32(0x550c7dc3),
+	C32(0x72be5d74), C32(0x80deb1fe), C32(0x9bdc06a7), C32(0xc19bf174),
+	C32(0xe49b69c1), C32(0xefbe4786), C32(0x0fc19dc6), C32(0x240ca1cc),
+	C32(0x2de92c6f), C32(0x4a7484aa), C32(0x5cb0a9dc), C32(0x76f988da),
+	C32(0x983e5152), C32(0xa831c66d), C32(0xb00327c8), C32(0xbf597fc7),
+	C32(0xc6e00bf3), C32(0xd5a79147), C32(0x06ca6351), C32(0x14292967),
+	C32(0x27b70a85), C32(0x2e1b2138), C32(0x4d2c6dfc), C32(0x53380d13),
+	C32(0x650a7354), C32(0x766a0abb), C32(0x81c2c92e), C32(0x92722c85),
+	C32(0xa2bfe8a1), C32(0xa81a664b), C32(0xc24b8b70), C32(0xc76c51a3),
+	C32(0xd192e819), C32(0xd6990624), C32(0xf40e3585), C32(0x106aa070),
+	C32(0x19a4c116), C32(0x1e376c08), C32(0x2748774c), C32(0x34b0bcb5),
+	C32(0x391c0cb3), C32(0x4ed8aa4a), C32(0x5b9cca4f), C32(0x682e6ff3),
+	C32(0x748f82ee), C32(0x78a5636f), C32(0x84c87814), C32(0x8cc70208),
+	C32(0x90befffa), C32(0xa4506ceb), C32(0xbef9a3f7), C32(0xc67178f2)
+};
+
+static W32 H01[5] =			/* SHA-1 initial hash value */
+{
+	C32(0x67452301), C32(0xefcdab89), C32(0x98badcfe),
+	C32(0x10325476), C32(0xc3d2e1f0)
+};
+
+static W32 H0224[8] =			/* SHA-224 initial hash value */
+{
+	C32(0xc1059ed8), C32(0x367cd507), C32(0x3070dd17), C32(0xf70e5939),
+	C32(0xffc00b31), C32(0x68581511), C32(0x64f98fa7), C32(0xbefa4fa4)
+};
+
+static W32 H0256[8] =			/* SHA-256 initial hash value */
+{
+	C32(0x6a09e667), C32(0xbb67ae85), C32(0x3c6ef372), C32(0xa54ff53a),
+	C32(0x510e527f), C32(0x9b05688c), C32(0x1f83d9ab), C32(0x5be0cd19)
+};
+
+static void sha1(SHA *s, UCHR *block)		/* SHA-1 transform */
+{
+	W32 a, b, c, d, e;
+	SHA_STO_CLASS W32 W[16];
+	W32 *wp = W;
+	W32 *H = (W32 *) s->H;
+
+	SHA32_SCHED(W, block);
+
+/*
+ * Use SHA-1 alternate method from FIPS PUB 180-2 (ref. 6.1.3)
+ *
+ * To improve performance, unroll the loop and consolidate assignments
+ * by changing the roles of variables "a" through "e" at each step.
+ * Note that the variable "T" is no longer needed.
+ */
+
+#define M1(a, b, c, d, e, f, k, w)		\
+	e += ROTL(a, 5) + f(b, c, d) + k + w;	\
+	b =  ROTL(b, 30)
+
+#define M11(f, k, w)	M1(a, b, c, d, e, f, k, w);
+#define M12(f, k, w)	M1(e, a, b, c, d, f, k, w);
+#define M13(f, k, w)	M1(d, e, a, b, c, f, k, w);
+#define M14(f, k, w)	M1(c, d, e, a, b, f, k, w);
+#define M15(f, k, w)	M1(b, c, d, e, a, f, k, w);
+
+#define W11(s)	W[(s+ 0) & 0xf]
+#define W12(s)	W[(s+13) & 0xf]
+#define W13(s)	W[(s+ 8) & 0xf]
+#define W14(s)	W[(s+ 2) & 0xf]
+
+#define A1(s)	(W11(s) = ROTL(W11(s) ^ W12(s) ^ W13(s) ^ W14(s), 1))
+
+	a = H[0]; b = H[1]; c = H[2]; d = H[3]; e = H[4];
+
+	M11(Ch, K1,  *wp++); M12(Ch, K1,  *wp++); M13(Ch, K1,  *wp++);
+	M14(Ch, K1,  *wp++); M15(Ch, K1,  *wp++); M11(Ch, K1,  *wp++);
+	M12(Ch, K1,  *wp++); M13(Ch, K1,  *wp++); M14(Ch, K1,  *wp++);
+	M15(Ch, K1,  *wp++); M11(Ch, K1,  *wp++); M12(Ch, K1,  *wp++);
+	M13(Ch, K1,  *wp++); M14(Ch, K1,  *wp++); M15(Ch, K1,  *wp++);
+	M11(Ch, K1,  *wp  ); M12(Ch, K1, A1( 0)); M13(Ch, K1, A1( 1));
+	M14(Ch, K1, A1( 2)); M15(Ch, K1, A1( 3)); M11(Pa, K2, A1( 4));
+	M12(Pa, K2, A1( 5)); M13(Pa, K2, A1( 6)); M14(Pa, K2, A1( 7));
+	M15(Pa, K2, A1( 8)); M11(Pa, K2, A1( 9)); M12(Pa, K2, A1(10));
+	M13(Pa, K2, A1(11)); M14(Pa, K2, A1(12)); M15(Pa, K2, A1(13));
+	M11(Pa, K2, A1(14)); M12(Pa, K2, A1(15)); M13(Pa, K2, A1( 0));
+	M14(Pa, K2, A1( 1)); M15(Pa, K2, A1( 2)); M11(Pa, K2, A1( 3));
+	M12(Pa, K2, A1( 4)); M13(Pa, K2, A1( 5)); M14(Pa, K2, A1( 6));
+	M15(Pa, K2, A1( 7)); M11(Ma, K3, A1( 8)); M12(Ma, K3, A1( 9));
+	M13(Ma, K3, A1(10)); M14(Ma, K3, A1(11)); M15(Ma, K3, A1(12));
+	M11(Ma, K3, A1(13)); M12(Ma, K3, A1(14)); M13(Ma, K3, A1(15));
+	M14(Ma, K3, A1( 0)); M15(Ma, K3, A1( 1)); M11(Ma, K3, A1( 2));
+	M12(Ma, K3, A1( 3)); M13(Ma, K3, A1( 4)); M14(Ma, K3, A1( 5));
+	M15(Ma, K3, A1( 6)); M11(Ma, K3, A1( 7)); M12(Ma, K3, A1( 8));
+	M13(Ma, K3, A1( 9)); M14(Ma, K3, A1(10)); M15(Ma, K3, A1(11));
+	M11(Pa, K4, A1(12)); M12(Pa, K4, A1(13)); M13(Pa, K4, A1(14));
+	M14(Pa, K4, A1(15)); M15(Pa, K4, A1( 0)); M11(Pa, K4, A1( 1));
+	M12(Pa, K4, A1( 2)); M13(Pa, K4, A1( 3)); M14(Pa, K4, A1( 4));
+	M15(Pa, K4, A1( 5)); M11(Pa, K4, A1( 6)); M12(Pa, K4, A1( 7));
+	M13(Pa, K4, A1( 8)); M14(Pa, K4, A1( 9)); M15(Pa, K4, A1(10));
+	M11(Pa, K4, A1(11)); M12(Pa, K4, A1(12)); M13(Pa, K4, A1(13));
+	M14(Pa, K4, A1(14)); M15(Pa, K4, A1(15));
+
+	H[0] += a; H[1] += b; H[2] += c; H[3] += d; H[4] += e;
+}
+
+static void sha256(SHA *s, UCHR *block)		/* SHA-224/256 transform */
+{
+	W32 a, b, c, d, e, f, g, h, T1;
+	SHA_STO_CLASS W32 W[16];
+	W32 *kp = K256;
+	W32 *wp = W;
+	W32 *H = (W32 *) s->H;
+
+	SHA32_SCHED(W, block);
+
+/*
+ * Use same technique as in sha1()
+ *
+ * To improve performance, unroll the loop and consolidate assignments
+ * by changing the roles of variables "a" through "h" at each step.
+ * Note that the variable "T2" is no longer needed.
+ */
+
+#define M2(a, b, c, d, e, f, g, h, w)				\
+	T1 = h  + SIGMA1(e) + Ch(e, f, g) + (*kp++) + w;	\
+	h  = T1 + SIGMA0(a) + Ma(a, b, c); d += T1;
+
+#define W21(s)	W[(s+ 0) & 0xf]
+#define W22(s)	W[(s+14) & 0xf]
+#define W23(s)	W[(s+ 9) & 0xf]
+#define W24(s)	W[(s+ 1) & 0xf]
+
+#define A2(s)	(W21(s) += sigma1(W22(s)) + W23(s) + sigma0(W24(s)))
+
+#define M21(w)	M2(a, b, c, d, e, f, g, h, w)
+#define M22(w)	M2(h, a, b, c, d, e, f, g, w)
+#define M23(w)	M2(g, h, a, b, c, d, e, f, w)
+#define M24(w)	M2(f, g, h, a, b, c, d, e, w)
+#define M25(w)	M2(e, f, g, h, a, b, c, d, w)
+#define M26(w)	M2(d, e, f, g, h, a, b, c, w)
+#define M27(w)	M2(c, d, e, f, g, h, a, b, w)
+#define M28(w)	M2(b, c, d, e, f, g, h, a, w)
+
+	a = H[0]; b = H[1]; c = H[2]; d = H[3];
+	e = H[4]; f = H[5]; g = H[6]; h = H[7];
+
+	M21( *wp++); M22( *wp++); M23( *wp++); M24( *wp++);
+	M25( *wp++); M26( *wp++); M27( *wp++); M28( *wp++);
+	M21( *wp++); M22( *wp++); M23( *wp++); M24( *wp++);
+	M25( *wp++); M26( *wp++); M27( *wp++); M28( *wp  );
+	M21(A2( 0)); M22(A2( 1)); M23(A2( 2)); M24(A2( 3));
+	M25(A2( 4)); M26(A2( 5)); M27(A2( 6)); M28(A2( 7));
+	M21(A2( 8)); M22(A2( 9)); M23(A2(10)); M24(A2(11));
+	M25(A2(12)); M26(A2(13)); M27(A2(14)); M28(A2(15));
+	M21(A2( 0)); M22(A2( 1)); M23(A2( 2)); M24(A2( 3));
+	M25(A2( 4)); M26(A2( 5)); M27(A2( 6)); M28(A2( 7));
+	M21(A2( 8)); M22(A2( 9)); M23(A2(10)); M24(A2(11));
+	M25(A2(12)); M26(A2(13)); M27(A2(14)); M28(A2(15));
+	M21(A2( 0)); M22(A2( 1)); M23(A2( 2)); M24(A2( 3));
+	M25(A2( 4)); M26(A2( 5)); M27(A2( 6)); M28(A2( 7));
+	M21(A2( 8)); M22(A2( 9)); M23(A2(10)); M24(A2(11));
+	M25(A2(12)); M26(A2(13)); M27(A2(14)); M28(A2(15));
+
+	H[0] += a; H[1] += b; H[2] += c; H[3] += d;
+	H[4] += e; H[5] += f; H[6] += g; H[7] += h;
+}
+
+#include "sha64bit.c"
+
+#define SETBIT(s, pos)	s[(pos) >> 3] |=  (0x01 << (7 - (pos) % 8))
+#define CLRBIT(s, pos)	s[(pos) >> 3] &= ~(0x01 << (7 - (pos) % 8))
+#define NBYTES(nbits)	((nbits) > 0 ? 1 + (((nbits) - 1) >> 3) : 0)
+#define HEXLEN(nbytes)	((nbytes) << 1)
+#define B64LEN(nbytes)	(((nbytes) % 3 == 0) ? ((nbytes) / 3) * 4 \
+			: ((nbytes) / 3) * 4 + ((nbytes) % 3) + 1)
+
+/* w32mem: writes 32-bit word to memory in big-endian order */
+static void w32mem(UCHR *mem, W32 w32)
+{
+	int i;
+
+	for (i = 0; i < 4; i++)
+		*mem++ = (UCHR) (SR32(w32, 24-i*8) & 0xff);
+}
+
+/* digcpy: writes current state to digest buffer */
+static void digcpy(SHA *s)
+{
+	UINT i;
+	UCHR *d = s->digest;
+	W32 *p32 = (W32 *) s->H;
+	W64 *p64 = (W64 *) s->H;
+
+	if (s->alg <= SHA256)
+		for (i = 0; i < 8; i++, d += 4)
+			w32mem(d, *p32++);
+	else
+		for (i = 0; i < 8; i++, d += 8) {
+			w32mem(d, (W32) ((*p64 >> 16) >> 16));
+			w32mem(d+4, (W32) (*p64++ & SHA32_MAX));
+		}
+}
+
+#define SHA_INIT(algo, transform) 					\
+	do {								\
+		memset(s, 0, sizeof(SHA));				\
+		s->alg = algo; s->sha = sha ## transform;		\
+		memcpy(s->H, H0 ## algo, sizeof(H0 ## algo));		\
+		s->blocksize = SHA ## algo ## _BLOCK_BITS;		\
+		s->digestlen = SHA ## algo ## _DIGEST_BITS >> 3;	\
+	} while (0)
+
+/* sharewind: re-initializes the digest object */
+void sharewind(SHA *s)
+{
+	if      (s->alg == SHA1)   SHA_INIT(1, 1);
+	else if (s->alg == SHA224) SHA_INIT(224, 256);
+	else if (s->alg == SHA256) SHA_INIT(256, 256);
+	else if (s->alg == SHA384) SHA_INIT(384, 512);
+	else if (s->alg == SHA512) SHA_INIT(512, 512);
+}
+
+/* shaopen: creates a new digest object */
+SHA *shaopen(int alg)
+{
+	SHA *s;
+
+	if (alg != SHA1 && alg != SHA224 && alg != SHA256 &&
+		alg != SHA384 && alg != SHA512)
+		return(NULL);
+	if (alg >= SHA384 && !sha_384_512)
+		return(NULL);
+	SHA_newz(0, s, 1, SHA);
+	if (s == NULL)
+		return(NULL);
+	s->alg = alg;
+	sharewind(s);
+	return(s);
+}
+
+/* shadirect: updates state directly (w/o going through s->block) */
+static ULNG shadirect(UCHR *bitstr, ULNG bitcnt, SHA *s)
+{
+	ULNG savecnt = bitcnt;
+
+	while (bitcnt >= s->blocksize) {
+		s->sha(s, bitstr);
+		bitstr += (s->blocksize >> 3);
+		bitcnt -= s->blocksize;
+	}
+	if (bitcnt > 0) {
+		memcpy(s->block, bitstr, NBYTES(bitcnt));
+		s->blockcnt = bitcnt;
+	}
+	return(savecnt);
+}
+
+/* shabytes: updates state for byte-aligned input data */
+static ULNG shabytes(UCHR *bitstr, ULNG bitcnt, SHA *s)
+{
+	UINT offset;
+	UINT nbits;
+	ULNG savecnt = bitcnt;
+
+	offset = s->blockcnt >> 3;
+	if (s->blockcnt + bitcnt >= s->blocksize) {
+		nbits = s->blocksize - s->blockcnt;
+		memcpy(s->block+offset, bitstr, nbits>>3);
+		bitcnt -= nbits;
+		bitstr += (nbits >> 3);
+		s->sha(s, s->block), s->blockcnt = 0;
+		shadirect(bitstr, bitcnt, s);
+	}
+	else {
+		memcpy(s->block+offset, bitstr, NBYTES(bitcnt));
+		s->blockcnt += bitcnt;
+	}
+	return(savecnt);
+}
+
+/* shabits: updates state for bit-aligned input data */
+static ULNG shabits(UCHR *bitstr, ULNG bitcnt, SHA *s)
+{
+	UINT i;
+	UINT gap;
+	ULNG nbits;
+	UCHR buf[1<<9];
+	UINT bufsize = sizeof(buf);
+	ULNG bufbits = (ULNG) bufsize << 3;
+	UINT nbytes = NBYTES(bitcnt);
+	ULNG savecnt = bitcnt;
+
+	gap = 8 - s->blockcnt % 8;
+	s->block[s->blockcnt>>3] &= ~0 << gap;
+	s->block[s->blockcnt>>3] |= *bitstr >> (8 - gap);
+	s->blockcnt += bitcnt < gap ? bitcnt : gap;
+	if (bitcnt < gap)
+		return(savecnt);
+	if (s->blockcnt == s->blocksize)
+		s->sha(s, s->block), s->blockcnt = 0;
+	if ((bitcnt -= gap) == 0)
+		return(savecnt);
+	while (nbytes > bufsize) {
+		for (i = 0; i < bufsize; i++)
+			buf[i] = bitstr[i] << gap | bitstr[i+1] >> (8-gap);
+		nbits = bitcnt < bufbits ? bitcnt : bufbits;
+		shabytes(buf, nbits, s);
+		bitcnt -= nbits, bitstr += bufsize, nbytes -= bufsize;
+	}
+	for (i = 0; i < nbytes - 1; i++)
+		buf[i] = bitstr[i] << gap | bitstr[i+1] >> (8-gap);
+	buf[nbytes-1] = bitstr[nbytes-1] << gap;
+	shabytes(buf, bitcnt, s);
+	return(savecnt);
+}
+
+/* shawrite: triggers a state update using data in bitstr/bitcnt */
+ULNG shawrite(UCHR *bitstr, ULNG bitcnt, SHA *s)
+{
+	if (bitcnt < 1)
+		return(0);
+	if (SHA_LO32(s->lenll += bitcnt) < bitcnt)
+		if (SHA_LO32(++s->lenlh) == 0)
+			if (SHA_LO32(++s->lenhl) == 0)
+				s->lenhh++;
+	if (s->blockcnt == 0)
+		return(shadirect(bitstr, bitcnt, s));
+	else if (s->blockcnt % 8 == 0)
+		return(shabytes(bitstr, bitcnt, s));
+	else
+		return(shabits(bitstr, bitcnt, s));
+}
+
+/* shafinish: pads remaining block(s) and computes final digest state */
+void shafinish(SHA *s)
+{
+	UINT lenpos, lhpos, llpos;
+
+	lenpos = s->blocksize == SHA1_BLOCK_BITS ? 448 : 896;
+	lhpos  = s->blocksize == SHA1_BLOCK_BITS ?  56 : 120;
+	llpos  = s->blocksize == SHA1_BLOCK_BITS ?  60 : 124;
+	SETBIT(s->block, s->blockcnt), s->blockcnt++;
+	while (s->blockcnt > lenpos)
+		if (s->blockcnt < s->blocksize)
+			CLRBIT(s->block, s->blockcnt), s->blockcnt++;
+		else
+			s->sha(s, s->block), s->blockcnt = 0;
+	while (s->blockcnt < lenpos)
+		CLRBIT(s->block, s->blockcnt), s->blockcnt++;
+	if (s->blocksize > SHA1_BLOCK_BITS) {
+		w32mem(s->block + 112, s->lenhh);
+		w32mem(s->block + 116, s->lenhl);
+	}
+	w32mem(s->block + lhpos, s->lenlh);
+	w32mem(s->block + llpos, s->lenll);
+	s->sha(s, s->block);
+}
+
+/* shadigest: returns pointer to current digest (binary) */
+UCHR *shadigest(SHA *s)
+{
+	digcpy(s);
+	return(s->digest);
+}
+
+/* shahex: returns pointer to current digest (hexadecimal) */
+char *shahex(SHA *s)
+{
+	int i;
+
+	digcpy(s);
+	s->hex[0] = '\0';
+	if (HEXLEN((size_t) s->digestlen) >= sizeof(s->hex))
+		return(s->hex);
+	for (i = 0; i < s->digestlen; i++)
+		sprintf(s->hex+i*2, "%02x", s->digest[i]);
+	return(s->hex);
+}
+
+/* map: translation map for Base 64 encoding */
+static char map[] =
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/* encbase64: encodes input (0 to 3 bytes) into Base 64 */
+static void encbase64(UCHR *in, int n, char *out)
+{
+	UCHR byte[3] = {0, 0, 0};
+
+	out[0] = '\0';
+	if (n < 1 || n > 3)
+		return;
+	memcpy(byte, in, n);
+	out[0] = map[byte[0] >> 2];
+	out[1] = map[((byte[0] & 0x03) << 4) | (byte[1] >> 4)];
+	out[2] = map[((byte[1] & 0x0f) << 2) | (byte[2] >> 6)];
+	out[3] = map[byte[2] & 0x3f];
+	out[n+1] = '\0';
+}
+
+/* shabase64: returns pointer to current digest (Base 64) */
+char *shabase64(SHA *s)
+{
+	int n;
+	UCHR *q;
+	char out[5];
+
+	digcpy(s);
+	s->base64[0] = '\0';
+	if (B64LEN(s->digestlen) >= sizeof(s->base64))
+		return(s->base64);
+	for (n = s->digestlen, q = s->digest; n > 3; n -= 3, q += 3) {
+		encbase64(q, 3, out);
+		strcat(s->base64, out);
+	}
+	encbase64(q, n, out);
+	strcat(s->base64, out);
+	return(s->base64);
+}
+
+/* shadsize: returns length of digest in bytes */
+int shadsize(SHA *s)
+{
+	return(s->digestlen);
+}
+
+/* shadup: duplicates current digest object */
+SHA *shadup(SHA *s)
+{
+	SHA *p;
+
+	SHA_new(0, p, 1, SHA);
+	if (p == NULL)
+		return(NULL);
+	memcpy(p, s, sizeof(SHA));
+	return(p);
+}
+
+/* shadump: dumps digest object to a human-readable ASCII file */
+int shadump(char *file, SHA *s)
+{
+	int i, j;
+	SHA_FILE *f;
+	UCHR *p = shadigest(s);
+
+	if (file == NULL || strlen(file) == 0)
+		f = SHA_stdout();
+	else if ((f = SHA_open(file, "w")) == NULL)
+		return(0);
+	SHA_fprintf(f, "alg:%d\nH", s->alg);
+	for (i = 0; i < 8; i++)
+		for (j = 0; j < (s->alg <= 256 ? 4 : 8); j++)
+			SHA_fprintf(f, "%s%02x", j==0 ? ":" : "", *p++);
+	SHA_fprintf(f, "\nblock");
+	for (i = 0; i < (int) (s->blocksize >> 3); i++)
+		SHA_fprintf(f, ":%02x", s->block[i]);
+	SHA_fprintf(f, "\nblockcnt:%u\n", s->blockcnt);
+	SHA_fprintf(f, "lenhh:%lu\nlenhl:%lu\nlenlh:%lu\nlenll:%lu\n",
+		(ULNG) LO32(s->lenhh), (ULNG) LO32(s->lenhl),
+		(ULNG) LO32(s->lenlh), (ULNG) LO32(s->lenll));
+	if (f != SHA_stdout())
+		SHA_close(f);
+	return(1);
+}
+
+/* fgetstr: reads (and returns pointer to) next line of file */
+static char *fgetstr(char *line, UINT maxsize, SHA_FILE *f)
+{
+	char *p;
+
+	if (SHA_feof(f) || maxsize == 0)
+		return(NULL);
+	for (p = line; !SHA_feof(f) && maxsize > 1; maxsize--)
+		if ((*p++ = SHA_getc(f)) == '\n')
+			break;
+	*p = '\0';
+	return(line);
+}
+
+/* empty: returns true if line contains only whitespace characters */
+static int empty(char *line)
+{
+	char *p;
+
+	for (p = line; *p; p++)
+		if (!isspace(*p))
+			return(0);
+	return(1);
+}
+
+/* getval: null-terminates field value, and sets pointer to rest of line */
+static char *getval(char *line, char **pprest)
+{
+	char *p, *v;
+
+	for (v = line; *v == ':' || isspace(*v); v++)
+		;
+	for (p = v; *p; p++) {
+		if (*p == ':' || isspace(*p)) {
+			*p++ = '\0';
+			break;
+		}
+	}
+	*pprest = p;
+	return(p == v ? NULL : v);
+}
+
+/* types of values present in dump file */
+#define T_C 1			/* character */
+#define T_I 2			/* normal integer */
+#define T_L 3			/* 32-bit value */
+#define T_Q 4			/* 64-bit value */
+
+/* ldvals: checks next line in dump file against tag, and loads values */
+static int ldvals(
+	SHA_FILE *f,
+	const char *tag,
+	int type,
+	void *pval,
+	int reps,
+	int base)
+{
+	char *p, *pr, line[512];
+	UCHR *pc = (UCHR *) pval; UINT *pi = (UINT *) pval;
+	W32  *pl = (W32  *) pval; W64  *pq = (W64  *) pval;
+
+	while ((p = fgetstr(line, sizeof(line), f)) != NULL)
+		if (line[0] != '#' && !empty(line))
+			break;
+	if (p == NULL || strcmp(getval(line, &pr), tag) != 0)
+		return(0);
+	while (reps-- > 0) {
+		if ((p = getval(pr, &pr)) == NULL)
+			return(1);
+		switch (type) {
+		case T_C: *pc++ = (UCHR) strtoul(p, NULL, base); break;
+		case T_I: *pi++ = (UINT) strtoul(p, NULL, base); break;
+		case T_L: *pl++ = (W32 ) strtoul(p, NULL, base); break;
+		case T_Q: *pq++ = (W64 ) strto64(p            ); break;
+		}
+	}
+	return(1);
+}
+
+/* closeall: closes dump file and de-allocates digest object */
+static SHA *closeall(SHA_FILE *f, SHA *s)
+{
+	if (f != NULL && f != SHA_stdin())
+		SHA_close(f);
+	if (s != NULL)
+		shaclose(s);
+	return(NULL);
+}
+
+/* shaload: creates digest object corresponding to contents of dump file */
+SHA *shaload(char *file)
+{
+	int alg;
+	SHA *s = NULL;
+	SHA_FILE *f;
+
+	if (file == NULL || strlen(file) == 0)
+		f = SHA_stdin();
+	else if ((f = SHA_open(file, "r")) == NULL)
+		return(NULL);
+	if (
+		/* avoid parens by exploiting precedence of (type)&-> */
+		!ldvals(f,"alg",T_I,(VP)&alg,1,10)			||
+		((s = shaopen(alg)) == NULL)				||
+		!ldvals(f,"H",alg<=SHA256?T_L:T_Q,(VP)s->H,8,16)	||
+		!ldvals(f,"block",T_C,(VP)s->block,s->blocksize/8,16)	||
+		!ldvals(f,"blockcnt",T_I,(VP)&s->blockcnt,1,10)		||
+		(alg <= SHA256 && s->blockcnt >= SHA1_BLOCK_BITS)	||
+		(alg >= SHA384 && s->blockcnt >= SHA384_BLOCK_BITS)	||
+		!ldvals(f,"lenhh",T_L,(VP)&s->lenhh,1,10)		||
+		!ldvals(f,"lenhl",T_L,(VP)&s->lenhl,1,10)		||
+		!ldvals(f,"lenlh",T_L,(VP)&s->lenlh,1,10)		||
+		!ldvals(f,"lenll",T_L,(VP)&s->lenll,1,10)
+	)
+		return(closeall(f, s));
+	if (f != SHA_stdin())
+		SHA_close(f);
+	return(s);
+}
+
+/* shaclose: de-allocates digest object */
+int shaclose(SHA *s)
+{
+	if (s != NULL) {
+		memset(s, 0, sizeof(SHA));
+		SHA_free(s);
+	}
+	return(0);
+}
diff --git a/cpan/Digest-SHA/src/sha.h b/cpan/Digest-SHA/src/sha.h
new file mode 100644
index 0000000000..6f18834a67
--- /dev/null
+++ b/cpan/Digest-SHA/src/sha.h
@@ -0,0 +1,233 @@
+/*
+ * sha.h: header file for SHA-1/224/256/384/512 routines
+ *
+ * Ref: NIST FIPS PUB 180-2 Secure Hash Standard
+ *
+ * Copyright (C) 2003-2008 Mark Shelor, All Rights Reserved
+ *
+ * Version: 5.47
+ * Wed Apr 30 04:00:54 MST 2008
+ *
+ */
+
+#ifndef _INCLUDE_SHA_H_
+#define _INCLUDE_SHA_H_
+
+#include <limits.h>
+
+#define SHA32_MAX	4294967295U
+
+#define SHA32_SHR(x, n)	((x) >> (n))
+#define SHA32_SHL(x, n)	((x) << (n))
+
+#define SHA64_SHR(x, n)	((x) >> (n))
+#define SHA64_SHL(x, n)	((x) << (n))
+
+#define SHA32_ALIGNED
+#define SHA64_ALIGNED
+
+#define SHA_LO32(x)	(x)
+
+#if USHRT_MAX == SHA32_MAX
+	#define SHA32	unsigned short
+	#define SHA32_CONST(c)	c ## U
+#elif UINT_MAX == SHA32_MAX
+	#define SHA32	unsigned int
+	#define SHA32_CONST(c)	c ## U
+#elif ULONG_MAX == SHA32_MAX
+	#define SHA32	unsigned long
+	#define SHA32_CONST(c)	c ## UL
+#else
+	#undef  SHA32_ALIGNED
+	#undef  SHA_LO32
+	#define SHA_LO32(x)	((x) & SHA32_MAX)
+	#undef  SHA32_SHR
+	#define SHA32_SHR(x, n)	(SHA_LO32(x) >> (n))
+	#define SHA32	unsigned long
+	#define SHA32_CONST(c)	c ## UL
+#endif
+
+#if defined(ULONG_LONG_MAX) || defined(ULLONG_MAX) || defined(HAS_LONG_LONG)
+	#define SHA_ULL_EXISTS
+#endif
+
+#if (((ULONG_MAX >> 16) >> 16) >> 16) >> 15 == 1UL
+	#define SHA64	unsigned long
+	#define SHA64_CONST(c)	c ## UL
+#elif defined(SHA_ULL_EXISTS) && defined(LONGLONGSIZE) && LONGLONGSIZE == 8
+	#define SHA64	unsigned long long
+	#define SHA64_CONST(c)	c ## ULL
+#elif defined(SHA_ULL_EXISTS)
+	#undef  SHA64_ALIGNED
+	#undef  SHA64_SHR
+	#define SHA64_MAX	18446744073709551615ULL
+	#define SHA64_SHR(x, n)	(((x) & SHA64_MAX) >> (n))
+	#define SHA64	unsigned long long
+	#define SHA64_CONST(c)	c ## ULL
+
+	/* The following cases detect compilers that
+	 * support 64-bit types in a non-standard way */
+
+#elif defined(_MSC_VER)					/* Microsoft C */
+	#define SHA64	unsigned __int64
+	#define SHA64_CONST(c)	(SHA64) c
+#endif
+
+#if defined(SHA64) && !defined(NO_SHA_384_512)
+	#define SHA_384_512
+#endif
+
+#if defined(BYTEORDER) && (BYTEORDER & 0xffff) == 0x4321
+	#if defined(SHA32_ALIGNED)
+		#define SHA32_SCHED(W, b)	memcpy(W, b, 64)
+	#endif
+	#if defined(SHA64) && defined(SHA64_ALIGNED)
+		#define SHA64_SCHED(W, b)	memcpy(W, b, 128)
+	#endif
+#endif
+
+#if !defined(SHA32_SCHED)
+	#define SHA32_SCHED(W, b) { int t; SHA32 *q = W;		\
+		for (t = 0; t < 16; t++, b += 4) *q++ =			\
+			(SHA32) b[0] << 24 | (SHA32) b[1] << 16 |	\
+			(SHA32) b[2] <<  8 | (SHA32) b[3]; }
+#endif
+
+#if defined(SHA64) && !defined(SHA64_SCHED)
+	#define SHA64_SCHED(W, b) { int t; SHA64 *q = W;		\
+		for (t = 0; t < 16; t++, b += 8) *q++ =			\
+			(SHA64) b[0] << 56 | (SHA64) b[1] << 48 |	\
+			(SHA64) b[2] << 40 | (SHA64) b[3] << 32 |	\
+			(SHA64) b[4] << 24 | (SHA64) b[5] << 16 |	\
+			(SHA64) b[6] <<  8 | (SHA64) b[7]; }
+#endif
+
+/*
+ * SHA_STO_CLASS: default to auto storage class for message schedule
+ * arrays inside transform routines.  Note that redefining this to
+ * static might improve performance on some platforms (e.g. Intel).
+ */
+
+#if !defined(SHA_STO_CLASS)
+	#define SHA_STO_CLASS	auto
+#endif
+
+/* Override use of static arrays if compiling for thread-safety */
+#ifdef SHA_THREAD_SAFE
+	#undef  SHA_STO_CLASS
+	#define SHA_STO_CLASS	auto
+#endif
+
+/* Configure memory management and I/O for Perl or standalone C */
+#ifdef SHA_PERL_MODULE
+	#define SHA_new			New
+	#define SHA_newz		Newz
+	#define SHA_free		Safefree
+	#define SHA_FILE		PerlIO
+	#define SHA_stdin()		PerlIO_stdin()
+	#define SHA_stdout()		PerlIO_stdout()
+	#define SHA_open		PerlIO_open
+	#define SHA_close		PerlIO_close
+	#define SHA_fprintf		PerlIO_printf
+	#define SHA_feof		PerlIO_eof
+	#define SHA_getc		PerlIO_getc
+#else
+	#define SHA_new(id, p, n, t)	p = (t *) malloc(sizeof(t))
+	#define SHA_newz(id, p, n, t)	p = (t *) calloc(n, sizeof(t))
+	#define SHA_free		free
+	#define SHA_FILE		FILE
+	#define SHA_stdin()		stdin
+	#define SHA_stdout()		stdout
+	#define SHA_open		fopen
+	#define SHA_close		fclose
+	#define SHA_fprintf		fprintf
+	#define SHA_feof		feof
+	#define SHA_getc		fgetc
+#endif
+
+#define SHA1	1
+#define SHA224	224
+#define SHA256	256
+#define SHA384	384
+#define SHA512	512
+
+#define SHA1_BLOCK_BITS		512
+#define SHA224_BLOCK_BITS	SHA1_BLOCK_BITS
+#define SHA256_BLOCK_BITS	SHA1_BLOCK_BITS
+#define SHA384_BLOCK_BITS	1024
+#define SHA512_BLOCK_BITS	SHA384_BLOCK_BITS
+
+#define SHA1_DIGEST_BITS	160
+#define SHA224_DIGEST_BITS	224
+#define SHA256_DIGEST_BITS	256
+#define SHA384_DIGEST_BITS	384
+#define SHA512_DIGEST_BITS	512
+
+#define SHA_MAX_BLOCK_BITS	SHA512_BLOCK_BITS
+#define SHA_MAX_DIGEST_BITS	SHA512_DIGEST_BITS
+#define SHA_MAX_HEX_LEN		(SHA_MAX_DIGEST_BITS / 4)
+#define SHA_MAX_BASE64_LEN	(1 + (SHA_MAX_DIGEST_BITS / 6))
+
+#if defined(SHA64)
+	#define SHA_H_SIZE	sizeof(SHA64) * 8
+#else
+	#define SHA_H_SIZE	sizeof(SHA32) * 8
+#endif
+
+typedef struct SHA {
+	int alg;
+	void (*sha)(struct SHA *, unsigned char *);
+	unsigned char H[SHA_H_SIZE];
+	unsigned char block[SHA_MAX_BLOCK_BITS/8];
+	unsigned int blockcnt;
+	unsigned int blocksize;
+	SHA32 lenhh, lenhl, lenlh, lenll;
+	unsigned char digest[SHA_MAX_DIGEST_BITS/8];
+	int digestlen;
+	char hex[SHA_MAX_HEX_LEN+1];
+	char base64[SHA_MAX_BASE64_LEN+1];
+} SHA;
+
+#define SHA_FMT_RAW 1
+#define SHA_FMT_HEX 2
+#define SHA_FMT_BASE64 3
+
+#define _SHA_STATE	SHA *s
+#define _SHA_ALG	int alg
+#define _SHA_DATA	unsigned char *bitstr, unsigned long bitcnt
+#define _SHA_FNAME	char *filename
+
+SHA		*shaopen	(_SHA_ALG);
+unsigned long	 shawrite	(_SHA_DATA, _SHA_STATE);
+void		 shafinish	(_SHA_STATE);
+void		 sharewind	(_SHA_STATE);
+unsigned char	*shadigest	(_SHA_STATE);
+char		*shahex		(_SHA_STATE);
+char		*shabase64	(_SHA_STATE);
+int		 shadsize	(_SHA_STATE);
+SHA		*shadup		(_SHA_STATE);
+int		 shadump	(_SHA_FNAME, _SHA_STATE);
+SHA		*shaload	(_SHA_FNAME);
+int		 shaclose	(_SHA_STATE);
+
+#ifndef SHA_PERL_MODULE
+
+unsigned char	*sha1digest	(_SHA_DATA);
+char		*sha1hex	(_SHA_DATA);
+char		*sha1base64	(_SHA_DATA);
+unsigned char	*sha224digest	(_SHA_DATA);
+char		*sha224hex	(_SHA_DATA);
+char		*sha224base64	(_SHA_DATA);
+unsigned char	*sha256digest	(_SHA_DATA);
+char		*sha256hex	(_SHA_DATA);
+char		*sha256base64	(_SHA_DATA);
+unsigned char	*sha384digest	(_SHA_DATA);
+char		*sha384hex	(_SHA_DATA);
+char		*sha384base64	(_SHA_DATA);
+unsigned char	*sha512digest	(_SHA_DATA);
+char		*sha512hex	(_SHA_DATA);
+char		*sha512base64	(_SHA_DATA);
+
+#endif
+
+#endif	/* _INCLUDE_SHA_H_ */
diff --git a/cpan/Digest-SHA/src/sha64bit.c b/cpan/Digest-SHA/src/sha64bit.c
new file mode 100644
index 0000000000..87a8e43dd6
--- /dev/null
+++ b/cpan/Digest-SHA/src/sha64bit.c
@@ -0,0 +1,101 @@
+#ifdef SHA_384_512
+
+#undef sha_384_512
+#undef W64
+#undef strto64
+#undef sha512
+#undef H0384
+#undef H0512
+
+#define sha_384_512	1
+
+#define W64		SHA64		/* useful abbreviations */
+#define C64		SHA64_CONST
+#define SR64		SHA64_SHR
+#define SL64		SHA64_SHL
+
+#define ROTRQ(x, n)	(SR64(x, n) | SL64(x, 64-(n)))
+#define SIGMAQ0(x)	(ROTRQ(x, 28) ^ ROTRQ(x, 34) ^ ROTRQ(x, 39))
+#define SIGMAQ1(x)	(ROTRQ(x, 14) ^ ROTRQ(x, 18) ^ ROTRQ(x, 41))
+#define sigmaQ0(x)	(ROTRQ(x,  1) ^ ROTRQ(x,  8) ^ SR64(x,  7))
+#define sigmaQ1(x)	(ROTRQ(x, 19) ^ ROTRQ(x, 61) ^ SR64(x,  6))
+
+static W64 K512[80] =			/* SHA-384/512 constants */
+{
+C64(0x428a2f98d728ae22), C64(0x7137449123ef65cd), C64(0xb5c0fbcfec4d3b2f),
+C64(0xe9b5dba58189dbbc), C64(0x3956c25bf348b538), C64(0x59f111f1b605d019),
+C64(0x923f82a4af194f9b), C64(0xab1c5ed5da6d8118), C64(0xd807aa98a3030242),
+C64(0x12835b0145706fbe), C64(0x243185be4ee4b28c), C64(0x550c7dc3d5ffb4e2),
+C64(0x72be5d74f27b896f), C64(0x80deb1fe3b1696b1), C64(0x9bdc06a725c71235),
+C64(0xc19bf174cf692694), C64(0xe49b69c19ef14ad2), C64(0xefbe4786384f25e3),
+C64(0x0fc19dc68b8cd5b5), C64(0x240ca1cc77ac9c65), C64(0x2de92c6f592b0275),
+C64(0x4a7484aa6ea6e483), C64(0x5cb0a9dcbd41fbd4), C64(0x76f988da831153b5),
+C64(0x983e5152ee66dfab), C64(0xa831c66d2db43210), C64(0xb00327c898fb213f),
+C64(0xbf597fc7beef0ee4), C64(0xc6e00bf33da88fc2), C64(0xd5a79147930aa725),
+C64(0x06ca6351e003826f), C64(0x142929670a0e6e70), C64(0x27b70a8546d22ffc),
+C64(0x2e1b21385c26c926), C64(0x4d2c6dfc5ac42aed), C64(0x53380d139d95b3df),
+C64(0x650a73548baf63de), C64(0x766a0abb3c77b2a8), C64(0x81c2c92e47edaee6),
+C64(0x92722c851482353b), C64(0xa2bfe8a14cf10364), C64(0xa81a664bbc423001),
+C64(0xc24b8b70d0f89791), C64(0xc76c51a30654be30), C64(0xd192e819d6ef5218),
+C64(0xd69906245565a910), C64(0xf40e35855771202a), C64(0x106aa07032bbd1b8),
+C64(0x19a4c116b8d2d0c8), C64(0x1e376c085141ab53), C64(0x2748774cdf8eeb99),
+C64(0x34b0bcb5e19b48a8), C64(0x391c0cb3c5c95a63), C64(0x4ed8aa4ae3418acb),
+C64(0x5b9cca4f7763e373), C64(0x682e6ff3d6b2b8a3), C64(0x748f82ee5defb2fc),
+C64(0x78a5636f43172f60), C64(0x84c87814a1f0ab72), C64(0x8cc702081a6439ec),
+C64(0x90befffa23631e28), C64(0xa4506cebde82bde9), C64(0xbef9a3f7b2c67915),
+C64(0xc67178f2e372532b), C64(0xca273eceea26619c), C64(0xd186b8c721c0c207),
+C64(0xeada7dd6cde0eb1e), C64(0xf57d4f7fee6ed178), C64(0x06f067aa72176fba),
+C64(0x0a637dc5a2c898a6), C64(0x113f9804bef90dae), C64(0x1b710b35131c471b),
+C64(0x28db77f523047d84), C64(0x32caab7b40c72493), C64(0x3c9ebe0a15c9bebc),
+C64(0x431d67c49c100d4c), C64(0x4cc5d4becb3e42b6), C64(0x597f299cfc657e2a),
+C64(0x5fcb6fab3ad6faec), C64(0x6c44198c4a475817)
+};
+
+static W64 H0384[8] =		/* SHA-384 initial hash value */
+{
+C64(0xcbbb9d5dc1059ed8), C64(0x629a292a367cd507), C64(0x9159015a3070dd17),
+C64(0x152fecd8f70e5939), C64(0x67332667ffc00b31), C64(0x8eb44a8768581511),
+C64(0xdb0c2e0d64f98fa7), C64(0x47b5481dbefa4fa4)
+};
+
+static W64 H0512[8] =		/* SHA-512 initial hash value */
+{
+C64(0x6a09e667f3bcc908), C64(0xbb67ae8584caa73b), C64(0x3c6ef372fe94f82b),
+C64(0xa54ff53a5f1d36f1), C64(0x510e527fade682d1), C64(0x9b05688c2b3e6c1f),
+C64(0x1f83d9abfb41bd6b), C64(0x5be0cd19137e2179)
+};
+
+/* strto64: converts hex string to a 64-bit word */
+static W64 strto64(char *s)
+{
+	char str[2] = {0, 0};
+	W64 u = C64(0);
+
+	while (isxdigit(str[0] = *s++))
+		u = (u << 4) + strtoul(str, NULL, 16);
+	return(u);
+}
+
+static void sha512(SHA *s, unsigned char *block) /* SHA-384/512 transform */
+{
+	W64 a, b, c, d, e, f, g, h, T1, T2;
+	SHA_STO_CLASS W64 W[80];
+	W64 *H = (W64 *) s->H;
+	int t;
+
+	SHA64_SCHED(W, block);
+	for (t = 16; t < 80; t++)
+		W[t] = sigmaQ1(W[t-2]) + W[t-7] + sigmaQ0(W[t-15]) + W[t-16];
+	a = H[0]; b = H[1]; c = H[2]; d = H[3];
+	e = H[4]; f = H[5]; g = H[6]; h = H[7];
+	for (t = 0; t < 80; t++) {
+		T1 = h + SIGMAQ1(e) + Ch(e, f, g) + K512[t] + W[t];
+		T2 = SIGMAQ0(a) + Ma(a, b, c);
+		h = g; g = f; f = e; e = d + T1;
+		d = c; c = b; b = a; a = T1 + T2;
+	}
+	H[0] += a; H[1] += b; H[2] += c; H[3] += d;
+	H[4] += e; H[5] += f; H[6] += g; H[7] += h;
+}
+
+#endif	/* #ifdef SHA_384_512 */
diff --git a/cpan/Digest-SHA/src/sha64bit.h b/cpan/Digest-SHA/src/sha64bit.h
new file mode 100644
index 0000000000..5a02c92ddd
--- /dev/null
+++ b/cpan/Digest-SHA/src/sha64bit.h
@@ -0,0 +1,15 @@
+/*
+ * The following macros supply placeholder values that enable the
+ * `sha.c' module to successfully compile when 64-bit integer types
+ * aren't present.
+ *
+ * They are appropriately redefined in `sha64bit.c` if the compiler
+ * provides a 64-bit type (i.e. when SHA_384_512 is defined).
+ */
+
+#define sha_384_512		0
+#define W64			unsigned long
+#define strto64(p)		0
+#define sha512			NULL
+#define H0384			H01
+#define H0512			H01
diff --git a/cpan/Digest-SHA/src/shaxtra.c b/cpan/Digest-SHA/src/shaxtra.c
new file mode 100644
index 0000000000..7301fc7cc1
--- /dev/null
+++ b/cpan/Digest-SHA/src/shaxtra.c
@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <string.h>
+#include "sha.h"
+
+static unsigned char *shacomp(alg, fmt, bitstr, bitcnt)
+int alg;
+int fmt;
+unsigned char *bitstr;
+unsigned long bitcnt;
+{
+	SHA *s;
+	static unsigned char digest[SHA_MAX_HEX_LEN+1];
+	unsigned char *ret = digest;
+
+	if ((s = shaopen(alg)) == NULL)
+		return(NULL);
+	shawrite(bitstr, bitcnt, s);
+	shafinish(s);
+	if (fmt == SHA_FMT_RAW)
+		memcpy(digest, shadigest(s), s->digestlen);
+	else if (fmt == SHA_FMT_HEX)
+		strcpy((char *) digest, shahex(s));
+	else if (fmt == SHA_FMT_BASE64)
+		strcpy((char *) digest, shabase64(s));
+	else
+		ret = NULL;
+	shaclose(s);
+	return(ret);
+}
+
+#define SHA_DIRECT(type, name, alg, fmt) 			\
+type name(bitstr, bitcnt)					\
+unsigned char *bitstr;						\
+unsigned long bitcnt;						\
+{								\
+	return((type) shacomp(alg, fmt, bitstr, bitcnt));	\
+}
+
+SHA_DIRECT(unsigned char *, sha1digest, SHA1, SHA_FMT_RAW)
+SHA_DIRECT(char *, sha1hex, SHA1, SHA_FMT_HEX)
+SHA_DIRECT(char *, sha1base64, SHA1, SHA_FMT_BASE64)
+
+SHA_DIRECT(unsigned char *, sha224digest, SHA224, SHA_FMT_RAW)
+SHA_DIRECT(char *, sha224hex, SHA224, SHA_FMT_HEX)
+SHA_DIRECT(char *, sha224base64, SHA224, SHA_FMT_BASE64)
+
+SHA_DIRECT(unsigned char *, sha256digest, SHA256, SHA_FMT_RAW)
+SHA_DIRECT(char *, sha256hex, SHA256, SHA_FMT_HEX)
+SHA_DIRECT(char *, sha256base64, SHA256, SHA_FMT_BASE64)
+
+SHA_DIRECT(unsigned char *, sha384digest, SHA384, SHA_FMT_RAW)
+SHA_DIRECT(char *, sha384hex, SHA384, SHA_FMT_HEX)
+SHA_DIRECT(char *, sha384base64, SHA384, SHA_FMT_BASE64)
+
+SHA_DIRECT(unsigned char *, sha512digest, SHA512, SHA_FMT_RAW)
+SHA_DIRECT(char *, sha512hex, SHA512, SHA_FMT_HEX)
+SHA_DIRECT(char *, sha512base64, SHA512, SHA_FMT_BASE64)
diff --git a/cpan/Digest-SHA/t/allfcns.t b/cpan/Digest-SHA/t/allfcns.t
new file mode 100644
index 0000000000..34cc803412
--- /dev/null
+++ b/cpan/Digest-SHA/t/allfcns.t
@@ -0,0 +1,30 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(
+		hmac_sha1	hmac_sha1_base64	hmac_sha1_hex
+		hmac_sha224	hmac_sha224_base64	hmac_sha224_hex
+		hmac_sha256	hmac_sha256_base64	hmac_sha256_hex
+		hmac_sha384	hmac_sha384_base64	hmac_sha384_hex
+		hmac_sha512	hmac_sha512_base64	hmac_sha512_hex
+		sha1		sha1_base64		sha1_hex
+		sha224		sha224_base64		sha224_hex
+		sha256		sha256_base64		sha256_hex
+		sha384		sha384_base64		sha384_hex
+		sha512		sha512_base64		sha512_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+print "1..1\n";
+
+print "ok 1\n";
diff --git a/cpan/Digest-SHA/t/base64.t b/cpan/Digest-SHA/t/base64.t
new file mode 100644
index 0000000000..1675e9a04c
--- /dev/null
+++ b/cpan/Digest-SHA/t/base64.t
@@ -0,0 +1,43 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(sha1_base64 sha224_base64 sha256_base64
+		sha384_base64 sha512_base64));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my $in = "abc";
+my @out = map { eval } <DATA>;
+my @fcn = (\&sha1_base64, \&sha224_base64, \&sha256_base64,
+	\&sha384_base64, \&sha512_base64);
+
+print "1..", scalar @out, "\n";
+
+my $testnum = 1;
+while (@out) {
+	my $fcn = shift @fcn;
+	my $rsp = shift @out;
+	my $skip = &$fcn("") ? 0 : 1;
+	unless ($skip) {
+		print "not " unless &$fcn($in) eq $rsp;
+	}
+	print "ok ", $testnum++, $skip ? " # skip: no 64 bit" : "", "\n";
+}
+
+__DATA__
+"qZk+NkcGgWq6PiVxeFDCbJzQ2J0"
+"Iwl9IjQF2CKGQqR3vaJVsyqtvOS9oLP342ydpw"
+"ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0"
+"ywB1P0WjXou1oD1pmsZQBycsMqsO3tFjGotgWkP/W+2AhgcroefMI1i67KE0yCWn"
+"3a81oZNherrMQXNJriBBMRLm+k6JqX6iCp7u5ktV05ohkpkqJ0/BqDa6PCOj/uu9RU1EI2Q86A4qmslPpUyknw"
+
diff --git a/cpan/Digest-SHA/t/bitbuf.t b/cpan/Digest-SHA/t/bitbuf.t
new file mode 100644
index 0000000000..81597356f0
--- /dev/null
+++ b/cpan/Digest-SHA/t/bitbuf.t
@@ -0,0 +1,73 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw());
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my $numtests = 4;
+print "1..$numtests\n";
+
+	# Here's the bitstring to test against, and its SHA-1 digest
+
+my $ONEBITS = pack("B*", "1" x 80000);
+my $digest = "11003389959355c2773af6b0f36d842fe430ec49";
+
+my $state = $MODULE->new("sHa1");
+my $testnum = 1;
+
+$state->add_bits($ONEBITS, 80000);
+print "not " unless $state->hexdigest eq $digest;
+print "ok ", $testnum++, "\n";
+
+	# buffer using a series of increasingly large bitstrings
+
+# Note that (1 + 2 + ... + 399) + 200 = 80000
+
+for (1 .. 399) {
+	$state->add_bits($ONEBITS, $_);
+}
+$state->add_bits($ONEBITS, 200);
+
+print "not " unless $state->hexdigest eq $digest;
+print "ok ", $testnum++, "\n";
+
+	# create a buffer-alignment nuisance
+
+$state = $MODULE->new("1");
+
+$state->add_bits($ONEBITS, 1);
+for (1 .. 99) {
+	$state->add_bits($ONEBITS, 800);
+}
+$state->add_bits($ONEBITS, 799);
+
+print "not " unless $state->hexdigest eq $digest;
+print "ok ", $testnum++, "\n";
+
+	# buffer randomly-sized bitstrings
+
+my $reps = 80000;
+my $maxbits = 8 * 127;
+
+$state = $MODULE->new(1);
+
+while ($reps > $maxbits) {
+	my $num = int(rand($maxbits));
+	$state->add_bits($ONEBITS, $num);
+	$reps -= $num;
+}
+$state->add_bits($ONEBITS, $reps);
+
+print "not " unless $state->hexdigest eq $digest;
+print "ok ", $testnum++, "\n";
diff --git a/cpan/Digest-SHA/t/dumpload.t b/cpan/Digest-SHA/t/dumpload.t
new file mode 100644
index 0000000000..92b92867e3
--- /dev/null
+++ b/cpan/Digest-SHA/t/dumpload.t
@@ -0,0 +1,102 @@
+use strict;
+use FileHandle;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(sha384_hex sha512_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @sharsp = (
+	"34aa973cd4c4daa4f61eeb2bdbad27316534016f",
+	"cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0",
+	"9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b07b8b3dc38ecc4ebae97ddd87f3d8985",
+	"e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b"
+);
+
+my $numtests = scalar @sharsp;
+print "1..$numtests\n";
+
+my @tempfiles;
+END { 1 while unlink @tempfiles }
+
+my @statefiles = ("dl001.tmp", "dl256.tmp", "dl384.tmp", "dl512.tmp");
+for (@statefiles) {
+	push @tempfiles, $_;
+	my $fh = FileHandle->new($_, "w");
+	for (1 .. 8) { my $line = <DATA>; print $fh $line }
+	$fh->close;
+}
+my $tmpfile = "dumpload.tmp";
+push @tempfiles, $tmpfile;
+
+my @alg = (1, 256, 384, 512);
+my $data = "a" x 990000;
+
+my $testnum = 1;
+while (@sharsp) {
+	my $skip = 0;
+	my $alg = shift @alg;
+	my $rsp = shift @sharsp;
+	my $file = shift @statefiles; push(@statefiles, $file);
+	if ($alg == 384) { $skip = sha384_hex("") ? 0 : 1 }
+	if ($alg == 512) { $skip = sha512_hex("") ? 0 : 1 }
+	if ($skip) {
+		print "ok ", $testnum++, " # skip: no 64 bit\n";
+		next;
+	}
+	my $digest;
+	my $state;
+	unless ($state = $MODULE->load($file)) {
+		print "not ok ", $testnum++, "\n";
+		next;
+	}
+	$state->add_bits($data, 79984)->dump($tmpfile);
+	$state->load($tmpfile)->add_bits($data, 16);
+	$digest = $state->hexdigest;
+	print "not " unless $digest eq $rsp;
+	print "ok ", $testnum++, "\n";
+}
+
+__DATA__
+alg:1
+H:9d6f7d2f:65e21307:c6f41af6:7c7fd3a9:8dec6058:00000000:00000000:00000000
+block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
+blockcnt:384
+lenhh:0
+lenhl:0
+lenlh:0
+lenll:7920000
+alg:256
+H:2d6c0def:4244ade7:fc8c121c:108f4493:ec3fbec2:91425a6e:b8d30d2a:9db24273
+block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
+blockcnt:384
+lenhh:0
+lenhl:0
+lenlh:0
+lenll:7920000
+alg:384
+H:598147f4583a61f7:8d194a4d7c9008cb:39725c96557d600f:d7f2079ce8251f19:bd735d446f9a3c7c:234de90b9060898d:a5b481b9d635d190:81c6e74ee4556125
+block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
+blockcnt:384
+lenhh:0
+lenhl:0
+lenlh:0
+lenll:7920000
+alg:512
+H:0442fe29a02b8c30:13553e6dbedc2aa0:8f891a0cb2ac3107:6fa1762b40ac04dd:dcbf420d729eea79:34703e9672dcf145:7bf9aaa14d400433:2aa65f044825466d
+block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
+blockcnt:384
+lenhh:0
+lenhl:0
+lenlh:0
+lenll:7920000
diff --git a/cpan/Digest-SHA/t/fips198.t b/cpan/Digest-SHA/t/fips198.t
new file mode 100644
index 0000000000..0447aa6489
--- /dev/null
+++ b/cpan/Digest-SHA/t/fips198.t
@@ -0,0 +1,42 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(hmac_sha1_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @data = map { "Sample #$_" } (1 .. 4);
+
+my @out = (
+	"4f4ca3d5d68ba7cc0a1208c9c61e9c5da0403c0a",
+	"0922d3405faa3d194f82a45830737d5cc6c75d24",
+	"bcf41eab8bb2d802f3d05caf7cb092ecf8d1a3aa",
+	"9ea886efe268dbecce420c7524df32e0751a2a26"
+);
+
+my @keys = ("", "", "", "");
+
+for (0x00 .. 0x00+63) { $keys[0] .= chr($_) }
+for (0x30 .. 0x30+19) { $keys[1] .= chr($_) }
+for (0x50 .. 0x50+99) { $keys[2] .= chr($_) }
+for (0x70 .. 0x70+48) { $keys[3] .= chr($_) }
+
+my $numtests = scalar @data;
+print "1..$numtests\n";
+
+my $testnum = 1;
+while (@data) {
+	print "not " unless hmac_sha1_hex(shift @data, shift @keys)
+		eq shift @out;
+	print "ok ", $testnum++, "\n";
+}
diff --git a/cpan/Digest-SHA/t/gg.t b/cpan/Digest-SHA/t/gg.t
new file mode 100644
index 0000000000..b43ec48bdf
--- /dev/null
+++ b/cpan/Digest-SHA/t/gg.t
@@ -0,0 +1,72 @@
+# Test against short bitwise vectors from Jim Gillogly and Francois Grieu
+#
+# http://www.chiark.greenend.org.uk/pipermail/ukcrypto/1999-February/003538.html
+
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw());
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+#	SHA-1 Test Vectors
+#
+#	In the following we use the notation bitstring#n to mean a bitstring
+#	repeated n (in decimal) times, and we use | for concatenation.
+#	Therefore 110#3|1 is 1101101101.
+#
+#	110#148|11  : CE7387AE 577337BE 54EA94F8 2C842E8B E76BC3E1
+#	110#149     : DE244F06 3142CB2F 4C903B7F 7660577F 9E0D8791
+#	110#149|1   : A3D29824 27AE39C8 920CA5F4 99D6C2BD 71EBF03C
+#	110#149|11  : 351AAB58 FF93CF12 AF7D5A58 4CFC8F7D 81023D10
+#
+#	110#170     : 99638692 1E480D4E 2955E727 5DF3522C E8F5AB6E
+#	110#170|1   : BB5F4AD4 8913F51B 157EB985 A5C2034B 8243B01B
+#	110#170|11  : 9E92C554 2237B957 BA2244E8 141FDB66 DEC730A5
+#	110#171     : 2103E454 DA4491F4 E32DD425 A3341DC9 C2A90848
+#
+#	011#490     : B4B18049 DE405027 528CD9E7 4B2EC540 D4E6F06B
+#	011#490|0   : 34C63356 B3087427 20AB9669 14EB0FC9 26E4294B
+#	011#490|01  : 75FACE18 02B9F84F 326368AB 06E73E05 02E9EA34
+#	011#491     : 7C2C3D62 F6AEC28D 94CDF93F 02E739E7 490698A1
+
+my @vecs = (
+	"110",148,"11","ce7387ae577337be54ea94f82c842e8be76bc3e1",
+	"110",149,"","de244f063142cb2f4c903b7f7660577f9e0d8791",
+	"110",149,"1","a3d2982427ae39c8920ca5f499d6c2bd71ebf03c",
+	"110",149,"11","351aab58ff93cf12af7d5a584cfc8f7d81023d10",
+	"110",170,"","996386921e480d4e2955e7275df3522ce8f5ab6e",
+	"110",170,"1","bb5f4ad48913f51b157eb985a5c2034b8243b01b",
+	"110",170,"11","9e92c5542237b957ba2244e8141fdb66dec730a5",
+	"110",171,"","2103e454da4491f4e32dd425a3341dc9c2a90848",
+	"011",490,"","b4b18049de405027528cd9e74b2ec540d4e6f06b",
+	"011",490,"0","34c63356b308742720ab966914eb0fc926e4294b",
+	"011",490,"01","75face1802b9f84f326368ab06e73e0502e9ea34",
+	"011",491,"","7c2c3d62f6aec28d94cdf93f02e739e7490698a1",
+);
+
+my $numtests = scalar(@vecs) / 4;
+print "1..$numtests\n";
+
+my $testnum = 1;
+my $sha = $MODULE->new(1);
+
+while (@vecs) {
+	my $frag = shift @vecs;
+	my $reps = shift @vecs;
+	my $tail = shift @vecs;
+	my $bitstr = ($frag x $reps) . $tail;
+	print "not " unless $sha->add_bits($bitstr)->hexdigest
+		eq shift @vecs;
+	print "ok ", $testnum++, "\n";
+}
diff --git a/cpan/Digest-SHA/t/gglong.t b/cpan/Digest-SHA/t/gglong.t
new file mode 100644
index 0000000000..4d8c53d77c
--- /dev/null
+++ b/cpan/Digest-SHA/t/gglong.t
@@ -0,0 +1,150 @@
+# Test against long bitwise vectors from Jim Gillogly and Francois Grieu
+#
+# http://www.chiark.greenend.org.uk/pipermail/ukcrypto/1999-February/003538.html
+
+use strict;
+use FileHandle;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw());
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+#	SHA-1 Test Vectors
+#
+#	In the following we use the notation bitstring#n to mean a bitstring
+#	repeated n (in decimal) times, and we use | for concatenation.
+#	Therefore 110#3|1 is 1101101101.
+#
+#	Here is a set near 2^32 bits to test the roll-over in the length
+#	field from one to two 32-bit words:
+#
+#	110#1431655764|11 1eef5a18 969255a3 b1793a2a 955c7ec2 8cd221a5
+#	110#1431655765|   7a1045b9 14672afa ce8d90e6 d19b3a6a da3cb879
+#	110#1431655765|1  d5e09777 a94f1ea9 240874c4 8d9fecb6 b634256b
+#	110#1431655765|11 eb256904 3c3014e5 1b2862ae 6eb5fb4e 0b851d99
+#
+#	011#1431655764|01 4CB0C4EF 69143D5B F34FC35F 1D4B19F6 ECCAE0F2
+#	011#1431655765    47D92F91 1FC7BB74 DE00ADFC 4E981A81 05556D52
+#	011#1431655765|0  A3D7438C 589B0B93 2AA91CC2 446F06DF 9ABC73F0
+#	011#1431655765|01 3EEE3E1E 28DEDE2C A444D68D A5675B2F AAAB3203
+
+my @vec110 = (	# 110 rep 1431655764
+	"11", "1eef5a18969255a3b1793a2a955c7ec28cd221a5",
+	"110", "7a1045b914672aface8d90e6d19b3a6ada3cb879",
+	"1101", "d5e09777a94f1ea9240874c48d9fecb6b634256b",
+	"11011", "eb2569043c3014e51b2862ae6eb5fb4e0b851d99"
+);
+
+my @vec011 = (	# 011 rep 1431655764
+	"01", "4cb0c4ef69143d5bf34fc35f1d4b19f6eccae0f2",
+	"011", "47d92f911fc7bb74de00adfc4e981a8105556d52",
+	"0110", "a3d7438c589b0b932aa91cc2446f06df9abc73f0",
+	"01101", "3eee3e1e28dede2ca444d68da5675b2faaab3203"
+);
+print "1..", scalar(@vec110) / 2 + scalar(@vec011) / 2, "\n";
+
+my $STATE110 = "gglong0.tmp";
+my $STATE011 = "gglong1.tmp";
+
+END { 1 while unlink $STATE110, $STATE011 }
+
+for ($STATE011, $STATE110) {
+	my $fh = FileHandle->new($_, "w");
+	for (1 .. 8) { my $line = <DATA>; print $fh $line }
+	$fh->close;
+}
+
+my $reps = 1 << 14;
+my $loops = int(1431655764 / $reps);
+my $rest = 3 * (1431655764 - $loops * $reps);
+
+sub state110 {
+	my $i;
+	my $state;
+	my $bitstr;
+
+	$state = $MODULE->new(1);
+	if (-r $STATE110) {
+		if ($state->load($STATE110)) {
+			return($state);
+		}
+	}
+	$bitstr = pack("B*", "110" x $reps);
+	$state->reset;
+	for ($i = 0; $i < $loops; $i++) {
+		$state->add_bits($bitstr, 3 * $reps);
+	}
+	$state->add_bits($bitstr, $rest);
+	$state->dump($STATE110);
+	return($state);
+}
+
+sub state011 {
+	my $i;
+	my $state;
+	my $bitstr;
+
+	$state = $MODULE->new(1);
+	if (-r $STATE011) {
+		if ($state->load($STATE011)) {
+			return($state);
+		}
+	}
+	$bitstr = pack("B*", "011" x $reps);
+	$state->reset;
+	for ($i = 0; $i < $loops; $i++) {
+		$state->add_bits($bitstr, 3 * $reps);
+	}
+	$state->add_bits($bitstr, $rest);
+	$state->dump($STATE011);
+	return($state);
+}
+
+my $i;
+
+my $testnum = 1;
+
+my $state110 = state110();
+for ($i = 0; $i < @vec110/2; $i++) {
+	my $state = $state110->clone;
+	$state->add_bits($vec110[2*$i]);
+	print "not " unless $state->hexdigest eq $vec110[2*$i+1];
+	print "ok ", $testnum++, "\n";
+}
+
+my $state011 = state011();
+for ($i = 0; $i < @vec011/2; $i++) {
+	my $state = $state011->clone;
+	$state->add_bits($vec011[2*$i]);
+	print "not " unless $state->hexdigest eq $vec011[2*$i+1];
+	print "ok ", $testnum++, "\n";
+}
+
+__DATA__
+alg:1
+H:7950cbe2:86a45aa0:91ff7dff:29015b42:3912e764:00000000:00000000:00000000
+block:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6
+blockcnt:508
+lenhh:0
+lenhl:0
+lenlh:0
+lenll:4294967292
+alg:1
+H:dfc51a14:87b4a4b7:ecf19acd:8cbbe40e:03a435f8:00000000:00000000:00000000
+block:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d
+blockcnt:508
+lenhh:0
+lenhl:0
+lenlh:0
+lenll:4294967292
diff --git a/cpan/Digest-SHA/t/hmacsha.t b/cpan/Digest-SHA/t/hmacsha.t
new file mode 100644
index 0000000000..a265a767d0
--- /dev/null
+++ b/cpan/Digest-SHA/t/hmacsha.t
@@ -0,0 +1,77 @@
+# HMAC-SHA-256 test vectors from draft-ietf-ipsec-ciph-sha-256-01.txt
+
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(hmac_sha256_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @data = map { eval } <DATA>;
+
+my $numtests = scalar @data;
+print "1..$numtests\n";
+
+my $k1 = join( "", map { chr } (1 .. 32) );
+my $k2 = join( "", map { chr } (1 .. 37) );
+
+my @keys = (
+	$k1,
+	$k1,
+	$k1,
+	chr(0x0b) x 32,
+	"Jefe",
+	chr(0xaa) x 32,
+	$k2,
+	chr(0x0c) x 32,
+	chr(0xaa) x 80,
+	chr(0xaa) x 80
+);
+
+my @out = (
+	"a21b1f5d4cf4f73a4dd939750f7a066a7f98cc131cb16a6692759021cfab8181",
+	"104fdc1257328f08184ba73131c53caee698e36119421149ea8c712456697d30",
+	"470305fc7e40fe34d3eeb3e773d95aab73acf0fd060447a5eb4595bf33a9d1a3",
+	"198a607eb44bfbc69903a0f1cf2bbdc5ba0aa3f3d9ae3c1c7a3b1696a0b68cf7",
+	"5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
+	"cdcb1220d1ecccea91e53aba3092f962e549fe6ce9ed7fdc43191fbde45c30b0",
+	"d4633c17f6fb8d744c66dee0f8f074556ec4af55ef07998541468eb49bd2e917",
+	"7546af01841fc09b1ab9c3749a5f1c17d4f589668a587b2700a9c97c1193cf42",
+	"6953025ed96f0c09f80a96f78e6538dbe2e7b820e3dd970e7ddd39091b32352f",
+	"6355ac22e890d0a3c8481a5ca4825bc884d3e7a1ff98a2fc2ac7d8e064c3b2e6"
+);
+
+	# do the first one using multi-argument data feed
+
+my $testnum = 1;
+my @args = split(//, shift @data);
+print "not " unless hmac_sha256_hex(@args, shift @keys) eq shift @out;
+print "ok ", $testnum++, "\n";
+
+while (@data) {
+	print "not " unless hmac_sha256_hex(shift @data, shift @keys)
+		eq shift @out;
+	print "ok ", $testnum++, "\n";
+}
+
+__DATA__
+"abc"
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+"Hi There"
+"what do ya want for nothing?"
+chr(0xdd) x 50
+chr(0xcd) x 50
+"Test With Truncation"
+"Test Using Larger Than Block-Size Key - Hash Key First"
+"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
diff --git a/cpan/Digest-SHA/t/ireland.t b/cpan/Digest-SHA/t/ireland.t
new file mode 100644
index 0000000000..97bad44243
--- /dev/null
+++ b/cpan/Digest-SHA/t/ireland.t
@@ -0,0 +1,50 @@
+use strict;
+use FileHandle;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw());
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+# David Ireland's test vector - SHA-256 digest of "a" x 536870912
+
+# Adapted from Julius Duque's original script (t/24-ireland.tmp)
+#	- modified to use state cache via dump()/load() methods
+
+print "1..1\n";
+
+my $tempfile = "ireland.tmp";
+END { 1 while unlink $tempfile }
+
+my $fh = FileHandle->new($tempfile, "w");
+while (<DATA>) { print $fh $_ }  close($fh);
+
+my $rsp = "b9045a713caed5dff3d3b783e98d1ce5778d8bc331ee4119d707072312af06a7";
+
+my $sha;
+if ($sha = $MODULE->load($tempfile)) {
+	$sha->add("aa");
+	print "not " unless $sha->hexdigest eq $rsp;
+	print "ok 1\n";
+}
+else { print "not ok 1\n" }
+
+__DATA__
+alg:256
+H:dd75eb45:02d4f043:06b41193:6fda751d:73064db9:787d54e1:52dc3fe0:48687dfa
+block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
+blockcnt:496
+lenhh:0
+lenhl:0
+lenlh:0
+lenll:4294967280
diff --git a/cpan/Digest-SHA/t/methods.t b/cpan/Digest-SHA/t/methods.t
new file mode 100644
index 0000000000..2a4a7c4a56
--- /dev/null
+++ b/cpan/Digest-SHA/t/methods.t
@@ -0,0 +1,102 @@
+use strict;
+use FileHandle;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw());
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @out = (
+	"ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0",
+	"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
+);
+
+my $numtests = 6 + scalar @out;
+print "1..$numtests\n";
+
+	# attempt to use an invalid algorithm, and check for failure
+
+my $testnum = 1;
+my $NSA = "SHA-42";	# No Such Algorithm
+print "not " if $MODULE->new($NSA);
+print "ok ", $testnum++, "\n";
+
+my $tempfile = "methods.tmp";
+END { 1 while unlink $tempfile }
+
+	# test OO methods using first two SHA-256 vectors from NIST
+
+my $fh = FileHandle->new($tempfile, "w");
+binmode($fh);
+print $fh "bcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
+$fh->close;
+
+my $sha = $MODULE->new()->reset("SHA-256")->new();
+$sha->add_bits("a", 5)->add_bits("001");
+
+my $rsp = shift(@out);
+print "not " unless $sha->clone->add("b", "c")->b64digest eq $rsp;
+print "ok ", $testnum++, "\n";
+
+$rsp = shift(@out);
+
+	# test addfile with bareword filehandle
+
+open(FILE, "<$tempfile");
+binmode(FILE);
+print "not " unless
+	$sha->clone->addfile(*FILE)->hexdigest eq $rsp;
+print "ok ", $testnum++, "\n";
+close(FILE);
+
+	# test addfile with indirect filehandle
+
+$fh = FileHandle->new($tempfile, "r");
+binmode($fh);
+print "not " unless $sha->clone->addfile($fh)->hexdigest eq $rsp;
+print "ok ", $testnum++, "\n";
+$fh->close;
+
+	# test addfile using file name instead of handle
+
+print "not " unless $sha->addfile($tempfile, "b")->hexdigest eq $rsp;
+print "ok ", $testnum++, "\n";
+
+	# test addfile portable mode
+
+$fh = FileHandle->new($tempfile, "w");
+binmode($fh);
+print $fh "abc\012" x 2048;		# using UNIX newline
+$fh->close;
+
+print "not " unless $sha->new(1)->addfile($tempfile, "p")->hexdigest eq
+	"d449e19c1b0b0c191294c8dc9fa2e4a6ff77fc51";
+print "ok ", $testnum++, "\n";
+
+$fh = FileHandle->new($tempfile, "w");
+binmode($fh);
+print $fh "abc\015\012" x 2048;		# using DOS/Windows newline
+$fh->close;
+
+print "not " unless $sha->new(1)->addfile($tempfile, "p")->hexdigest eq
+	"d449e19c1b0b0c191294c8dc9fa2e4a6ff77fc51";
+print "ok ", $testnum++, "\n";
+
+$fh = FileHandle->new($tempfile, "w");
+binmode($fh);
+print $fh "abc\015" x 2048;		# using early-Mac newline
+$fh->close;
+
+print "not " unless $sha->new(1)->addfile($tempfile, "p")->hexdigest eq
+	"d449e19c1b0b0c191294c8dc9fa2e4a6ff77fc51";
+print "ok ", $testnum++, "\n";
diff --git a/cpan/Digest-SHA/t/nistbit.t b/cpan/Digest-SHA/t/nistbit.t
new file mode 100644
index 0000000000..8516195989
--- /dev/null
+++ b/cpan/Digest-SHA/t/nistbit.t
@@ -0,0 +1,72 @@
+# Test against SHA-1 Sample Vectors from NIST
+#
+#	ref: http://csrc.nist.gov/cryptval/shs.html
+
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw());
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my $nist_hashes = <<END_OF_NIST_HASHES;
+DA39A3EE5E6B4B0D3255BFEF95601890AFD80709 ^
+59C4526AA2CC59F9A5F56B5579BA7108E7CCB61A ^
+6E42FB84067CFF056C43A49E484997AF23190879 ^
+C63FBB9A87171A176E6E054890E29A8C5F125F6C ^
+3109E33C1C4B9A0169D1599169D0E5A520A1E71C ^
+9195E1E73CC68D7170F44BD1D83CB624BC87FA0B ^
+64F7C374527278C0436DBC8DE5AABEC2BBF634BC ^
+154B622EA426FB151B1FF1BE1CE871752B9EDEB4 ^
+12BDD00FD4038756CBCF8ECDAD1B0CD862603CD8 ^
+6700F93E1691E83735279E167F67AF61FEE9813B ^
+END_OF_NIST_HASHES
+
+my @hashes = $nist_hashes =~ /\b[0-9A-F]{40}\b/g;
+
+my $nist_messages = <<END_OF_NIST_MESSAGES;
+0 1 ^
+1 1 1 ^
+2 1 1 1 ^
+3 0 1 1 1 ^
+2 0 2 2 ^
+4 1 1 1 2 1 ^
+3 0 2 2 2 ^
+4 1 1 2 2 2 ^
+5 1 2 2 1 1 2 ^
+5 0 2 2 1 1 3 ^
+END_OF_NIST_MESSAGES
+
+my @lines = split(/\n/, $nist_messages);
+
+print "1..", scalar(@hashes), "\n";
+my $testnum = 1;
+
+my $message = "";
+my $sha = $MODULE->new(1);
+for (@lines) {
+	next unless /^[\d ^]/;
+	$message .= $_;
+	next unless /\^\s*$/;
+	my @vals = $message =~ /\d+/g; $message = "";
+	my $count = shift(@vals);
+	my $bit = shift(@vals);
+	my $bitstr = "";
+	while (@vals) {
+		$bitstr .= $bit x shift(@vals);
+		$bit = 1 - $bit;
+	}
+	print "not " unless uc($sha->add_bits($bitstr)->hexdigest)
+		eq shift(@hashes);
+	print "ok ", $testnum++, "\n";
+}
diff --git a/cpan/Digest-SHA/t/nistbyte.t b/cpan/Digest-SHA/t/nistbyte.t
new file mode 100644
index 0000000000..9c4a89d136
--- /dev/null
+++ b/cpan/Digest-SHA/t/nistbyte.t
@@ -0,0 +1,73 @@
+# Test against SHA-1 Sample Vectors from NIST
+#
+#	ref: http://csrc.nist.gov/cryptval/shs.html
+
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw());
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my $nist_hashes = <<END_OF_NIST_HASHES;
+DA39A3EE5E6B4B0D3255BFEF95601890AFD80709 ^
+3CDF2936DA2FC556BFA533AB1EB59CE710AC80E5 ^
+19C1E2048FA7393CFBF2D310AD8209EC11D996E5 ^
+CA775D8C80FAA6F87FA62BECA6CA6089D63B56E5 ^
+71AC973D0E4B50AE9E5043FF4D615381120A25A0 ^
+A6B5B9F854CFB76701C3BDDBF374B3094EA49CBA ^
+D87A0EE74E4B9AD72E6847C87BDEEB3D07844380 ^
+1976B8DD509FE66BF09C9A8D33534D4EF4F63BFD ^
+5A78F439B6DB845BB8A558E4CEB106CD7B7FF783 ^
+F871BCE62436C1E280357416695EE2EF9B83695C ^
+END_OF_NIST_HASHES
+
+my @hashes = $nist_hashes =~ /\b[0-9A-F]{40}\b/g;
+
+my $nist_messages = <<END_OF_NIST_MESSAGES;
+0 1 ^
+5 0 2 1 2 1 2 ^
+5 0 1 3 4 4 4 ^
+7 0 4 3 4 4 1 4 4 ^
+10 0 4 1 5 3 4 4 3 1 3 4 ^
+10 0 3 1 6 5 5 1 3 6 6 4 ^
+13 1 3 2 5 3 3 3 4 6 6 1 4 6 2 ^
+16 1 3 5 5 1 2 1 3 3 6 3 5 2 3 5 7 2 ^
+15 1 8 1 5 3 2 7 4 5 6 7 3 3 1 6 3 ^
+15 1 4 6 8 2 1 4 2 5 1 6 8 8 6 4 7 ^
+END_OF_NIST_MESSAGES
+
+my @lines = split(/\n/, $nist_messages);
+
+print "1..", scalar(@hashes), "\n";
+my $testnum = 1;
+
+my $message = "";
+my $sha = $MODULE->new(1);
+for (@lines) {
+	next unless /^[\d ^]/;
+	$message .= $_;
+	next unless /\^\s*$/;
+	my @vals = $message =~ /\d+/g; $message = "";
+	my $count = shift(@vals);
+	my $bit = shift(@vals);
+	my $bitstr = "";
+	while (@vals) {
+		$bitstr .= $bit x shift(@vals);
+		$bit = 1 - $bit;
+	}
+	print "not " unless
+		uc($sha->add(pack("B*", $bitstr))->hexdigest)
+			eq shift(@hashes);
+	print "ok ", $testnum++, "\n";
+}
diff --git a/cpan/Digest-SHA/t/rfc2202.t b/cpan/Digest-SHA/t/rfc2202.t
new file mode 100644
index 0000000000..8e21bbdff8
--- /dev/null
+++ b/cpan/Digest-SHA/t/rfc2202.t
@@ -0,0 +1,57 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(hmac_sha1_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @data = map { eval } <DATA>;
+
+my $numtests = scalar @data;
+print "1..$numtests\n";
+
+my @keys = (
+	chr(0x0b) x 20,
+	"Jefe",
+	chr(0xaa) x 20,
+	join("", map { chr } (1 .. 25)),
+	chr(0x0c) x 20,
+	chr(0xaa) x 80,
+	chr(0xaa) x 80
+);
+
+my @out = (
+	"b617318655057264e28bc0b6fb378c8ef146be00",
+	"effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+	"125d7342b9ac11cd91a39af48aa17b4f63f175d3",
+	"4c9007f4026250c6bc8414f9bf50c86c2d7235da",
+	"4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+	"aa4ae5e15272d00e95705637ce8a3b55ed402112",
+	"e8e99d0f45237d786d6bbaa7965c7808bbff1a91"
+);
+
+my $testnum = 1;
+while (@data) {
+	print "not " unless hmac_sha1_hex(shift @data, shift @keys)
+		eq shift @out;
+	print "ok ", $testnum++, "\n";
+}
+
+__DATA__
+"Hi There"
+"what do ya want for nothing?"
+chr(0xdd) x 50
+chr(0xcd) x 50
+"Test With Truncation"
+"Test Using Larger Than Block-Size Key - Hash Key First"
+"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
diff --git a/cpan/Digest-SHA/t/sha1.t b/cpan/Digest-SHA/t/sha1.t
new file mode 100644
index 0000000000..e7de6f2601
--- /dev/null
+++ b/cpan/Digest-SHA/t/sha1.t
@@ -0,0 +1,37 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(sha1_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @vecs = map { eval } <DATA>;
+$#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl";
+
+my $numtests = scalar(@vecs) / 2;
+print "1..$numtests\n";
+
+for (1 .. $numtests) {
+	my $data = shift @vecs;
+	my $digest = shift @vecs;
+	print "not " unless sha1_hex($data) eq $digest;
+	print "ok ", $_, "\n";
+}
+
+__DATA__
+"abc"
+"a9993e364706816aba3e25717850c26c9cd0d89d"
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+"84983e441c3bd26ebaae4aa1f95129e5e54670f1"
+"a" x 1000000
+"34aa973cd4c4daa4f61eeb2bdbad27316534016f"
diff --git a/cpan/Digest-SHA/t/sha224.t b/cpan/Digest-SHA/t/sha224.t
new file mode 100644
index 0000000000..6c2b45f0e3
--- /dev/null
+++ b/cpan/Digest-SHA/t/sha224.t
@@ -0,0 +1,37 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(sha224_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @vecs = map { eval } <DATA>;
+$#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl";
+
+my $numtests = scalar(@vecs) / 2;
+print "1..$numtests\n";
+
+for (1 .. $numtests) {
+	my $data = shift @vecs;
+	my $digest = shift @vecs;
+	print "not " unless sha224_hex($data) eq $digest;
+	print "ok ", $_, "\n";
+}
+
+__DATA__
+"abc"
+"23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7"
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+"75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525"
+"a" x 1000000
+"20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67"
diff --git a/cpan/Digest-SHA/t/sha256.t b/cpan/Digest-SHA/t/sha256.t
new file mode 100644
index 0000000000..591f432c94
--- /dev/null
+++ b/cpan/Digest-SHA/t/sha256.t
@@ -0,0 +1,37 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(sha256_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @vecs = map { eval } <DATA>;
+$#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl";
+
+my $numtests = scalar(@vecs) / 2;
+print "1..$numtests\n";
+
+for (1 .. $numtests) {
+	my $data = shift @vecs;
+	my $digest = shift @vecs;
+	print "not " unless sha256_hex($data) eq $digest;
+	print "ok ", $_, "\n";
+}
+
+__DATA__
+"abc"
+"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"
+"a" x 1000000
+"cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0"
diff --git a/cpan/Digest-SHA/t/sha384.t b/cpan/Digest-SHA/t/sha384.t
new file mode 100644
index 0000000000..a6fbd360c7
--- /dev/null
+++ b/cpan/Digest-SHA/t/sha384.t
@@ -0,0 +1,41 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(sha384_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @vecs = map { eval } <DATA>;
+$#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl";
+
+my $numtests = scalar(@vecs) / 2;
+print "1..$numtests\n";
+
+my $skip = sha384_hex("") ? 0 : 1;
+
+for (1 .. $numtests) {
+	my $data = shift @vecs;
+	my $digest = shift @vecs;
+	unless ($skip) {
+		print "not " unless sha384_hex($data) eq $digest;
+	}
+	print "ok ", $_, $skip ? " # skip: no 64 bit" : "", "\n";
+}
+
+__DATA__
+"abc"
+"cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7"
+"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"
+"09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039"
+"a" x 1000000
+"9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b07b8b3dc38ecc4ebae97ddd87f3d8985"
diff --git a/cpan/Digest-SHA/t/sha512.t b/cpan/Digest-SHA/t/sha512.t
new file mode 100644
index 0000000000..7228554066
--- /dev/null
+++ b/cpan/Digest-SHA/t/sha512.t
@@ -0,0 +1,41 @@
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(sha512_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @vecs = map { eval } <DATA>;
+$#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl";
+
+my $numtests = scalar(@vecs) / 2;
+print "1..$numtests\n";
+
+my $skip = sha512_hex("") ? 0 : 1;
+
+for (1 .. $numtests) {
+	my $data = shift @vecs;
+	my $digest = shift @vecs;
+	unless ($skip) {
+		print "not " unless sha512_hex($data) eq $digest;
+	}
+	print "ok ", $_, $skip ? " # skip: no 64 bit" : "", "\n";
+}
+
+__DATA__
+"abc"
+"ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f"
+"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"
+"8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909"
+"a" x 1000000
+"e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b"
diff --git a/cpan/Digest-SHA/t/woodbury.t b/cpan/Digest-SHA/t/woodbury.t
new file mode 100644
index 0000000000..d56e8108a8
--- /dev/null
+++ b/cpan/Digest-SHA/t/woodbury.t
@@ -0,0 +1,143 @@
+# Test Vectors for HMAC-SHA-256/384/512
+#
+# Vectors and initial script courtesy of Adam Woodbury, The MITRE Corporation
+
+use strict;
+
+my $MODULE;
+
+BEGIN {
+	$MODULE = ($ENV{PERL_CORE} || -d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl";
+	eval "require $MODULE" || die $@;
+	$MODULE->import(qw(hmac_sha256_hex hmac_sha384_hex hmac_sha512_hex));
+}
+
+BEGIN {
+	if ($ENV{PERL_CORE}) {
+		chdir 't' if -d 't';
+		@INC = '../lib';
+	}
+}
+
+my @plex = map { eval } <DATA>;
+
+my $numtests = scalar(@plex) / 3;
+print "1..$numtests\n";
+
+# Use RFC 2202 data/key values for 512-bit blocks
+
+my @data_bs512 = splice(@plex, 0, 7);
+my @keys_bs512 = splice(@plex, 0, 7);
+my @hmac256rsp = splice(@plex, 0, 7);
+
+# Lengthen final RFC 2202 data/key values for 1024-bit blocks
+
+my @data_bs1024 = splice(@plex, 0, 7);
+my @keys_bs1024 = splice(@plex, 0, 7);
+my @hmac384rsp  = splice(@plex, 0, 7);
+
+my @dat2_bs1024 = splice(@plex, 0, 7);
+my @key2_bs1024 = splice(@plex, 0, 7);
+my @hmac512rsp  = splice(@plex, 0, 7);
+
+my $testnum = 1;
+
+while (@data_bs512) {
+	print "not " unless
+		hmac_sha256_hex(shift @data_bs512, shift @keys_bs512)
+			eq shift @hmac256rsp;
+	print "ok ", $testnum++, "\n";
+}
+
+my $skip = hmac_sha384_hex("", "") ? 0 : 1;
+
+while (@data_bs1024) {
+	if ($skip) {
+		print "ok ", $testnum++,
+			$skip ? " # skip: no 64 bit" : "", "\n";
+		shift @data_bs1024;
+		next;
+	}
+	print "not " unless
+		hmac_sha384_hex(shift @data_bs1024, shift @keys_bs1024)
+			eq shift @hmac384rsp;
+	print "ok ", $testnum++, "\n";
+}
+
+while (@dat2_bs1024) {
+	if ($skip) {
+		print "ok ", $testnum++,
+			$skip ? " # skip: no 64 bit" : "", "\n";
+		shift @dat2_bs1024;
+		next;
+	}
+	print "not " unless
+		hmac_sha512_hex(shift @dat2_bs1024, shift @key2_bs1024)
+			eq shift @hmac512rsp;
+	print "ok ", $testnum++, "\n";
+}
+
+__DATA__
+"Hi There"
+"what do ya want for nothing?"
+chr(0xdd) x 50
+chr(0xcd) x 50
+"Test With Truncation"
+"Test Using Larger Than Block-Size Key - Hash Key First"
+"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
+chr(0x0b) x 20
+"Jefe"
+chr(0xaa) x 20
+join("", map { chr } (1 .. 25))
+chr(0x0c) x 20
+chr(0xaa) x 80
+chr(0xaa) x 80
+"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"
+"5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"
+"773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe"
+"82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b"
+"a3b6167473100ee06e0c796c2955552bfa6f7c0a6a8aef8b93f860aab0cd20c5"
+"6953025ed96f0c09f80a96f78e6538dbe2e7b820e3dd970e7ddd39091b32352f"
+"6355ac22e890d0a3c8481a5ca4825bc884d3e7a1ff98a2fc2ac7d8e064c3b2e6"
+"Hi There"
+"what do ya want for nothing?"
+chr(0xdd) x 50
+chr(0xcd) x 50
+"Test With Truncation"
+"Test Using Larger Than Block-Size Key - Hash Key First"
+"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data. The Larger Block-Sizes Make For Much Longer Test Vectors"
+chr(0x0b) x 20
+"Jefe"
+chr(0xaa) x 20
+join("", map { chr } (1 .. 25))
+chr(0x0c) x 20
+chr(0xaa) x 200
+chr(0xaa) x 200
+"afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6"
+"af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649"
+"88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27"
+"3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb"
+"3abf34c3503b2a23a46efc619baef897f4c8e42c934ce55ccbae9740fcbc1af4ca62269e2a37cd88ba926341efe4aeea"
+"ec629fe0dc1fab504fc1c89572d6573cf15c3a4b5b69d53f0c13849561a6c13e153af48d2538ce056a3fe10d69da16c3"
+"07109d2c6c2fdcac39c3a8b5f36fc9a69e029d3d8647cc3e4ddb77888418c5c09d807942e5f96d17ee9fd46aed64b7f2"
+"Hi There"
+"what do ya want for nothing?"
+chr(0xdd) x 50
+chr(0xcd) x 50
+"Test With Truncation"
+"Test Using Larger Than Block-Size Key - Hash Key First"
+"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data. The Larger Block-Sizes Make For Much Longer Test Vectors"
+chr(0x0b) x 20
+"Jefe"
+chr(0xaa) x 20
+join("", map { chr } (1 .. 25))
+chr(0x0c) x 20
+chr(0xaa) x 200
+chr(0xaa) x 200
+"87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854"
+"164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"
+"fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb"
+"b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd"
+"415fad6271580a531d4179bc891d87a650188707922a4fbb36663a1eb16da008711c5b50ddd0fc235084eb9d3364a1454fb2ef67cd1d29fe6773068ea266e96b"
+"9dc6330f4c966b62b735d565343cb77413deccdf42a92d9ef5e4e2ae33f6c924bbc8e34c47111bc069482d4dbcfee148419a6547f2d01500e8160b39cc2e4ae8"
+"396ed3a17cef82cddbd987ea66a5dd1f38b68167df31f049463b85fa10b531d0e90d1052f8c9c7cda263468ec3f980a8fec06213c2944c92a0ac95a2d8ade76d"
diff --git a/cpan/Digest-SHA/typemap b/cpan/Digest-SHA/typemap
new file mode 100644
index 0000000000..70c4dc1acb
--- /dev/null
+++ b/cpan/Digest-SHA/typemap
@@ -0,0 +1,2 @@
+SHA *						T_PTROBJ
+HMAC *						T_PTROBJ