r1502 - in packages: . libdigest-sha-perl
libdigest-sha-perl/branches libdigest-sha-perl/branches/upstream
libdigest-sha-perl/branches/upstream/current
libdigest-sha-perl/branches/upstream/current/src
libdigest-sha-perl/branches/upstream/current/t
libdigest-sha-perl/branches/upstream/current/t/gillogly
libdigest-sha-perl/branches/upstream/current/t/nist
libdigest-sha-perl/branches/upstream/current/t/state
Allard Hoeve
hoeve-guest at costa.debian.org
Wed Nov 16 10:46:46 UTC 2005
Author: hoeve-guest
Date: 2005-11-16 10:46:12 +0000 (Wed, 16 Nov 2005)
New Revision: 1502
Added:
packages/libdigest-sha-perl/
packages/libdigest-sha-perl/branches/
packages/libdigest-sha-perl/branches/upstream/
packages/libdigest-sha-perl/branches/upstream/current/
packages/libdigest-sha-perl/branches/upstream/current/Changes
packages/libdigest-sha-perl/branches/upstream/current/MANIFEST
packages/libdigest-sha-perl/branches/upstream/current/META.yml
packages/libdigest-sha-perl/branches/upstream/current/Makefile.PL
packages/libdigest-sha-perl/branches/upstream/current/README
packages/libdigest-sha-perl/branches/upstream/current/SHA.pm
packages/libdigest-sha-perl/branches/upstream/current/SHA.xs
packages/libdigest-sha-perl/branches/upstream/current/SIGNATURE
packages/libdigest-sha-perl/branches/upstream/current/ppport.h
packages/libdigest-sha-perl/branches/upstream/current/shasum
packages/libdigest-sha-perl/branches/upstream/current/src/
packages/libdigest-sha-perl/branches/upstream/current/src/hmac.c
packages/libdigest-sha-perl/branches/upstream/current/src/hmac.h
packages/libdigest-sha-perl/branches/upstream/current/src/hmacxtra.c
packages/libdigest-sha-perl/branches/upstream/current/src/sha.c
packages/libdigest-sha-perl/branches/upstream/current/src/sha.h
packages/libdigest-sha-perl/branches/upstream/current/src/sha64bit.c
packages/libdigest-sha-perl/branches/upstream/current/src/sha64bit.h
packages/libdigest-sha-perl/branches/upstream/current/src/shaxtra.c
packages/libdigest-sha-perl/branches/upstream/current/t/
packages/libdigest-sha-perl/branches/upstream/current/t/0-pod-coverage.t
packages/libdigest-sha-perl/branches/upstream/current/t/0-pod.t
packages/libdigest-sha-perl/branches/upstream/current/t/1-exist.t
packages/libdigest-sha-perl/branches/upstream/current/t/1-hello-world.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-1.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-224.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-256.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-384.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-512.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-base64.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-oo.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-vectors-bit.t
packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-vectors-byte.t
packages/libdigest-sha-perl/branches/upstream/current/t/3-gillogly-easy.t
packages/libdigest-sha-perl/branches/upstream/current/t/3-gillogly-hard.t
packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-increasing.t
packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-large.t
packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-random.t
packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-fips198.t
packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-rfc2202.t
packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-sha-256.t
packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-woodbury.t
packages/libdigest-sha-perl/branches/upstream/current/t/6-dump-load.t
packages/libdigest-sha-perl/branches/upstream/current/t/7-ireland.t
packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/
packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/state.011
packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/state.110
packages/libdigest-sha-perl/branches/upstream/current/t/nist/
packages/libdigest-sha-perl/branches/upstream/current/t/nist/COPYRIGHT
packages/libdigest-sha-perl/branches/upstream/current/t/nist/Readme.txt
packages/libdigest-sha-perl/branches/upstream/current/t/nist/bit-hashes.sha1
packages/libdigest-sha-perl/branches/upstream/current/t/nist/bit-messages.sha1
packages/libdigest-sha-perl/branches/upstream/current/t/nist/byte-hashes.sha1
packages/libdigest-sha-perl/branches/upstream/current/t/nist/byte-messages.sha1
packages/libdigest-sha-perl/branches/upstream/current/t/state/
packages/libdigest-sha-perl/branches/upstream/current/t/state/state.1
packages/libdigest-sha-perl/branches/upstream/current/t/state/state.256
packages/libdigest-sha-perl/branches/upstream/current/t/state/state.384
packages/libdigest-sha-perl/branches/upstream/current/t/state/state.512
packages/libdigest-sha-perl/branches/upstream/current/typemap
packages/libdigest-sha-perl/tags/
Log:
[svn-inject] Installing original source of libdigest-sha-perl
Added: packages/libdigest-sha-perl/branches/upstream/current/Changes
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/Changes 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/Changes 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,295 @@
+Revision history for Perl extension Digest::SHA.
+
+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
Added: packages/libdigest-sha-perl/branches/upstream/current/MANIFEST
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/MANIFEST 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/MANIFEST 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,55 @@
+Changes
+Makefile.PL
+MANIFEST
+META.yml
+ppport.h
+README
+SHA.pm
+SHA.xs
+shasum
+SIGNATURE
+typemap
+src/hmac.c
+src/hmac.h
+src/hmacxtra.c Not used for Perl build
+src/sha.c
+src/sha.h
+src/shaxtra.c Not used for Perl build
+src/sha64bit.c
+src/sha64bit.h
+t/0-pod-coverage.t
+t/0-pod.t
+t/1-exist.t
+t/1-hello-world.t
+t/2-nist-sha-1.t
+t/2-nist-sha-224.t
+t/2-nist-sha-256.t
+t/2-nist-sha-384.t
+t/2-nist-sha-512.t
+t/2-nist-sha-base64.t
+t/2-nist-sha-oo.t
+t/2-nist-vectors-bit.t
+t/2-nist-vectors-byte.t
+t/3-gillogly-easy.t
+t/3-gillogly-hard.t
+t/4-bitstr-increasing.t
+t/4-bitstr-large.t
+t/4-bitstr-random.t
+t/5-hmac-fips198.t
+t/5-hmac-rfc2202.t
+t/5-hmac-sha-256.t
+t/5-hmac-woodbury.t
+t/6-dump-load.t
+t/7-ireland.t
+t/gillogly/state.011
+t/gillogly/state.110
+t/nist/COPYRIGHT
+t/nist/Readme.txt
+t/nist/bit-hashes.sha1
+t/nist/bit-messages.sha1
+t/nist/byte-hashes.sha1
+t/nist/byte-messages.sha1
+t/state/state.1
+t/state/state.256
+t/state/state.384
+t/state/state.512
Added: packages/libdigest-sha-perl/branches/upstream/current/META.yml
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/META.yml 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/META.yml 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,16 @@
+--- #YAML:1.0
+name: Digest-SHA
+version: 5.31
+author:
+ - Mark Shelor, mshelor at cpan.org
+abstract: Perl extension for SHA-1/224/256/384/512
+license: perl
+requires: {}
+recommends: {}
+build_requires: {}
+conflicts: {}
+provides:
+ Digest::SHA:
+ file: SHA.pm
+ version: 5.31
+generated_by: Module::Build version 0.22
Added: packages/libdigest-sha-perl/branches/upstream/current/Makefile.PL
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/Makefile.PL 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/Makefile.PL 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,34 @@
+use ExtUtils::MakeMaker;
+use Getopt::Std;
+use Config;
+
+my %opts;
+getopts('tx', \%opts);
+
+my @defines = ('-DSHA_PERL_MODULE');
+
+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);
+
+WriteMakefile(
+ 'NAME' => 'Digest::SHA',
+ 'VERSION_FROM' => 'SHA.pm',
+ 'PREREQ_PM' => {},
+ 'AUTHOR' => 'Mark Shelor <mshelor at cpan.org>',
+ 'LIBS' => [''],
+ 'DEFINE' => $define,
+ 'INC' => '-I.',
+ 'NO_META' => 1,
+ 'EXE_FILES' => [ 'shasum' ]
+);
Added: packages/libdigest-sha-perl/branches/upstream/current/README
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/README 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/README 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,44 @@
+Digest::SHA version 5.31
+========================
+
+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-2005 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
Added: packages/libdigest-sha-perl/branches/upstream/current/SHA.pm
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/SHA.pm 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/SHA.pm 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,559 @@
+package Digest::SHA;
+
+use strict;
+use warnings;
+use integer;
+
+our $VERSION = '5.31';
+
+require Exporter;
+our @ISA = qw(Exporter);
+
+our @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)
+
+eval {
+ require MIME::Base64;
+ require Digest::base;
+ push(@ISA, 'Digest::base');
+};
+if ($@) {
+ *addfile = \&Addfile;
+ *hexdigest = \&Hexdigest;
+ *b64digest = \&B64digest;
+}
+
+require XSLoader;
+XSLoader::load('Digest::SHA', $VERSION);
+
+# Preloaded methods go here.
+
+# 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);
+}
+
+# local copy of "addfile" in case Digest::base not installed
+
+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);
+ }
+ unless (defined $n) {
+ require Carp;
+ Carp::croak("Read failed: $!");
+ }
+
+ $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);
+}
+
+1;
+__END__
+
+=head1 NAME
+
+Digest::SHA - Perl extension for SHA-1/224/256/384/512
+
+=head1 SYNOPSIS (SHA)
+
+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->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 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.
+
+=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.
+
+This method is inherited if L<Digest::base> is installed on your
+system. Otherwise, a functionally equivalent substitute is used.
+
+=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.
+
+=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.
+
+=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 at cpan.org>
+
+=head1 ACKNOWLEDGMENTS
+
+The author is particularly grateful to
+
+ Gisle Aas
+ Chris Carey
+ Julius Duque
+ Jeffrey Friedl
+ Robert Gilmour
+ Brian Gladman
+ Andy Lester
+ Alex Muntada
+ Chris Skiscim
+ Martin Thurn
+ Adam Woodbury
+
+for their valuable comments and suggestions.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2003-2005 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
Added: packages/libdigest-sha-perl/branches/upstream/current/SHA.xs
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/SHA.xs 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/SHA.xs 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,201 @@
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#include "ppport.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>
+
+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);
Added: packages/libdigest-sha-perl/branches/upstream/current/SIGNATURE
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/SIGNATURE 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/SIGNATURE 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,77 @@
+This file contains message digests of all files listed in MANIFEST,
+signed via the Module::Signature module, version 0.50.
+
+To verify the content in this distribution, first make sure you have
+Module::Signature installed, then type:
+
+ % cpansign -v
+
+It will check each file's integrity, as well as the signature's
+validity. If "==> Signature verified OK! <==" is not displayed,
+the distribution may already have been compromised, and you should
+not run its Makefile.PL or Build.PL.
+
+-----BEGIN PGP SIGNED MESSAGE-----
+Hash: SHA1
+
+SHA1 226f2775375a3481d1fc34c176b7b10876b43230 Changes
+SHA1 952a17b73eeb605287d1aa08d2e8bf4837106b43 MANIFEST
+SHA1 0a2a774c849ac1df06df6c9fc9f32c437032368e META.yml
+SHA1 9903634fd8ce5d1ed2fbece7be5ed0cd5d98f158 Makefile.PL
+SHA1 cf127ddcb3023c8f357eea4a377644d36dd2505f README
+SHA1 736019bcd8cc385ffb6d922c37b91a0b17bd1c26 SHA.pm
+SHA1 51d3d1db41241cdf960bb3d5c81efa9eac13b197 SHA.xs
+SHA1 0389154c992f23bfc99b36f187500c4d2e47ac95 ppport.h
+SHA1 d8faf01f83da1fedb6659364fd470adc98f65c10 shasum
+SHA1 c42f2e8f2357ece6882bbe276cb60e397f7151da src/hmac.c
+SHA1 915f3f64518c40a61b4d3ef15f8b93120110aa26 src/hmac.h
+SHA1 7589c6ce33e74a58ded932d69756659e91723fdb src/hmacxtra.c
+SHA1 42138d24d6db3e6797503a27c93b4ea0120c0c8d src/sha.c
+SHA1 a026c7288fd89b4ef17c37252289082c708dfcdc src/sha.h
+SHA1 c1bba35de65c8d81362472b76075dba8cf1e542b src/sha64bit.c
+SHA1 48d806b05a15dfd8211d5f7158b3294d86fa24d2 src/sha64bit.h
+SHA1 329ac17325437c725331fbf84ae0c9484f50041a src/shaxtra.c
+SHA1 40cbf841dee0e93f741ab63e32c9fe5a7177edbd t/0-pod-coverage.t
+SHA1 e9c6a5881fc60173fbc8d479c1afd2ce3b43bef1 t/0-pod.t
+SHA1 9d80d4157cbf2791d830c26e1757cbfb1fda717d t/1-exist.t
+SHA1 89d62a1c05ad0d2721d85d921490b181031ad2f8 t/1-hello-world.t
+SHA1 73700867f0df504d7f4545cd674c6f9bb64e4d1b t/2-nist-sha-1.t
+SHA1 0e53db5ce4fa566dd3c407970a7fca2ee5586083 t/2-nist-sha-224.t
+SHA1 d745cd3fe82b686f958782615a270b31261e1b59 t/2-nist-sha-256.t
+SHA1 baeb0deb7582bc6c7f5178b3e14d7dfe22ac5dba t/2-nist-sha-384.t
+SHA1 0a21b8f93bf56c64da46c39df2ea7addbc8bc937 t/2-nist-sha-512.t
+SHA1 60a4d5cdb98367fd4e31ac39f30cb05c6762d5ff t/2-nist-sha-base64.t
+SHA1 0c394207595a2e631e0e524fc618bd56402d2b9f t/2-nist-sha-oo.t
+SHA1 81a3e7ba244407c517ea15b391fbbc087c656cab t/2-nist-vectors-bit.t
+SHA1 7782177cf67fd8ad2074f433e4b30814a34524e5 t/2-nist-vectors-byte.t
+SHA1 2268f236c26d00bfc8c7d805f09108b4913ae5ec t/3-gillogly-easy.t
+SHA1 b1681ac42e405b7384926f2e065f0fd27e52dc99 t/3-gillogly-hard.t
+SHA1 97e25f4939ee815f77ca5d01921b7e3b2145d4ed t/4-bitstr-increasing.t
+SHA1 7d0e85bc97ffab13282e8e60a6ce3801a7876cd5 t/4-bitstr-large.t
+SHA1 c28ce25d2301a6dc322e127a41eebb2816286d57 t/4-bitstr-random.t
+SHA1 48a3befa7429d71540da174d31943fb3c1b5bb5d t/5-hmac-fips198.t
+SHA1 32ee94a4defaac702c9e62e4f89466beb7c38ba9 t/5-hmac-rfc2202.t
+SHA1 6eeba20a4385cfacb6ccf1432b187166bc4108a6 t/5-hmac-sha-256.t
+SHA1 af0e69c897eeae25de8a00ddd8c0b197165b6e0c t/5-hmac-woodbury.t
+SHA1 8c357e6f889147f0ceaf0aea1f1b0e98022ce3b0 t/6-dump-load.t
+SHA1 6228a85f4d019149250d359b9a1713e75e0c5b35 t/7-ireland.t
+SHA1 636d5e987243f6634fdc1dff1fe1d11d07778347 t/gillogly/state.011
+SHA1 b1e86af6b46e066555bbcd749982ccba816cf744 t/gillogly/state.110
+SHA1 427874bceb58bc3a36b5808a204023334614930b t/nist/COPYRIGHT
+SHA1 573d7d4bba50c5cecb4a86f1ffff14d764a31ecb t/nist/Readme.txt
+SHA1 7996bb1a434fb3f6fd38f64800ab3b2fe5d23c6b t/nist/bit-hashes.sha1
+SHA1 d21096373dfbf3330d89bcb2e704b543a27b6065 t/nist/bit-messages.sha1
+SHA1 dd66fe858830fb1b23d35affa402b52a77a15b1f t/nist/byte-hashes.sha1
+SHA1 936304c2db3a3ee49ecb1247f8466814cab080a0 t/nist/byte-messages.sha1
+SHA1 3b51b03c790b1cf112d4804573f5fd4814b384c2 t/state/state.1
+SHA1 cc3d0feffc019e4651fb085e7bc51e190e58fa53 t/state/state.256
+SHA1 2130ee8086bc7bf41fc329e9d87a81e2d98b68c8 t/state/state.384
+SHA1 69cd49d84cb11c83ef8e6eb36f6a472edb37079d t/state/state.512
+SHA1 e93dd71c67ba56e170516c16eeeb7659a41f91fd typemap
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.4.0 (Darwin)
+
+iD8DBQFDG/mEBwNg/wr1Y/4RAlDyAKDe/1HH7Ve16rGkvaLDZCtPlY4iUwCgon76
+x3mClMHPFnCVwnSTFShiPMk=
+=xtkD
+-----END PGP SIGNATURE-----
Added: packages/libdigest-sha-perl/branches/upstream/current/ppport.h
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/ppport.h 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/ppport.h 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,540 @@
+
+/* ppport.h -- Perl/Pollution/Portability Version 2.0002
+ *
+ * Automatically Created by Devel::PPPort on Wed Oct 8 22:28:04 2003
+ *
+ * Do NOT edit this file directly! -- Edit PPPort.pm instead.
+ *
+ * Version 2.x, Copyright (C) 2001, Paul Marquess.
+ * Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
+ * This code may be used and distributed under the same license as any
+ * version of Perl.
+ *
+ * This version of ppport.h is designed to support operation with Perl
+ * installations back to 5.004, and has been tested up to 5.8.0.
+ *
+ * If this version of ppport.h is failing during the compilation of this
+ * module, please check if a newer version of Devel::PPPort is available
+ * on CPAN before sending a bug report.
+ *
+ * If you are using the latest version of Devel::PPPort and it is failing
+ * during compilation of this module, please send a report to perlbug at perl.com
+ *
+ * Include all following information:
+ *
+ * 1. The complete output from running "perl -V"
+ *
+ * 2. This file.
+ *
+ * 3. The name & version of the module you were trying to build.
+ *
+ * 4. A full log of the build that failed.
+ *
+ * 5. Any other information that you think could be relevant.
+ *
+ *
+ * For the latest version of this code, please retreive the Devel::PPPort
+ * module from CPAN.
+ *
+ */
+
+/*
+ * In order for a Perl extension module to be as portable as possible
+ * across differing versions of Perl itself, certain steps need to be taken.
+ * Including this header is the first major one, then using dTHR is all the
+ * appropriate places and using a PL_ prefix to refer to global Perl
+ * variables is the second.
+ *
+ */
+
+
+/* If you use one of a few functions that were not present in earlier
+ * versions of Perl, please add a define before the inclusion of ppport.h
+ * for a static include, or use the GLOBAL request in a single module to
+ * produce a global definition that can be referenced from the other
+ * modules.
+ *
+ * Function: Static define: Extern define:
+ * newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL
+ *
+ */
+
+
+/* To verify whether ppport.h is needed for your module, and whether any
+ * special defines should be used, ppport.h can be run through Perl to check
+ * your source code. Simply say:
+ *
+ * perl -x ppport.h *.c *.h *.xs foo/bar*.c [etc]
+ *
+ * The result will be a list of patches suggesting changes that should at
+ * least be acceptable, if not necessarily the most efficient solution, or a
+ * fix for all possible problems. It won't catch where dTHR is needed, and
+ * doesn't attempt to account for global macro or function definitions,
+ * nested includes, typemaps, etc.
+ *
+ * In order to test for the need of dTHR, please try your module under a
+ * recent version of Perl that has threading compiled-in.
+ *
+ */
+
+
+/*
+#!/usr/bin/perl
+ at ARGV = ("*.xs") if !@ARGV;
+%badmacros = %funcs = %macros = (); $replace = 0;
+foreach (<DATA>) {
+ $funcs{$1} = 1 if /Provide:\s+(\S+)/;
+ $macros{$1} = 1 if /^#\s*define\s+([a-zA-Z0-9_]+)/;
+ $replace = $1 if /Replace:\s+(\d+)/;
+ $badmacros{$2}=$1 if $replace and /^#\s*define\s+([a-zA-Z0-9_]+).*?\s+([a-zA-Z0-9_]+)/;
+ $badmacros{$1}=$2 if /Replace (\S+) with (\S+)/;
+}
+foreach $filename (map(glob($_), at ARGV)) {
+ unless (open(IN, "<$filename")) {
+ warn "Unable to read from $file: $!\n";
+ next;
+ }
+ print "Scanning $filename...\n";
+ $c = ""; while (<IN>) { $c .= $_; } close(IN);
+ $need_include = 0; %add_func = (); $changes = 0;
+ $has_include = ($c =~ /#.*include.*ppport/m);
+
+ foreach $func (keys %funcs) {
+ if ($c =~ /#.*define.*\bNEED_$func(_GLOBAL)?\b/m) {
+ if ($c !~ /\b$func\b/m) {
+ print "If $func isn't needed, you don't need to request it.\n" if
+ $changes += ($c =~ s/^.*#.*define.*\bNEED_$func\b.*\n//m);
+ } else {
+ print "Uses $func\n";
+ $need_include = 1;
+ }
+ } else {
+ if ($c =~ /\b$func\b/m) {
+ $add_func{$func} =1 ;
+ print "Uses $func\n";
+ $need_include = 1;
+ }
+ }
+ }
+
+ if (not $need_include) {
+ foreach $macro (keys %macros) {
+ if ($c =~ /\b$macro\b/m) {
+ print "Uses $macro\n";
+ $need_include = 1;
+ }
+ }
+ }
+
+ foreach $badmacro (keys %badmacros) {
+ if ($c =~ /\b$badmacro\b/m) {
+ $changes += ($c =~ s/\b$badmacro\b/$badmacros{$badmacro}/gm);
+ print "Uses $badmacros{$badmacro} (instead of $badmacro)\n";
+ $need_include = 1;
+ }
+ }
+
+ if (scalar(keys %add_func) or $need_include != $has_include) {
+ if (!$has_include) {
+ $inc = join('',map("#define NEED_$_\n", sort keys %add_func)).
+ "#include \"ppport.h\"\n";
+ $c = "$inc$c" unless $c =~ s/#.*include.*XSUB.*\n/$&$inc/m;
+ } elsif (keys %add_func) {
+ $inc = join('',map("#define NEED_$_\n", sort keys %add_func));
+ $c = "$inc$c" unless $c =~ s/^.*#.*include.*ppport.*$/$inc$&/m;
+ }
+ if (!$need_include) {
+ print "Doesn't seem to need ppport.h.\n";
+ $c =~ s/^.*#.*include.*ppport.*\n//m;
+ }
+ $changes++;
+ }
+
+ if ($changes) {
+ open(OUT,">/tmp/ppport.h.$$");
+ print OUT $c;
+ close(OUT);
+ open(DIFF, "diff -u $filename /tmp/ppport.h.$$|");
+ while (<DIFF>) { s!/tmp/ppport\.h\.$$!$filename.patched!; print STDOUT; }
+ close(DIFF);
+ unlink("/tmp/ppport.h.$$");
+ } else {
+ print "Looks OK\n";
+ }
+}
+__DATA__
+*/
+
+#ifndef _P_P_PORTABILITY_H_
+#define _P_P_PORTABILITY_H_
+
+#ifndef PERL_REVISION
+# ifndef __PATCHLEVEL_H_INCLUDED__
+# include "patchlevel.h"
+# endif
+# ifndef PERL_REVISION
+# define PERL_REVISION (5)
+ /* Replace: 1 */
+# define PERL_VERSION PATCHLEVEL
+# define PERL_SUBVERSION SUBVERSION
+ /* Replace PERL_PATCHLEVEL with PERL_VERSION */
+ /* Replace: 0 */
+# endif
+#endif
+
+#define PERL_BCDVERSION ((PERL_REVISION * 0x1000000L) + (PERL_VERSION * 0x1000L) + PERL_SUBVERSION)
+
+/* It is very unlikely that anyone will try to use this with Perl 6
+ (or greater), but who knows.
+ */
+#if PERL_REVISION != 5
+# error ppport.h only works with Perl version 5
+#endif /* PERL_REVISION != 5 */
+
+#ifndef ERRSV
+# define ERRSV perl_get_sv("@",FALSE)
+#endif
+
+#if (PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5))
+/* Replace: 1 */
+# define PL_Sv Sv
+# define PL_compiling compiling
+# define PL_copline copline
+# define PL_curcop curcop
+# define PL_curstash curstash
+# define PL_defgv defgv
+# define PL_dirty dirty
+# define PL_dowarn dowarn
+# define PL_hints hints
+# define PL_na na
+# define PL_perldb perldb
+# define PL_rsfp_filters rsfp_filters
+# define PL_rsfpv rsfp
+# define PL_stdingv stdingv
+# define PL_sv_no sv_no
+# define PL_sv_undef sv_undef
+# define PL_sv_yes sv_yes
+/* Replace: 0 */
+#endif
+
+#ifdef HASATTRIBUTE
+# if defined(__GNUC__) && defined(__cplusplus)
+# define PERL_UNUSED_DECL
+# else
+# define PERL_UNUSED_DECL __attribute__((unused))
+# endif
+#else
+# define PERL_UNUSED_DECL
+#endif
+
+#ifndef dNOOP
+# define NOOP (void)0
+# define dNOOP extern int Perl___notused PERL_UNUSED_DECL
+#endif
+
+#ifndef dTHR
+# define dTHR dNOOP
+#endif
+
+#ifndef dTHX
+# define dTHX dNOOP
+# define dTHXa(x) dNOOP
+# define dTHXoa(x) dNOOP
+#endif
+
+#ifndef pTHX
+# define pTHX void
+# define pTHX_
+# define aTHX
+# define aTHX_
+#endif
+
+#ifndef UVSIZE
+# define UVSIZE IVSIZE
+#endif
+
+#ifndef NVTYPE
+# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)
+# define NVTYPE long double
+# else
+# define NVTYPE double
+# endif
+typedef NVTYPE NV;
+#endif
+
+#ifndef INT2PTR
+
+#if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
+# define PTRV UV
+# define INT2PTR(any,d) (any)(d)
+#else
+# if PTRSIZE == LONGSIZE
+# define PTRV unsigned long
+# else
+# define PTRV unsigned
+# endif
+# define INT2PTR(any,d) (any)(PTRV)(d)
+#endif
+#define NUM2PTR(any,d) (any)(PTRV)(d)
+#define PTR2IV(p) INT2PTR(IV,p)
+#define PTR2UV(p) INT2PTR(UV,p)
+#define PTR2NV(p) NUM2PTR(NV,p)
+#if PTRSIZE == LONGSIZE
+# define PTR2ul(p) (unsigned long)(p)
+#else
+# define PTR2ul(p) INT2PTR(unsigned long,p)
+#endif
+
+#endif /* !INT2PTR */
+
+#ifndef boolSV
+# define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
+#endif
+
+#ifndef gv_stashpvn
+# define gv_stashpvn(str,len,flags) gv_stashpv(str,flags)
+#endif
+
+#ifndef newSVpvn
+# define newSVpvn(data,len) ((len) ? newSVpv ((data), (len)) : newSVpv ("", 0))
+#endif
+
+#ifndef newRV_inc
+/* Replace: 1 */
+# define newRV_inc(sv) newRV(sv)
+/* Replace: 0 */
+#endif
+
+/* DEFSV appears first in 5.004_56 */
+#ifndef DEFSV
+# define DEFSV GvSV(PL_defgv)
+#endif
+
+#ifndef SAVE_DEFSV
+# define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv))
+#endif
+
+#ifndef newRV_noinc
+# ifdef __GNUC__
+# define newRV_noinc(sv) \
+ ({ \
+ SV *nsv = (SV*)newRV(sv); \
+ SvREFCNT_dec(sv); \
+ nsv; \
+ })
+# else
+# if defined(USE_THREADS)
+static SV * newRV_noinc (SV * sv)
+{
+ SV *nsv = (SV*)newRV(sv);
+ SvREFCNT_dec(sv);
+ return nsv;
+}
+# else
+# define newRV_noinc(sv) \
+ (PL_Sv=(SV*)newRV(sv), SvREFCNT_dec(sv), (SV*)PL_Sv)
+# endif
+# endif
+#endif
+
+/* Provide: newCONSTSUB */
+
+/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
+#if (PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION < 63))
+
+#if defined(NEED_newCONSTSUB)
+static
+#else
+extern void newCONSTSUB(HV * stash, char * name, SV *sv);
+#endif
+
+#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
+void
+newCONSTSUB(stash,name,sv)
+HV *stash;
+char *name;
+SV *sv;
+{
+ U32 oldhints = PL_hints;
+ HV *old_cop_stash = PL_curcop->cop_stash;
+ HV *old_curstash = PL_curstash;
+ line_t oldline = PL_curcop->cop_line;
+ PL_curcop->cop_line = PL_copline;
+
+ PL_hints &= ~HINT_BLOCK_SCOPE;
+ if (stash)
+ PL_curstash = PL_curcop->cop_stash = stash;
+
+ newSUB(
+
+#if (PERL_VERSION < 3) || ((PERL_VERSION == 3) && (PERL_SUBVERSION < 22))
+ /* before 5.003_22 */
+ start_subparse(),
+#else
+# if (PERL_VERSION == 3) && (PERL_SUBVERSION == 22)
+ /* 5.003_22 */
+ start_subparse(0),
+# else
+ /* 5.003_23 onwards */
+ start_subparse(FALSE, 0),
+# endif
+#endif
+
+ newSVOP(OP_CONST, 0, newSVpv(name,0)),
+ newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */
+ newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
+ );
+
+ PL_hints = oldhints;
+ PL_curcop->cop_stash = old_cop_stash;
+ PL_curstash = old_curstash;
+ PL_curcop->cop_line = oldline;
+}
+#endif
+
+#endif /* newCONSTSUB */
+
+#ifndef START_MY_CXT
+
+/*
+ * Boilerplate macros for initializing and accessing interpreter-local
+ * data from C. All statics in extensions should be reworked to use
+ * this, if you want to make the extension thread-safe. See ext/re/re.xs
+ * for an example of the use of these macros.
+ *
+ * Code that uses these macros is responsible for the following:
+ * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
+ * 2. Declare a typedef named my_cxt_t that is a structure that contains
+ * all the data that needs to be interpreter-local.
+ * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
+ * 4. Use the MY_CXT_INIT macro such that it is called exactly once
+ * (typically put in the BOOT: section).
+ * 5. Use the members of the my_cxt_t structure everywhere as
+ * MY_CXT.member.
+ * 6. Use the dMY_CXT macro (a declaration) in all the functions that
+ * access MY_CXT.
+ */
+
+#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
+ defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT)
+
+/* This must appear in all extensions that define a my_cxt_t structure,
+ * right after the definition (i.e. at file scope). The non-threads
+ * case below uses it to declare the data as static. */
+#define START_MY_CXT
+
+#if (PERL_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION < 68 ))
+/* Fetches the SV that keeps the per-interpreter data. */
+#define dMY_CXT_SV \
+ SV *my_cxt_sv = perl_get_sv(MY_CXT_KEY, FALSE)
+#else /* >= perl5.004_68 */
+#define dMY_CXT_SV \
+ SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \
+ sizeof(MY_CXT_KEY)-1, TRUE)
+#endif /* < perl5.004_68 */
+
+/* This declaration should be used within all functions that use the
+ * interpreter-local data. */
+#define dMY_CXT \
+ dMY_CXT_SV; \
+ my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
+
+/* Creates and zeroes the per-interpreter data.
+ * (We allocate my_cxtp in a Perl SV so that it will be released when
+ * the interpreter goes away.) */
+#define MY_CXT_INIT \
+ dMY_CXT_SV; \
+ /* newSV() allocates one more than needed */ \
+ my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
+ Zero(my_cxtp, 1, my_cxt_t); \
+ sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
+
+/* This macro must be used to access members of the my_cxt_t structure.
+ * e.g. MYCXT.some_data */
+#define MY_CXT (*my_cxtp)
+
+/* Judicious use of these macros can reduce the number of times dMY_CXT
+ * is used. Use is similar to pTHX, aTHX etc. */
+#define pMY_CXT my_cxt_t *my_cxtp
+#define pMY_CXT_ pMY_CXT,
+#define _pMY_CXT ,pMY_CXT
+#define aMY_CXT my_cxtp
+#define aMY_CXT_ aMY_CXT,
+#define _aMY_CXT ,aMY_CXT
+
+#else /* single interpreter */
+
+
+#define START_MY_CXT static my_cxt_t my_cxt;
+#define dMY_CXT_SV dNOOP
+#define dMY_CXT dNOOP
+#define MY_CXT_INIT NOOP
+#define MY_CXT my_cxt
+
+#define pMY_CXT void
+#define pMY_CXT_
+#define _pMY_CXT
+#define aMY_CXT
+#define aMY_CXT_
+#define _aMY_CXT
+
+#endif
+
+#endif /* START_MY_CXT */
+
+#ifndef IVdf
+# if IVSIZE == LONGSIZE
+# define IVdf "ld"
+# define UVuf "lu"
+# define UVof "lo"
+# define UVxf "lx"
+# define UVXf "lX"
+# else
+# if IVSIZE == INTSIZE
+# define IVdf "d"
+# define UVuf "u"
+# define UVof "o"
+# define UVxf "x"
+# define UVXf "X"
+# endif
+# endif
+#endif
+
+#ifndef NVef
+# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
+ defined(PERL_PRIfldbl) /* Not very likely, but let's try anyway. */
+# define NVef PERL_PRIeldbl
+# define NVff PERL_PRIfldbl
+# define NVgf PERL_PRIgldbl
+# else
+# define NVef "e"
+# define NVff "f"
+# define NVgf "g"
+# endif
+#endif
+
+#ifndef AvFILLp /* Older perls (<=5.003) lack AvFILLp */
+# define AvFILLp AvFILL
+#endif
+
+#ifdef SvPVbyte
+# if PERL_REVISION == 5 && PERL_VERSION < 7
+ /* SvPVbyte does not work in perl-5.6.1, borrowed version for 5.7.3 */
+# undef SvPVbyte
+# define SvPVbyte(sv, lp) \
+ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
+ ? ((lp = SvCUR(sv)), SvPVX(sv)) : my_sv_2pvbyte(aTHX_ sv, &lp))
+ static char *
+ my_sv_2pvbyte(pTHX_ register SV *sv, STRLEN *lp)
+ {
+ sv_utf8_downgrade(sv,0);
+ return SvPV(sv,*lp);
+ }
+# endif
+#else
+# define SvPVbyte SvPV
+#endif
+
+#endif /* _P_P_PORTABILITY_H_ */
+
+/* End of File ppport.h */
Added: packages/libdigest-sha-perl/branches/upstream/current/shasum
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/shasum 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/shasum 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,173 @@
+#!perl -w
+
+ # shasum: filter for computing SHA digests (analogous to md5sum)
+ #
+ # Copyright (C) 2003-2005 Mark Shelor, All Rights Reserved
+ #
+ # Version: 5.31
+ # Mon Sep 5 00:52:42 MST 2005
+
+
+use strict;
+use Getopt::Long;
+
+my $VERSION = "5.31";
+
+
+ # 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.
+
+sub usage {
+ my($err) = @_;
+
+ my $stream = $err ? *STDERR : *STDOUT;
+ print $stream <<'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
+ -t, --text read files in text mode (default)
+
+The following two options are useful only when verifying checksums:
+ --status don't output anything, status code shows success
+ -w, --warn warn about improperly formatted MD5 checksum lines
+
+ --help display this help and exit
+ --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 text), and name for each FILE.
+
+Report bugs to <mshelor at cpan.org>.
+END_OF_USAGE
+ exit($err);
+}
+
+
+ # Collect options from command line
+
+my ($alg, $binary, $check, $text, $status, $warn, $help, $version);
+
+GetOptions(
+ 'binary' => \$binary, 'check' => \$check,
+ 'text' => \$text, 'algorithm=i' => \$alg,
+ 'status' => \$status, 'warn' => \$warn,
+ 'help' => \$help, 'version' => \$version
+) or usage(1);
+
+
+ # Deal with help requests and incorrect uses
+
+usage(0) if $help;
+usage(1) if $binary and $text;
+usage(1) if $warn and not $check;
+usage(1) if $status and not $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);
+
+
+ # 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" option.
+
+my $isDOSish = ($^O =~ /^(MSWin\d\d|os2|dos|mint|cygwin)$/);
+if ($isDOSish) { $binary = 1 unless $text }
+
+
+ # Read from STDIN (-) if no files listed on command line
+
+ at ARGV = ("-") unless @ARGV;
+
+
+ # sumfile($file): computes SHA digest of $file
+
+sub sumfile {
+ my($file) = @_;
+ my($fh, $digest);
+
+ unless (open($fh, "<$file")) {
+ print STDERR "shasum: $file: No such file or directory\n";
+ return;
+ }
+ binmode($fh) if $binary;
+ $digest = $module->new($alg)->addfile($fh)->hexdigest;
+ close($fh);
+ return($digest);
+}
+
+
+ # %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 = 0;
+ my ($fh, $sum, $fname, $rsp);
+
+ die "shasum: $checkfile: No such file or directory\n"
+ unless open($fh, "<$checkfile");
+ while (<$fh>) {
+ s/\s+$//;
+ ($sum, $binary, $fname) = /^(\S+)\s+(\*?)(.*)$/;
+ unless ($alg = $len2alg{length($sum)}) {
+ print STDERR "shasum: $checkfile: $.: improperly ",
+ "formatted SHA checksum line\n" if $warn;
+ next;
+ }
+ $rsp = "$fname: ";
+ if (lc($sum) eq sumfile($fname)) { $rsp .= "OK\n" }
+ else { $rsp .= "FAILED\n"; $err = 1 }
+ print $rsp unless $status;
+ }
+ close($fh);
+ exit($err);
+}
+
+
+ # Compute and display SHA checksums of requested files
+
+for (@ARGV) {
+ if (-d $_) {
+ print STDERR "shasum: $_: Is a directory\n";
+ next;
+ }
+ next unless my $digest = sumfile($_);
+ print "$digest ", $binary ? "\*" : " ", "$_\n";
+}
Property changes on: packages/libdigest-sha-perl/branches/upstream/current/shasum
___________________________________________________________________
Name: svn:executable
+
Added: packages/libdigest-sha-perl/branches/upstream/current/src/hmac.c
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/src/hmac.c 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/src/hmac.c 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,114 @@
+/*
+ * 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-2005 Mark Shelor, All Rights Reserved
+ *
+ * Version: 5.31
+ * Mon Sep 5 00:52:42 MST 2005
+ *
+ */
+
+#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(alg, key, keylen)
+int alg;
+unsigned char *key;
+unsigned int keylen;
+{
+ 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(bitstr, bitcnt, h)
+unsigned char *bitstr;
+unsigned long bitcnt;
+HMAC *h;
+{
+ return(shawrite(bitstr, bitcnt, h->isha));
+}
+
+/* hmacfinish: computes final digest state */
+void hmacfinish(h)
+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(h)
+HMAC *h;
+{
+ return(shadigest(h->osha));
+}
+
+/* hmachex: returns pointer to digest (hexadecimal) */
+char *hmachex(h)
+HMAC *h;
+{
+ return(shahex(h->osha));
+}
+
+/* hmacbase64: returns pointer to digest (Base 64) */
+char *hmacbase64(h)
+HMAC *h;
+{
+ return(shabase64(h->osha));
+}
+
+/* hmacclose: de-allocates digest object */
+int hmacclose(h)
+HMAC *h;
+{
+ shaclose(h->osha);
+ if (h != NULL) {
+ memset(h, 0, sizeof(HMAC));
+ SHA_free(h);
+ }
+ return(0);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/src/hmac.h
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/src/hmac.h 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/src/hmac.h 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,60 @@
+/*
+ * 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-2005 Mark Shelor, All Rights Reserved
+ *
+ * Version: 5.31
+ * Mon Sep 5 00:52:42 MST 2005
+ *
+ */
+
+#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;
+
+#if defined(__STDC__) && __STDC__ != 0
+ #define _HMAC_P(protos) protos
+#else
+ #define _HMAC_P(protos) ()
+#endif
+
+#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_P((_HMAC_ALG, _HMAC_KEY));
+unsigned long hmacwrite _HMAC_P((_HMAC_DATA, _HMAC_STATE));
+void hmacfinish _HMAC_P((_HMAC_STATE));
+unsigned char *hmacdigest _HMAC_P((_HMAC_STATE));
+char *hmachex _HMAC_P((_HMAC_STATE));
+char *hmacbase64 _HMAC_P((_HMAC_STATE));
+int hmacclose _HMAC_P((_HMAC_STATE));
+
+unsigned char *hmac1digest _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac1hex _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac1base64 _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+unsigned char *hmac224digest _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac224hex _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac224base64 _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+unsigned char *hmac256digest _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac256hex _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac256base64 _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+unsigned char *hmac384digest _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac384hex _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac384base64 _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+unsigned char *hmac512digest _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac512hex _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+char *hmac512base64 _HMAC_P((_HMAC_DATA, _HMAC_KEY));
+
+#endif /* _INCLUDE_HMAC_H_ */
Added: packages/libdigest-sha-perl/branches/upstream/current/src/hmacxtra.c
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/src/hmacxtra.c 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/src/hmacxtra.c 2005-11-16 10:46:12 UTC (rev 1502)
@@ -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)
Added: packages/libdigest-sha-perl/branches/upstream/current/src/sha.c
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/src/sha.c 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/src/sha.c 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,682 @@
+/*
+ * sha.c: routines to compute SHA-1/224/256/384/512 digests
+ *
+ * Ref: NIST FIPS PUB 180-2 Secure Hash Standard
+ *
+ * Copyright (C) 2003-2005 Mark Shelor, All Rights Reserved
+ *
+ * Version: 5.31
+ * Mon Sep 5 00:52:42 MST 2005
+ *
+ */
+
+#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(s, block) /* SHA-1 transform */
+SHA *s;
+UCHR *block;
+{
+ 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(s, block) /* SHA-224/256 transform */
+SHA *s;
+UCHR *block;
+{
+ 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(mem, w32)
+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(s)
+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(s)
+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(alg)
+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(bitstr, bitcnt, s)
+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(bitstr, bitcnt, s)
+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(bitstr, bitcnt, s)
+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(bitstr, bitcnt, s)
+UCHR *bitstr;
+ULNG bitcnt;
+SHA *s;
+{
+ if (bitcnt == 0)
+ 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(s)
+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)
+ s->sha(s, s->block), s->blockcnt = 0;
+ else
+ CLRBIT(s->block, s->blockcnt), s->blockcnt++;
+ 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), s->blockcnt = 0;
+}
+
+/* shadigest: returns pointer to current digest (binary) */
+UCHR *shadigest(s)
+SHA *s;
+{
+ digcpy(s);
+ return(s->digest);
+}
+
+/* shahex: returns pointer to current digest (hexadecimal) */
+char *shahex(s)
+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(in, n, out)
+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(s)
+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(s)
+SHA *s;
+{
+ return(s->digestlen);
+}
+
+/* shadup: duplicates current digest object */
+SHA *shadup(s)
+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(file, s)
+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 < 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(line, maxsize, f)
+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(line)
+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(line, pprest)
+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(f, tag, type, pval, reps, base)
+SHA_FILE *f;
+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(f, s)
+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(file)
+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(s)
+SHA *s;
+{
+ if (s != NULL) {
+ memset(s, 0, sizeof(SHA));
+ SHA_free(s);
+ }
+ return(0);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/src/sha.h
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/src/sha.h 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/src/sha.h 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,235 @@
+/*
+ * sha.h: header file for SHA-1/224/256/384/512 routines
+ *
+ * Ref: NIST FIPS PUB 180-2 Secure Hash Standard
+ *
+ * Copyright (C) 2003-2005 Mark Shelor, All Rights Reserved
+ *
+ * Version: 5.31
+ * Mon Sep 5 00:52:42 MST 2005
+ *
+ */
+
+#ifndef _INCLUDE_SHA_H_
+#define _INCLUDE_SHA_H_
+
+#include <limits.h>
+
+#define SHA32_MAX 4294967295U
+#define SHA64_MAX 18446744073709551615U
+
+#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_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 {
+ int alg;
+ void (*sha)();
+ 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
+
+#if defined(__STDC__) && __STDC__ != 0
+ #define _SHA_P(protos) protos
+#else
+ #define _SHA_P(protos) ()
+#endif
+
+#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_P((_SHA_ALG));
+unsigned long shawrite _SHA_P((_SHA_DATA, _SHA_STATE));
+void shafinish _SHA_P((_SHA_STATE));
+void sharewind _SHA_P((_SHA_STATE));
+unsigned char *shadigest _SHA_P((_SHA_STATE));
+char *shahex _SHA_P((_SHA_STATE));
+char *shabase64 _SHA_P((_SHA_STATE));
+int shadsize _SHA_P((_SHA_STATE));
+SHA *shadup _SHA_P((_SHA_STATE));
+int shadump _SHA_P((_SHA_FNAME, _SHA_STATE));
+SHA *shaload _SHA_P((_SHA_FNAME));
+int shaclose _SHA_P((_SHA_STATE));
+
+unsigned char *sha1digest _SHA_P((_SHA_DATA));
+char *sha1hex _SHA_P((_SHA_DATA));
+char *sha1base64 _SHA_P((_SHA_DATA));
+unsigned char *sha224digest _SHA_P((_SHA_DATA));
+char *sha224hex _SHA_P((_SHA_DATA));
+char *sha224base64 _SHA_P((_SHA_DATA));
+unsigned char *sha256digest _SHA_P((_SHA_DATA));
+char *sha256hex _SHA_P((_SHA_DATA));
+char *sha256base64 _SHA_P((_SHA_DATA));
+unsigned char *sha384digest _SHA_P((_SHA_DATA));
+char *sha384hex _SHA_P((_SHA_DATA));
+char *sha384base64 _SHA_P((_SHA_DATA));
+unsigned char *sha512digest _SHA_P((_SHA_DATA));
+char *sha512hex _SHA_P((_SHA_DATA));
+char *sha512base64 _SHA_P((_SHA_DATA));
+
+#endif /* _INCLUDE_SHA_H_ */
Added: packages/libdigest-sha-perl/branches/upstream/current/src/sha64bit.c
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/src/sha64bit.c 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/src/sha64bit.c 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,104 @@
+#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(s)
+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(s, block) /* SHA-384/512 transform */
+SHA *s;
+unsigned char *block;
+{
+ 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 */
Added: packages/libdigest-sha-perl/branches/upstream/current/src/sha64bit.h
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/src/sha64bit.h 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/src/sha64bit.h 2005-11-16 10:46:12 UTC (rev 1502)
@@ -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
Added: packages/libdigest-sha-perl/branches/upstream/current/src/shaxtra.c
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/src/shaxtra.c 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/src/shaxtra.c 2005-11-16 10:46:12 UTC (rev 1502)
@@ -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)
Added: packages/libdigest-sha-perl/branches/upstream/current/t/0-pod-coverage.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/0-pod-coverage.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/0-pod-coverage.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,18 @@
+use Test::More;
+eval "use Test::Pod::Coverage 0.08";
+plan skip_all => "Test::Pod::Coverage 0.08 required for testing POD coverage" if $@;
+
+my @privfcns = qw(
+ Addfile
+ Hexdigest
+ B64digest
+ shaclose
+ shadump
+ shadup
+ shaload
+ shaopen
+ sharewind
+ shawrite
+);
+
+all_pod_coverage_ok( { also_private => \@privfcns } );
Added: packages/libdigest-sha-perl/branches/upstream/current/t/0-pod.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/0-pod.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/0-pod.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,4 @@
+use Test::More;
+eval "use Test::Pod 1.00";
+plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
+all_pod_files_ok();
Added: packages/libdigest-sha-perl/branches/upstream/current/t/1-exist.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/1-exist.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/1-exist.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,17 @@
+use Test;
+
+BEGIN { plan tests => 1 }
+
+use Digest::SHA 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);
+
+ok(1);
Added: packages/libdigest-sha-perl/branches/upstream/current/t/1-hello-world.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/1-hello-world.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/1-hello-world.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,20 @@
+use Test;
+use Digest::SHA qw(sha1);
+use strict;
+use integer;
+
+my(@vec, @rsp);
+
+BEGIN {
+
+ @vec = ( "hello world" );
+
+ @rsp = ( pack("H*", "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed") );
+
+ plan tests => scalar(@vec);
+
+}
+
+for (my $i = 0; $i < @vec; $i++) {
+ ok(sha1($vec[$i]), $rsp[$i]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-1.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-1.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-1.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,26 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(sha1_hex);
+
+my(@vec, @rsp);
+
+BEGIN {
+ @vec = (
+"abc",
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+"a" x 1000000
+ );
+
+ @rsp = (
+"a9993e364706816aba3e25717850c26c9cd0d89d",
+"84983e441c3bd26ebaae4aa1f95129e5e54670f1",
+"34aa973cd4c4daa4f61eeb2bdbad27316534016f"
+ );
+
+ plan tests => scalar(@vec);
+}
+
+for (my $i = 0; $i < @vec; $i++) {
+ ok(sha1_hex($vec[$i]), $rsp[$i]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-224.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-224.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-224.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,26 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(sha224_hex);
+
+my(@vec, @rsp);
+
+BEGIN {
+ @vec = (
+"abc",
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+"a" x 1000000
+ );
+
+ @rsp = (
+"23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7",
+"75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525",
+"20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67"
+ );
+
+ plan tests => scalar(@vec);
+}
+
+for (my $i = 0; $i < @vec; $i++) {
+ ok(sha224_hex($vec[$i]), $rsp[$i]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-256.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-256.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-256.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,26 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(sha256_hex);
+
+my(@vec, @rsp);
+
+BEGIN {
+ @vec = (
+"abc",
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+"a" x 1000000
+ );
+
+ @rsp = (
+"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
+"cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0"
+ );
+
+ plan tests => scalar(@vec);
+}
+
+for (my $i = 0; $i < @vec; $i++) {
+ ok(sha256_hex($vec[$i]), $rsp[$i]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-384.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-384.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-384.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,28 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(sha384_hex);
+
+my(@vec, @rsp);
+
+BEGIN {
+ @vec = (
+"abc",
+"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
+"a" x 1000000
+ );
+
+ @rsp = (
+"cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7",
+"09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039",
+"9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b07b8b3dc38ecc4ebae97ddd87f3d8985"
+ );
+
+ plan tests => scalar(@vec);
+}
+
+my $skip = sha384_hex("") ? 0 : 1;
+
+for (my $i = 0; $i < @vec; $i++) {
+ skip($skip, sha384_hex($vec[$i]), $rsp[$i]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-512.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-512.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-512.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,28 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(sha512_hex);
+
+my(@vec, @rsp);
+
+BEGIN {
+ @vec = (
+"abc",
+"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
+"a" x 1000000
+ );
+
+ @rsp = (
+"ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f",
+"8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909",
+"e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b"
+ );
+
+ plan tests => scalar(@vec);
+}
+
+my $skip = sha512_hex("") ? 0 : 1;
+
+for (my $i = 0; $i < @vec; $i++) {
+ skip($skip, sha512_hex($vec[$i]), $rsp[$i]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-base64.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-base64.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-base64.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,30 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(sha1_base64 sha224_base64 sha256_base64 sha384_base64 sha512_base64);
+
+my(@vec, $data);
+
+BEGIN {
+ $data = "abc";
+ @vec = (
+\&sha1_base64, "qZk+NkcGgWq6PiVxeFDCbJzQ2J0",
+\&sha224_base64, "Iwl9IjQF2CKGQqR3vaJVsyqtvOS9oLP342ydpw",
+\&sha256_base64, "ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0",
+\&sha384_base64, "ywB1P0WjXou1oD1pmsZQBycsMqsO3tFjGotgWkP/W+2AhgcroefMI1i67KE0yCWn",
+\&sha512_base64, "3a81oZNherrMQXNJriBBMRLm+k6JqX6iCp7u5ktV05ohkpkqJ0/BqDa6PCOj/uu9RU1EI2Q86A4qmslPpUyknw"
+ );
+
+ plan tests => scalar(@vec) / 2;
+}
+
+my $fcn;
+my $rsp;
+my $skip;
+
+while (@vec) {
+ $fcn = shift(@vec);
+ $rsp = shift(@vec);
+ $skip = &$fcn("") ? 0 : 1;
+ skip($skip, &$fcn($data), $rsp);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-oo.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-oo.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-sha-oo.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,44 @@
+use Test;
+use strict;
+use integer;
+use File::Basename qw(dirname);
+use File::Spec;
+use Digest::SHA;
+
+my(@vec);
+
+BEGIN {
+ @vec = (
+"ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0",
+"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"
+ );
+
+ plan tests => 1 + scalar(@vec);
+}
+
+ # attempt to use an invalid algorithm, and check for failure
+
+my $NSA = "SHA-42"; # No Such Algorithm
+ok(Digest::SHA->new($NSA), undef);
+
+ # test OO methods using first two SHA-256 vectors from NIST
+
+my $temp = dirname($0) . "/oo.tmp";
+my $file = File::Spec->canonpath($temp);
+open(FILE, ">$file");
+binmode(FILE);
+print FILE "bcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
+close(FILE);
+
+my $ctx = Digest::SHA->new()->reset("SHA-256")->new();
+$ctx->add_bits("a", 5)->add_bits("001");
+
+my $rsp = shift(@vec);
+ok($ctx->clone->add("b", "c")->b64digest, $rsp);
+
+$rsp = shift(@vec);
+open(FILE, "<$file");
+binmode(FILE);
+ok($ctx->addfile(*FILE)->hexdigest, $rsp);
+close(FILE);
+unlink($file);
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-vectors-bit.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-vectors-bit.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-vectors-bit.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,82 @@
+# Test against SHA-1 Sample Vectors from NIST
+#
+# ref: http://csrc.nist.gov/cryptval/shs.html
+#
+# Uses files "nist/bit-messages.sha1" and "nist/bit-hashes.sha1"
+
+use Test;
+use strict;
+use integer;
+
+use File::Basename qw(dirname);
+use File::Spec;
+use Digest::SHA;
+
+my @hashes;
+
+BEGIN {
+ my $file = dirname($0) . "/nist/bit-hashes.sha1";
+ my $datafile = File::Spec->canonpath($file);
+ open(F, $datafile);
+ while (<F>) {
+ next unless (/^[0-9A-F]/);
+ s/[\r\n]+$//;
+ if (/\^$/) {
+ s/\s*\^$//;
+ push(@hashes, $_);
+ }
+ }
+ close(F);
+ plan tests => scalar(@hashes);
+}
+
+sub doType3 {
+ my $hash;
+ my $str = pack("B*", shift);
+ my $ctx = Digest::SHA->new(1);
+ for (my $j = 0; $j <= 99; $j++) {
+ for (my $i = 1; $i <= 50000; $i++) {
+ $str .= chr(0x00) x (int($j/4)+3);
+ $str .= pack("N", $i);
+ $str = $ctx->add($str)->digest;
+ }
+ ok(uc(unpack("H*", $str)), $hash = shift(@hashes));
+ }
+}
+
+my @msgs;
+my @cnts;
+my $bitstr;
+my $bitval;
+my $line;
+my $hash;
+my $type3 = 0;
+my $ctx = Digest::SHA->new(1);
+
+my $file = dirname($0) . "/nist/bit-messages.sha1";
+my $datafile = File::Spec->canonpath($file);
+open(F, $datafile);
+while (<F>) {
+ $type3 = 1 if (/Type 3/);
+ $type3 = 0 if (/^<D/);
+ next unless (/^[0-9^ ]/);
+ s/[\r\n]+$//;
+ $line .= $_;
+ if (/\^$/) {
+ $line =~ s/\s*\^$//;
+ @cnts = split(/\s+/, $line);
+ $bitstr = "";
+ $bitval = $cnts[1];
+ for (my $i = 0; $i < $cnts[0]; $i++) {
+ $bitstr .= $bitval x $cnts[$i+2];
+ $bitval = $bitval eq "1" ? "0" : "1";
+ }
+ ok(
+ uc($ctx->add_bits($bitstr)->hexdigest),
+ $hash = shift(@hashes)
+ ) unless $type3;
+ doType3($bitstr) if ($type3);
+ $line = "";
+ }
+}
+close(F);
Added: packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-vectors-byte.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-vectors-byte.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/2-nist-vectors-byte.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,82 @@
+# Test against SHA-1 Sample Vectors from NIST
+#
+# ref: http://csrc.nist.gov/cryptval/shs.html
+#
+# Uses files "nist/byte-messages.sha1" and "nist/byte-hashes.sha1"
+
+use Test;
+use strict;
+use integer;
+
+use File::Basename qw(dirname);
+use File::Spec;
+use Digest::SHA;
+
+my @hashes;
+
+BEGIN {
+ my $file = dirname($0) . "/nist/byte-hashes.sha1";
+ my $datafile = File::Spec->canonpath($file);
+ open(F, $datafile);
+ while (<F>) {
+ next unless (/^[0-9A-F]/);
+ s/[\r\n]+$//;
+ if (/\^$/) {
+ s/\s*\^$//;
+ push(@hashes, $_);
+ }
+ }
+ close(F);
+ plan tests => scalar(@hashes);
+}
+
+sub doType3 {
+ my $hash;
+ my $str = pack("B*", shift);
+ my $ctx = Digest::SHA->new(1);
+ for (my $j = 0; $j <= 99; $j++) {
+ for (my $i = 1; $i <= 50000; $i++) {
+ $str .= chr(0x00) x (int($j/4)+3);
+ $str .= pack("N", $i);
+ $str = $ctx->add($str)->digest;
+ }
+ ok(uc(unpack("H*", $str)), $hash = shift(@hashes));
+ }
+}
+
+my @msgs;
+my @cnts;
+my $bitstr;
+my $bitval;
+my $line;
+my $hash;
+my $type3 = 0;
+my $ctx = Digest::SHA->new(1);
+
+my $file = dirname($0) . "/nist/byte-messages.sha1";
+my $datafile = File::Spec->canonpath($file);
+open(F, $datafile);
+while (<F>) {
+ $type3 = 1 if (/Type 3/);
+ $type3 = 0 if (/^<D/);
+ next unless (/^[0-9^ ]/);
+ s/[\r\n]+$//;
+ $line .= $_;
+ if (/\^$/) {
+ $line =~ s/\s*\^$//;
+ @cnts = split(/\s+/, $line);
+ $bitstr = "";
+ $bitval = $cnts[1];
+ for (my $i = 0; $i < $cnts[0]; $i++) {
+ $bitstr .= $bitval x $cnts[$i+2];
+ $bitval = $bitval eq "1" ? "0" : "1";
+ }
+ ok (
+ uc($ctx->add(pack("B*", $bitstr))->hexdigest),
+ $hash = shift(@hashes)
+ ) unless $type3;
+ doType3($bitstr) if ($type3);
+ $line = "";
+ }
+}
+close(F);
Added: packages/libdigest-sha-perl/branches/upstream/current/t/3-gillogly-easy.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/3-gillogly-easy.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/3-gillogly-easy.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,61 @@
+# Test against short bitwise vectors from Jim Gillogly and Francois Grieu
+#
+# http://www.chiark.greenend.org.uk/pipermail/ukcrypto/1999-February/003538.html
+
+use Test;
+use strict;
+use integer;
+use Digest::SHA;
+
+# 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(@vec);
+
+BEGIN {
+ @vec = (
+ "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",
+ );
+ plan tests => scalar(@vec) / 4;
+}
+
+my $bitstr;
+my $bitcnt;
+my $ctx = Digest::SHA->new(1);
+
+for (my $i = 0; $i < @vec/4; $i++) {
+ $bitstr = ($vec[4*$i] x $vec[4*$i+1]) . $vec[4*$i+2];
+ $bitcnt = length($bitstr);
+ $bitstr = pack("B*", $bitstr);
+ ok($ctx->add_bits($bitstr, $bitcnt)->hexdigest, $vec[4*$i+3]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/3-gillogly-hard.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/3-gillogly-hard.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/3-gillogly-hard.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,114 @@
+# Test against long bitwise vectors from Jim Gillogly and Francois Grieu
+#
+# http://www.chiark.greenend.org.uk/pipermail/ukcrypto/1999-February/003538.html
+
+use Test;
+use strict;
+use integer;
+use File::Basename qw(dirname);
+use File::Spec;
+use Digest::SHA;
+
+# 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, @vec011);
+
+BEGIN {
+ @vec110 = ( # 110 rep 1431655764
+ "11", "1eef5a18969255a3b1793a2a955c7ec28cd221a5",
+ "110", "7a1045b914672aface8d90e6d19b3a6ada3cb879",
+ "1101", "d5e09777a94f1ea9240874c48d9fecb6b634256b",
+ "11011", "eb2569043c3014e51b2862ae6eb5fb4e0b851d99"
+ );
+
+ @vec011 = ( # 011 rep 1431655764
+ "01", "4cb0c4ef69143d5bf34fc35f1d4b19f6eccae0f2",
+ "011", "47d92f911fc7bb74de00adfc4e981a8105556d52",
+ "0110", "a3d7438c589b0b932aa91cc2446f06df9abc73f0",
+ "01101", "3eee3e1e28dede2ca444d68da5675b2faaab3203"
+ );
+ plan tests => scalar(@vec110) / 2 + scalar(@vec011) / 2;
+}
+
+my $fileSTATE110 = dirname($0) . "/gillogly/state.110";
+my $fileSTATE011 = dirname($0) . "/gillogly/state.011";
+
+my $STATE110 = File::Spec->canonpath($fileSTATE110);
+my $STATE011 = File::Spec->canonpath($fileSTATE011);
+
+my $reps = 1 << 14;
+my $loops = int(1431655764 / $reps);
+my $rest = 3 * (1431655764 - $loops * $reps);
+
+sub state110 {
+ my $state;
+ my $bitstr;
+
+ $state = Digest::SHA->new(1);
+ if (-r $STATE110) {
+ if ($state->load($STATE110)) {
+ return($state);
+ }
+ }
+ $bitstr = pack("B*", "110" x $reps);
+ $state->reset;
+ for (my $i = 0; $i < $loops; $i++) {
+ $state->add_bits($bitstr, 3 * $reps);
+ }
+ $state->add_bits($bitstr, $rest);
+ $state->dump($STATE110);
+ return($state);
+}
+
+sub state011 {
+ my $state;
+ my $bitstr;
+
+ $state = Digest::SHA->new(1);
+ if (-r $STATE011) {
+ if ($state->load($STATE011)) {
+ return($state);
+ }
+ }
+ $bitstr = pack("B*", "011" x $reps);
+ $state->reset;
+ for (my $i = 0; $i < $loops; $i++) {
+ $state->add_bits($bitstr, 3 * $reps);
+ }
+ $state->add_bits($bitstr, $rest);
+ $state->dump($STATE011);
+ return($state);
+}
+
+my $i;
+
+my $state110 = state110();
+for ($i = 0; $i < @vec110/2; $i++) {
+ my $state = $state110->clone;
+ $state->add_bits($vec110[2*$i]);
+ ok($state->hexdigest, $vec110[2*$i+1]);
+}
+
+my $state011 = state011();
+for ($i = 0; $i < @vec011/2; $i++) {
+ my $state = $state011->clone;
+ $state->add_bits($vec011[2*$i]);
+ ok($state->hexdigest, $vec011[2*$i+1]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-increasing.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-increasing.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-increasing.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,22 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA;
+
+BEGIN { plan tests => 1 }
+
+my $i;
+my $bitstr = pack("B*", "1" x 3999);
+my $state = Digest::SHA->new("sHa1");
+
+# Note that (1 + 2 + ... + 3999) + 2000 = 8000000
+
+for ($i = 0; $i <= 3999; $i++) {
+ $state->add_bits($bitstr, $i);
+}
+$state->add_bits($bitstr, 2000);
+
+ok(
+ $state->hexdigest,
+ "559a512393dd212220ee080730d6f11644ba0222"
+);
Added: packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-large.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-large.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-large.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,21 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA;
+
+BEGIN { plan tests => 1 }
+
+my $i;
+my $bitstr = pack("B*", "11111111" x 10000);
+my $state = Digest::SHA->new("1");
+
+$state->add_bits($bitstr, 1); # creates an alignment nuisance
+for ($i = 0; $i < 99; $i++) {
+ $state->add_bits($bitstr, 80000);
+}
+$state->add_bits($bitstr, 79999);
+
+ok(
+ $state->hexdigest,
+ "559a512393dd212220ee080730d6f11644ba0222"
+);
Added: packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-random.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-random.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/4-bitstr-random.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,24 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA;
+
+BEGIN { plan tests => 1 }
+
+my $reps = 8000000;
+my $bitstr = pack("B*", "11111111" x 127);
+my $maxbits = 8 * 127;
+my $state = Digest::SHA->new(1);
+my $num;
+
+while ($reps > $maxbits) {
+ $num = int(rand($maxbits));
+ $state->add_bits($bitstr, $num);
+ $reps -= $num;
+}
+$state->add_bits($bitstr, $reps);
+
+ok(
+ $state->hexdigest,
+ "559a512393dd212220ee080730d6f11644ba0222"
+);
Added: packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-fips198.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-fips198.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-fips198.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,44 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(hmac_sha1_hex);
+
+my(@vec);
+
+BEGIN {
+ @vec = (
+ "Sample #1",
+ "Sample #2",
+ "Sample #3",
+ "Sample #4"
+ );
+ plan tests => scalar(@vec);
+}
+
+my @keys = ("", "", "", "");
+
+my $i = 0;
+$keys[0] .= chr($i++) while (length($keys[0]) < 64);
+
+$i = 0x30;
+$keys[1] .= chr($i++) while (length($keys[1]) < 20);
+
+$i = 0x50;
+$keys[2] .= chr($i++) while (length($keys[2]) < 100);
+
+$i = 0x70;
+$keys[3] .= chr($i++) while (length($keys[3]) < 49);
+
+my @hmac1rsp = (
+ "4f4ca3d5d68ba7cc0a1208c9c61e9c5da0403c0a",
+ "0922d3405faa3d194f82a45830737d5cc6c75d24",
+ "bcf41eab8bb2d802f3d05caf7cb092ecf8d1a3aa",
+ "9ea886efe268dbecce420c7524df32e0751a2a26"
+);
+
+for ($i = 0; $i < @vec; $i++) {
+ ok(
+ hmac_sha1_hex($vec[$i], $keys[$i]),
+ $hmac1rsp[$i]
+ );
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-rfc2202.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-rfc2202.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-rfc2202.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,49 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(hmac_sha1_hex);
+
+my(@vec);
+
+BEGIN {
+ @vec = (
+"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"
+ );
+ plan tests => scalar(@vec);
+}
+
+my @keys = (
+ chr(0x0b) x 20,
+ "Jefe",
+ chr(0xaa) x 20,
+ "",
+ chr(0x0c) x 20,
+ chr(0xaa) x 80,
+ chr(0xaa) x 80
+);
+
+my @hmac1rsp = (
+ "b617318655057264e28bc0b6fb378c8ef146be00",
+ "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+ "125d7342b9ac11cd91a39af48aa17b4f63f175d3",
+ "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
+ "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+ "aa4ae5e15272d00e95705637ce8a3b55ed402112",
+ "e8e99d0f45237d786d6bbaa7965c7808bbff1a91"
+);
+
+my $i = 0x01;
+$keys[3] .= chr($i++) while (length($keys[3]) < 25);
+
+for ($i = 0; $i < @vec; $i++) {
+ ok(
+ hmac_sha1_hex($vec[$i], $keys[$i]),
+ $hmac1rsp[$i]
+ );
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-sha-256.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-sha-256.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-sha-256.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,64 @@
+# HMAC-SHA-256 test vectors from draft-ietf-ipsec-ciph-sha-256-01.txt
+
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(hmac_sha256_hex);
+
+my(@data);
+
+BEGIN {
+ @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"
+ );
+ plan tests => scalar(@data);
+}
+
+my $k1 = pack("H*", "0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20");
+my $k2 = pack("H*", "0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425");
+
+my @key = (
+ $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 @hmac256rsp = (
+ "a21b1f5d4cf4f73a4dd939750f7a066a7f98cc131cb16a6692759021cfab8181",
+ "104fdc1257328f08184ba73131c53caee698e36119421149ea8c712456697d30",
+ "470305fc7e40fe34d3eeb3e773d95aab73acf0fd060447a5eb4595bf33a9d1a3",
+ "198a607eb44bfbc69903a0f1cf2bbdc5ba0aa3f3d9ae3c1c7a3b1696a0b68cf7",
+ "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
+ "cdcb1220d1ecccea91e53aba3092f962e549fe6ce9ed7fdc43191fbde45c30b0",
+ "d4633c17f6fb8d744c66dee0f8f074556ec4af55ef07998541468eb49bd2e917",
+ "7546af01841fc09b1ab9c3749a5f1c17d4f589668a587b2700a9c97c1193cf42",
+ "6953025ed96f0c09f80a96f78e6538dbe2e7b820e3dd970e7ddd39091b32352f",
+ "6355ac22e890d0a3c8481a5ca4825bc884d3e7a1ff98a2fc2ac7d8e064c3b2e6"
+);
+
+ # do the first one by hand to test multi-argument data feed
+
+ok(hmac_sha256_hex("a", "b", "c", $k1), $hmac256rsp[0]);
+
+for (my $i = 1; $i < @data; $i++) {
+ ok(
+ hmac_sha256_hex($data[$i], $key[$i]),
+ $hmac256rsp[$i]
+ );
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-woodbury.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-woodbury.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/5-hmac-woodbury.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,114 @@
+# Test Vectors for HMAC-SHA-256/384/512
+#
+# Vectors and script courtesy of Adam Woodbury, The MITRE Corporation
+
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(hmac_sha256_hex hmac_sha384_hex hmac_sha512_hex);
+
+BEGIN { plan tests => 21 }
+
+# Use RFC 2202 data/key values for 512-bit blocks
+
+my @vecs_bs512 = (
+ "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"
+);
+
+my @keys_bs512 = (
+ chr(0x0b) x 20,
+ "Jefe",
+ chr(0xaa) x 20,
+ "",
+ chr(0x0c) x 20,
+ chr(0xaa) x 80,
+ chr(0xaa) x 80
+);
+
+# Lengthen final RFC 2202 data/key values for 1024-bit blocks
+
+my @vecs_bs1024 = (
+ "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"
+);
+
+my @keys_bs1024 = (
+ chr(0x0b) x 20,
+ "Jefe",
+ chr(0xaa) x 20,
+ "",
+ chr(0x0c) x 20,
+ chr(0xaa) x 200,
+ chr(0xaa) x 200
+);
+
+my @hmac256rsp = (
+ "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
+ "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
+ "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
+ "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
+ "a3b6167473100ee06e0c796c2955552bfa6f7c0a6a8aef8b93f860aab0cd20c5",
+ "6953025ed96f0c09f80a96f78e6538dbe2e7b820e3dd970e7ddd39091b32352f",
+ "6355ac22e890d0a3c8481a5ca4825bc884d3e7a1ff98a2fc2ac7d8e064c3b2e6"
+);
+
+my @hmac384rsp = (
+"afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6",
+"af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649",
+"88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27",
+"3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb",
+"3abf34c3503b2a23a46efc619baef897f4c8e42c934ce55ccbae9740fcbc1af4ca62269e2a37cd88ba926341efe4aeea",
+"ec629fe0dc1fab504fc1c89572d6573cf15c3a4b5b69d53f0c13849561a6c13e153af48d2538ce056a3fe10d69da16c3",
+"07109d2c6c2fdcac39c3a8b5f36fc9a69e029d3d8647cc3e4ddb77888418c5c09d807942e5f96d17ee9fd46aed64b7f2"
+);
+
+my @hmac512rsp = (
+"87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854",
+"164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737",
+"fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb",
+"b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd",
+"415fad6271580a531d4179bc891d87a650188707922a4fbb36663a1eb16da008711c5b50ddd0fc235084eb9d3364a1454fb2ef67cd1d29fe6773068ea266e96b",
+"9dc6330f4c966b62b735d565343cb77413deccdf42a92d9ef5e4e2ae33f6c924bbc8e34c47111bc069482d4dbcfee148419a6547f2d01500e8160b39cc2e4ae8",
+"396ed3a17cef82cddbd987ea66a5dd1f38b68167df31f049463b85fa10b531d0e90d1052f8c9c7cda263468ec3f980a8fec06213c2944c92a0ac95a2d8ade76d"
+);
+
+my $i = 0x01;
+$keys_bs512[3] .= chr($i++) while (length($keys_bs512[3]) < 25);
+$i = 0x01;
+$keys_bs1024[3] .= chr($i++) while (length($keys_bs1024[3]) < 25);
+
+for ($i = 0; $i < @vecs_bs512; $i++) {
+ ok(
+ hmac_sha256_hex($vecs_bs512[$i], $keys_bs512[$i]),
+ $hmac256rsp[$i]
+ );
+}
+
+my $skip = hmac_sha384_hex("", "") ? 0 : 1;
+
+for ($i = 0; $i < @vecs_bs1024; $i++) {
+ skip(
+ $skip,
+ hmac_sha384_hex($vecs_bs1024[$i], $keys_bs1024[$i]),
+ $hmac384rsp[$i]
+ );
+}
+
+for ($i = 0; $i < @vecs_bs1024; $i++) {
+ skip(
+ $skip,
+ hmac_sha512_hex($vecs_bs1024[$i], $keys_bs1024[$i]),
+ $hmac512rsp[$i]
+ );
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/6-dump-load.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/6-dump-load.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/6-dump-load.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,53 @@
+use Test;
+use strict;
+use integer;
+use Digest::SHA qw(sha384_hex sha512_hex);
+use File::Basename qw(dirname);
+use File::Spec;
+
+my(@sharsp);
+
+BEGIN {
+ @sharsp = (
+"34aa973cd4c4daa4f61eeb2bdbad27316534016f",
+"cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0",
+"9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b07b8b3dc38ecc4ebae97ddd87f3d8985",
+"e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b"
+ );
+ plan tests => scalar(@sharsp);
+}
+
+my @ext = (1, 256, 384, 512);
+my $data = "a" x 990000;
+my $skip;
+my $tmpname = dirname($0) . "/dumpload.tmp";
+my $tmpfile = File::Spec->canonpath($tmpname);
+
+for (my $i = 0; $i < @sharsp; $i++) {
+ $skip = 0;
+ if ($ext[$i] == 384) {
+ $skip = sha384_hex("") ? 0 : 1;
+ }
+ if ($ext[$i] == 512) {
+ $skip = sha512_hex("") ? 0 : 1;
+ }
+ my $digest;
+ unless ($skip) {
+ my $state;
+ my $file;
+ my $filename;
+ $filename = dirname($0) . "/state/state.$ext[$i]";
+ $file = File::Spec->canonpath($filename);
+ unless ($state = Digest::SHA->load($file)) {
+ $state = Digest::SHA->new($ext[$i]);
+ $state->add($data);
+ $state->dump($file);
+ $state->load($file);
+ }
+ $state->add_bits($data, 79984)->dump($tmpfile);
+ $state->load($tmpfile)->add_bits($data, 16);
+ unlink($tmpfile);
+ $digest = $state->hexdigest;
+ }
+ skip($skip, $digest, $sharsp[$i]);
+}
Added: packages/libdigest-sha-perl/branches/upstream/current/t/7-ireland.t
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/7-ireland.t 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/7-ireland.t 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,41 @@
+use Test;
+use strict;
+use File::Basename qw(dirname);
+use File::Spec;
+use Digest::SHA;
+
+# 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
+
+BEGIN { plan tests => 1 }
+
+my $filename = dirname($0) . "/ireland.tmp";
+my $file = File::Spec->canonpath($filename);
+open(F, ">$file"); while (<DATA>) { print F $_ } close(F);
+
+my $data = "a" x 1000000;
+my $vec = "b9045a713caed5dff3d3b783e98d1ce5778d8bc331ee4119d707072312af06a7";
+
+my $ctx;
+unless ($ctx = Digest::SHA->load($file)) {
+ $ctx = Digest::SHA->new(256);
+ for (1 .. 536) { $ctx->add($data) }
+ $ctx->add(substr($data, 0, 870910));
+ $ctx->dump($file);
+}
+$ctx->add("aa");
+ok($ctx->hexdigest, $vec);
+
+unlink($file);
+
+__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
Added: packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/state.011
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/state.011 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/state.011 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,8 @@
+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
Added: packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/state.110
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/state.110 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/gillogly/state.110 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,8 @@
+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
Added: packages/libdigest-sha-perl/branches/upstream/current/t/nist/COPYRIGHT
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/nist/COPYRIGHT 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/nist/COPYRIGHT 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,17 @@
+The files in this directory were extracted from the "sha1-vectors.zip"
+archive, which is publicly available through the National Institute
+of Standards and Technology (NIST) website at the following URL:
+
+ http://csrc.nist.gov/cryptval/shs.html
+
+The files have been truncated to include only the first 10 test
+cases for bit and byte messages. This was done solely to decrease
+the size of the module distribution, thereby making downloads much
+quicker for users. If a more extensive test run is desired, simply
+replace these files by the originals from the above URL.
+
+NIST advises that the archive file describes "tests and vectors
+that can be used to informally verify the correctness of an SHA-1
+implementation. However, use of these vectors does not take the
+place of validation obtained through the Cryptographic Module
+Validation Program."
Added: packages/libdigest-sha-perl/branches/upstream/current/t/nist/Readme.txt
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/nist/Readme.txt 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/nist/Readme.txt 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,82 @@
+
+ Sample Vectors for SHA-1 Testing
+
+ This file describes tests and vectors that can be used in verifying the correctness of
+an SHA-1 implementation. However, use of these vectors does not take the place of validation
+obtained through the Cryptographic Module Validation Program.
+
+ There are three areas of the Secure Hash Standard for which test vectors are supplied:
+short messages of varying length, selected long messages, and pseudorandomly generated messages.
+Since it is possible for an implementation to correctly handle the hashing of byte-oriented
+messages (and not messages of a non-byte length), the SHS tests each come in two flavors. For
+both byte oriented and bit oriented messages, the message lengths are given in bits.
+
+Type I Test: Messages of Varying Length
+
+ An implementation of the SHS must be able to correctly generate message digests for
+messages of arbitrary length. This functionality can be tested by supplying the implementation
+with 1025 pseudorandomly generated messages with lengths from 0 to 1024 bits (for an implementation
+that only hashes byte-oriented data correctly, 129 messages of length 0, 8, 16, 24,...,1024 bits
+will be supplied).
+
+Type II Test: Selected Long Messages
+
+ Additional testing of an implementation can be performed by testing that the implementation
+can correctly generate digests for longer messages. A list of 100 messages, each of length > 1024,
+is supplied. These can be used to verify the hashing of longer message lengths. For bit oriented
+testing the messages are from 1025 to 103425 bits long (length=1025+i*1024, where 0<=i<100). For
+byte oriented testing the messages are from 1032 to 103432 (length=1032+i*1024, where 0<=i<100).
+
+Type III Test: Pseudorandomly Generated Messages
+
+ This test determines whether the implementation can compute message digests for messages
+that are generated using a given seed. A sequence of 100 message digests is generated using this
+seed. The digests are generated according to the following pseudocode:
+
+procedure MonteCarlo(string SEED)
+{
+ integer i, j, a;
+ string M;
+
+ M := SEED;
+ for j = 0 to 99 do {
+ for i = 1 to 50000 do {
+ for a = 1 to (j/4*8 + 24) do M := M || ’0’; /*‘0' is the binary zero bit. */
+ M := M || i; /* Here, the value for ‘i’ is expressed as a 32-bit word
+ and concatenated with ‘M’. The first bit
+ concatenated with ‘M’ is the most significant bit of
+ this 32-bit word. */
+ M := SHA(M);
+ }
+ print(M);
+ }
+ }
+
+NOTE: In the above procedure, || denotes concatenation. Also, M || i denotes appending the 32-bit
+word representing the value ‘i’, as defined in section 2 of the SHS. Within the procedure, M is a string
+of variable length. The initial length of 416 bits ensures that the length of M never exceeds 512 bits
+during execution of the above procedure, and it ensures that messages will be of a byte length. Each
+element printed should be 160 bits in length.
+
+
+File formats:
+
+There are two files included for each test type (bit-oriented and byte-oriented). One file contains
+the messages and the other file contains the hashes.
+
+The message files provided use "compact strings" to store the message values. Compact strings are
+used to represented the messages in a compact form. A compact string has the form
+ z || b || n(1) || n(2) || ... || n(z)
+where z>=0 that represents the number of n, b is either 0 or 1, and each n(i) is a decimal integer
+representing a positive number. The length of the compact string is given by the summation of the n(i).
+
+The compact string is interpreted as the representation of the bit string consisting of b repeated n(1) times,
+followed by 1-b repeated n(2) times, followed by b repeated n(3) times, and so on.
+
+Example:
+ M = 5 1 7 13 5 1 2
+ where z = 5 and b = 1. Then the compact string M represents the bit string
+ 1111111000000000000011111011
+ where 1 is repeated 7 times, 0 is repeated 13 times, 1 is repeated 5 times,
+ 0 is repeated 1 time, and 1 is repeated 2 times.
+
Property changes on: packages/libdigest-sha-perl/branches/upstream/current/t/nist/Readme.txt
___________________________________________________________________
Name: svn:eol-style
+ native
Added: packages/libdigest-sha-perl/branches/upstream/current/t/nist/bit-hashes.sha1
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/nist/bit-hashes.sha1 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/nist/bit-hashes.sha1 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,14 @@
+# Configuration information for "SHA-1 Test"
+# SHA tests are configured for BIT oriented implementations
+H>SHS Type 1 Hashes<H
+D>
+DA39A3EE5E6B4B0D3255BFEF95601890AFD80709 ^
+59C4526AA2CC59F9A5F56B5579BA7108E7CCB61A ^
+6E42FB84067CFF056C43A49E484997AF23190879 ^
+C63FBB9A87171A176E6E054890E29A8C5F125F6C ^
+3109E33C1C4B9A0169D1599169D0E5A520A1E71C ^
+9195E1E73CC68D7170F44BD1D83CB624BC87FA0B ^
+64F7C374527278C0436DBC8DE5AABEC2BBF634BC ^
+154B622EA426FB151B1FF1BE1CE871752B9EDEB4 ^
+12BDD00FD4038756CBCF8ECDAD1B0CD862603CD8 ^
+6700F93E1691E83735279E167F67AF61FEE9813B ^
Added: packages/libdigest-sha-perl/branches/upstream/current/t/nist/bit-messages.sha1
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/nist/bit-messages.sha1 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/nist/bit-messages.sha1 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,14 @@
+# Configuration information for "SHA-1 Test"
+# SHA tests are configured for BIT oriented implementations
+H>SHS Type 1 Strings<H
+D>
+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 ^
Added: packages/libdigest-sha-perl/branches/upstream/current/t/nist/byte-hashes.sha1
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/nist/byte-hashes.sha1 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/nist/byte-hashes.sha1 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,14 @@
+# Configuration information for "SHA-1 Test"
+# SHA tests are configured for BYTE oriented implementations
+H>SHS Type 1 Hashes<H
+D>
+DA39A3EE5E6B4B0D3255BFEF95601890AFD80709 ^
+3CDF2936DA2FC556BFA533AB1EB59CE710AC80E5 ^
+19C1E2048FA7393CFBF2D310AD8209EC11D996E5 ^
+CA775D8C80FAA6F87FA62BECA6CA6089D63B56E5 ^
+71AC973D0E4B50AE9E5043FF4D615381120A25A0 ^
+A6B5B9F854CFB76701C3BDDBF374B3094EA49CBA ^
+D87A0EE74E4B9AD72E6847C87BDEEB3D07844380 ^
+1976B8DD509FE66BF09C9A8D33534D4EF4F63BFD ^
+5A78F439B6DB845BB8A558E4CEB106CD7B7FF783 ^
+F871BCE62436C1E280357416695EE2EF9B83695C ^
Added: packages/libdigest-sha-perl/branches/upstream/current/t/nist/byte-messages.sha1
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/nist/byte-messages.sha1 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/nist/byte-messages.sha1 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,14 @@
+# Configuration information for "SHA-1 Test"
+# SHA tests are configured for BYTE oriented implementations
+H>SHS Type 1 Strings<H
+D>
+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 ^
Added: packages/libdigest-sha-perl/branches/upstream/current/t/state/state.1
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/state/state.1 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/state/state.1 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,8 @@
+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
Added: packages/libdigest-sha-perl/branches/upstream/current/t/state/state.256
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/state/state.256 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/state/state.256 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,8 @@
+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
Added: packages/libdigest-sha-perl/branches/upstream/current/t/state/state.384
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/state/state.384 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/state/state.384 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,8 @@
+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
Added: packages/libdigest-sha-perl/branches/upstream/current/t/state/state.512
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/t/state/state.512 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/t/state/state.512 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,8 @@
+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
Added: packages/libdigest-sha-perl/branches/upstream/current/typemap
===================================================================
--- packages/libdigest-sha-perl/branches/upstream/current/typemap 2005-11-14 08:34:04 UTC (rev 1501)
+++ packages/libdigest-sha-perl/branches/upstream/current/typemap 2005-11-16 10:46:12 UTC (rev 1502)
@@ -0,0 +1,2 @@
+SHA * T_PTROBJ
+HMAC * T_PTROBJ
More information about the Pkg-perl-cvs-commits
mailing list