Digest-SHA-5.86/0000755000175000017500000000000012272467613013222 5ustar mshelormshelorDigest-SHA-5.86/examples/0000755000175000017500000000000012272467613015040 5ustar mshelormshelorDigest-SHA-5.86/examples/dups0000755000175000017500000000234112164252654015736 0ustar mshelormshelor#!perl # dups: simple script for showing duplicate files =head1 NAME dups - Show Duplicate Files =head1 SYNOPSIS Usage: dups files ... dups is a fast script for discovering duplicate files. It achieves its efficiency by comparing file digests rather than the file contents themselves, the latter being much larger in general. The NIST Secure Hash Algorithm (SHA) is highly collision-resistant, meaning that two files with the same SHA digest have an almost certain probability of being identical. The dups script works by computing the SHA-1 digest of each file and looking for matches. The search can reveal more than one set of duplicates, so the output is written as follows: match1_file1 match1_file2 match1_file3 etc. match2_file1 match2_file2 etc. =head1 AUTHOR Mark Shelor =head1 SEE ALSO Perl module L or L =cut use strict; use Digest::SHA; die "usage: dups files ...\n" unless @ARGV; my @files = grep { -f $_ } @ARGV; my %dups; for (@files) { my $digest = Digest::SHA->new->addfile($_, "b")->hexdigest; push(@{$dups{$digest}}, $_); } for (keys %dups) { my $ref = $dups{$_}; if (scalar(@$ref) > 1) { print join("\n\t", @$ref), "\n\n"; } } Digest-SHA-5.86/MANIFEST0000644000175000017500000000063412164252654014353 0ustar mshelormshelorChanges Makefile.PL MANIFEST META.yml README SHA.xs shasum examples/dups lib/Digest/SHA.pm src/sha.c src/sha.h src/sha64bit.c src/sha64bit.h t/allfcns.t t/base64.t t/bitbuf.t t/dumpload.t t/fips180-4.t t/fips198.t t/gg.t t/gglong.t t/hmacsha.t t/ireland.t t/methods.t t/nistbit.t t/nistbyte.t t/pod.t t/podcover.t t/rfc2202.t t/sha1.t t/sha224.t t/sha256.t t/sha384.t t/sha512.t t/unicode.t t/woodbury.t typemap Digest-SHA-5.86/Changes0000644000175000017500000005037212272467255014526 0ustar mshelormshelorRevision history for Perl extension Digest::SHA. 5.86 Thu Jan 30 08:24:28 MST 2014 - improved the performance of hexadecimal output functions -- ref. 'shahex' in src/sha.c -- thanks to Thomas Drugeon for ideas and test script 5.85 Wed Jun 26 04:05:26 MST 2013 - workaround for repeated calls to shaclose (ref. Bug #86295) -- need to explicitly reset internal pointer to NULL ref. shaclose() in SHA.xs - corrected typos in shasum script -- ref. Bug #85430 5.84 Sat Mar 9 17:36:08 MST 2013 - untweaked Makefile.PL to remove dependencies of SHA.c -- dependencies were breaking builds on VMS -- retaining dependencies provides too little benefit for cost of portable workaround 5.83 Mon Mar 4 08:12:00 MST 2013 - removed code for standalone C operation (no longer used) -- eliminates need for external symbols -- consolidates SHA and HMAC code -- reduces size of object files -- thanks to Marc Lehmann for suggestions - tweaked Makefile.PL to show dependencies of SHA.c 5.82 Thu Jan 24 04:54:12 MST 2013 - introduced workaround to SvPVbyte bug in Perl 5.6 -- module behavior now consistent under all Perls 5.6+ -- ref: new test script t/unicode.t -- SHA routines now always croak on wide chars (5.6+) - removed "static" message schedules from C code -- default "auto" is now just as fast -- thread-safe option (-t) no longer necessary -- still allowed, but ignored -- simplifies source and header files -- eliminates SHA_STO_CLASS and SHA_THREAD_SAFE -- ref. Bug #82784 -- thanks to Steve Hay for initial patch - provided documentation to describe Unicode handling -- ref: Bug #82378 - updated documentation of NIST statement on SHA-1 5.81 Mon Jan 14 05:17:08 MST 2013 - corrected load subroutine (SHA.pm) to prevent double-free -- Bug #82655: Security issue - segfault -- thanks to Victor Efimov and Nicholas Clark for technical expertise and suggestions 5.80 Mon Dec 10 14:15:26 MST 2012 - obtained noticeable speedup on Intel/gcc -- by setting -O1 and -fomit-frame-pointer -- SHA-1 about 63% faster, SHA-2 improves 11-20% 5.74 Sat Nov 24 03:10:18 MST 2012 - handle wide-string input by converting to bytes first -- viz. use SvPVbyte instead of SvPV in SHA.xs -- thanks to Eric Brine for summary and code 5.73 Wed Oct 31 04:32:44 MST 2012 - provided workaround for DEC compiler bug (ref. Makefile.PL) 5.72 Mon Sep 24 15:22:08 MST 2012 - adjusted module installation directory for later Perls -- As of 5.11 Perl searches 'site' first, so use that -- ref. INSTALLDIRS in Makefile.PL -- thanks to Robert Sedlacek for patch 5.71 Wed Feb 29 04:06:10 MST 2012 - prevented $! from getting clobbered in _bail() routine -- thanks to Zefram for patch - added example of BITS mode usage to shasum documentation 5.70 Wed Dec 14 02:32:10 MST 2011 - added BITS mode to addfile method and shasum -- partial-byte inputs now possible via files/STDIN -- allows shasum to check all 8074 NIST Msg vectors -- previously required special programming 5.63 Tue Nov 8 02:36:42 MST 2011 - added code to allow very large data inputs all at once -- previously limited to several hundred MB at a time -- many thanks to Thomas Drugeon for his elegant patch - removed outdated reference URLs from several test scripts -- these URLs aren't essential, and often go stale -- thanks to Leon Brocard for spotting this -- ref. rt.cpan.org #68740 5.62 Sat May 14 04:00:34 MST 2011 - removed unnecessary loading of MIME::Base64 module -- thanks to dolmen for pointing this out 5.61 Wed Mar 9 05:26:36 MST 2011 - corrected bug in 'algorithm' method - fixed -x option in Makefile.PL -- not often used since it deliberately excludes all 64-bit SHA transforms - addressed minor documentation oversights 5.60 Thu Mar 3 05:26:42 MST 2011 - added new SHA-512/224 and SHA-512/256 transforms -- ref. NIST Draft FIPS 180-4 (February 2011) - simplified shasum by removing duplicative text - improved efficiency of Addfile -- expensive -T test now occurs only in portable mode 5.50 Tue Dec 14 06:20:08 MST 2010 - adopted convention that '-' always means STDIN -- actual filename '-' accessed as './-' -- accords with behavior of sha1sum/md5sum - corrected undefined subroutine oversight in shasum -- inadvertent migration of _bail() from SHA.pm 5.49 Sun Dec 12 07:22:04 MST 2010 - modified Addfile to accept all POSIX filenames -- standard allows all characters except NUL and '/' - updated shasum to more closely mimic sha1sum/md5sum -- added "backslash processing" to handle newlines and backslashes in filenames -- now accepts all POSIX filenames via Addfile -- thanks to Sean Burke for identifying edge cases 5.48 Mon Jan 4 16:32:52 MST 2010 - fixed "shasum -a0" option (ref. rt.cpan.org #53319) -- incorrectly accepted 0 as a valid algorithm -- thanks to Zefram for patch - updated URL for NIST test vectors -- ref. files t/nistbit.t, t/nistbyte.t -- thanks to Leon Brocard for patch 5.47 Wed Apr 30 04:00:54 MST 2008 - modified Makefile.PL to install in core for Perls >= 5.10 -- thanks to Jerry Hedden for patch - changed from #include <> to #include "" in SHA.xs -- some platforms not able to find SHA source files -- thanks to Alexandr Ciornii for testing - moved .pm file to appropriate lib directory - minor addition to META.yml 5.46 Wed Apr 9 05:04:00 MST 2008 - modified Addfile to recognize leading and trailing whitespace in filenames (ref. rt.cpan.org #34690) - minor C source code modification (ref. hmac.c) - use const in sha.c for clean builds with -Wwrite-strings -- thanks to Robin Barker for patch 5.45 Tue Jun 26 02:36:00 MST 2007 - extended portability to earlier Perls -- works on Perl 5.003 and later -- thanks to Jim Doble for testing on legacy platforms - updated META.yml to conform to current META spec (1.3) - minor documentation fixes 5.44 Sat Oct 14 00:42:44 MST 2006 - removed SIGNATURE file from distribution -- spurious errors from CPANPLUS can break build - eliminated ppport.h header file -- significantly reduces size of distribution - modified C functions in src/hmac.c to use ANSI prototypes -- thanks to Jarkko Hietaniemi for patch 5.43 Sat Aug 5 02:36:18 MST 2006 - undid Perl Best Practice of favoring 3-argument "open" -- 3-arg version uses different semantics for "-" causing bugs in addfile and shasum - modified underlying C functions to use ANSI prototypes -- requested by Steve Hay (ref. Smoke [5.9.4] 28630) -- K&R style was causing numerous warnings from Borland compiler 5.42 Mon Jul 24 04:04:40 MST 2006 - minor code changes suggested by Perl::Critic -- e.g. no bareword filehandles, no 2-argument open's - updated public key (ref. B538C51C) -- previous one (0AF563FE) expired July 2, 2006 - added documentation to warn that Base64 digests are NOT padded -- padding must be done by user if interoperability with other software is required 5.41 Sat Jun 3 01:50:46 MST 2006 - corrected addfile -- process $file argument as a filehandle unless passed as a SCALAR (which indicates a file name) 5.40 Fri Jun 2 04:00:30 MST 2006 - modified addfile to accept indirect filehandles -- ref. rt.cpan.org #19627 and #19641 5.39 Sun May 28 03:22:24 MST 2006 - modified shasum to warn rather than die for file errors -- to follow conventions of GNU sha1sum/md5sum 5.38 Thu May 25 02:02:02 MST 2006 - added new capabilities to the "addfile" method -- now able to accept file names as well as handles -- includes mode for portable digest calculation -- thanks to Adam Kennedy for emails and ideas ref. File::LocalizeNewlines - used expanded addfile interface to simplify shasum (sumfile) -- regex a tad less general than 5.37, but handles all known newline variants in UNIX/Windows/MacOS - enhanced WARNING messages from shasum checkfile processing -- to mimic behavior of md5sum 5.37 Mon May 8 04:30:09 MST 2006 - modified shasum to avoid file slurping (ref. sub sumfile) - improved error handling of checksum files in shasum -- to better mimic the behavior of md5sum - refined line-break regex in shasum (ref. sub sumfile) -- catches multiple CR's preceding LF thanks to Gisle Aas for suggested patch - changed loop vars to signed int's in shadump (ref. src/sha.c) -- to prevent type mismatch warnings 5.36 Mon May 8 01:38:36 MST 2006 - fixed the "portable" option in shasum -- normalize line-breaks in text files only 5.35 Thu May 4 16:54:42 MST 2006 - added "portable" option to shasum -- to make digests match across Windows/Unix/MacOS - enabled bundling of shasum command line options -- to mimic behavior of md5sum - removed \r's from text files in t/nist directory -- resolves SIGNATURE clashes (rt.cpan.org #18983) - changed suffix on SHA64_MAX (src/sha.h) to ULL -- eliminates gcc warnings (rt.cpan.org #18988) - specified minimum Perl version for module and Makefile.PL -- closes rt.cpan.org #18984 5.34 Thu Feb 2 18:55:40 MST 2006 - removed Unix-style pathnames in test scripts -- causing problems on OpenVMS -- thanks to Steve Peters for patch - included latest version of Perl Portability header (ppport.h) - added PERL_CORE check to test scripts -- allows module to be built into Perl distribution 5.32 Fri Dec 2 02:32:20 MST 2005 - added POD section to shasum script -- thanks to Gunnar Wolf for patch - made minor code changes to silence compiler warnings -- resulting from signed/unsigned integer mixing - inserted code in test scripts for POD checking -- to recover gracefully if Test::More isn't installed 5.31 Mon Sep 5 00:52:42 MST 2005 - added standard tests for pod and pod-coverage checking - inserted subtest to check for failure when using unrecognized SHA algorithm 5.30 Sat Aug 20 16:46:08 MST 2005 - updated docs with recent NIST statement on SHA-1 -- advises use of larger and stronger hash functions (i.e. SHA-224/256/384/512) for new developments 5.29 Sun Aug 14 04:48:34 MST 2005 - added explicit casts in "shaload" routine (ref. "ldvals") -- thanks to E. Allen Smith for pointing out SGI compiler warnings on IPxx-irix platforms - updated docs with cautionary note about SHA-1 5.28 Wed Nov 10 15:33:20 MST 2004 - provided more flexible formatting of SHA state files -- entries may now contain embedded whitespace for improved readability - minor code cleanups 5.27 Sun Oct 24 02:54:00 MST 2004 - minor code cleanups -- reduces size of dump files for SHA-1/224/256 5.26 Thu Oct 7 14:52:00 MST 2004 - streamlined distribution -- reduced NIST vector tests from 200 to 20 -- former number was overkill -- distro now downloads and builds more quickly - rewrote SYNOPSIS sections in pod file - made additional tweaks to t/8-shasum.t for portability - cleaned up test scripts 5.25 Sun Sep 12 18:48:00 MST 2004 - removed non-essential test script -- t/8-shasum.t causes problems on sparc64-linux - reverted to using eval "require $module" in shasum 5.24 Sun Sep 12 02:50:18 MST 2004 - modified shasum to use barewords in "require" statements -- ref. perl.cpan.testers (157305) 5.23 Thu Sep 9 23:06:18 MST 2004 - corrected bug in test script -- use blib when invoking perl as an external command in t/8-shasum.t 5.22 Tue Sep 7 19:12:40 MST 2004 - broadened SHA-384/512 support -- to compilers with no ULLONG_MAX in limits.h -- e.g IBM C (xlC 6.0.0) on AIX 4.3.3 -- thanks to Chris Carey for suggestions and technical expertise - improved use of static storage class in transforms -- detection of Intel arch. now done in Makefile.PL -- NB: static not used if compiling for thread safety - minor changes to documentation 5.21 Mon Aug 23 04:02:00 MST 2004 - removed 64-bit constant expressions from #if statements -- ref. src/sha.h (lines 55, 58, and 61) -- even if compiler supports long long's, preprocessor may use long's when evaluating expressions - improved test script for "shasum" (t/8-shasum.t) -- exercises check file option (-c) 5.20 Sun Aug 15 04:24:48 MST 2004 - introduced "shasum" script -- mimics the usage and behavior of "md5sum" -- adds "-a" option to select SHA algorithm -- for help, just type "shasum -h" 5.10 Fri Aug 6 02:04:38 MST 2004 - simplified module documentation -- made it consistent with Digest::SHA::PurePerl docs 5.03 Sat Jul 31 00:00:48 MST 2004 - corrected HMAC-SHA-384/512 bug (cpan #7181, Adam Woodbury) -- code was using hardwired blocksize for SHA-1/256 -- ref. src/hmac.c, src/hmac.h 5.02 Thu Jul 29 02:48:00 MST 2004 - updated documentation and "dump-load.t" test script -- to be consistent with Digest::SHA::PurePerl - included a SIGNATURE file -- for stronger authentication of module contents -- ref. Module::Signature on CPAN - corrected embarrassing misspelling in docs -- apologies to Gisle Aas 5.01 Fri May 21 13:08:12 MST 2004 - check for undefined SHA handle when calling "shaclose()" -- prevents intermittent cleanup errors during global object destruction 5.00 Fri May 14 04:45:00 MST 2004 - minor documentation fixes - restored classical style of version numbering (X.YZ) -- previous X.Y.Z style caused installation difficulties when using CPANPLUS 4.3.3 Wed May 5 00:30:40 MST 2004 - fixed bug in "strto64()" function -- caused problems in state files with CR/LF pairs -- thanks to Martin Thurn for testing support 4.3.2 Wed Apr 28 03:56:00 MST 2004 - added Makefile.PL options -- thread-safety: -t -- exclude 384/512 support: -x -- e.g. perl Makefile.PL -t - temporarily suppress dump/load tests for SHA-384/512 -- pending clarification of problem on sun4u sparc 4.3.1 Thu Mar 4 02:54:00 MST 2004 - removed unused functions from XS file -- reduces size of compiled objects - simplified implementation of Digest::SHA object -- now a blessed SHAPtr ref instead of blessed array ref -- results in slight speed-up of OO operations - streamlined underlying C source -- used macros to consolidate repetitive code - rewrote test scripts to depend on Test rather than Test::More -- allows module to be checked in minimal Perl environments - added compilation option for thread-safety -- overrides use of static arrays 4.3.0 Sat Feb 7 02:58:00 MST 2004 - included SHA-384/512 support if using Microsoft C/C++ -- uses MSVC's __int64 in place of "long long" - enhanced portability and efficiency on diverse platforms -- automatically sets up optimal types for 32/64-bit ops - improved test scripts for better reporting -- many thanks to Alex Muntada for helpful suggestions 4.2.2 Sat Jan 31 17:10:20 MST 2004 - repaired 32-bit SHA operations for 8-byte longs 4.2.1 Sat Jan 24 00:56:54 MST 2004 - modified I/O and memory management in underlying C code -- uses Perl libraries when compiled as CPAN module -- otherwise defaults to ANSI C libraries -- bypasses problems in MSWin multi-threaded Perls -- avoids "Free to wrong pool" error -- special thanks to Robert Gilmour and Brian Gladman for technical guidance and testing 4.2.0 Sat Dec 27 16:08:00 MST 2003 - added support for recently-announced SHA-224 algorithm -- ref. FIPS 180-2 Change Notice 1 -- also includes HMAC-SHA-224 4.1.0 Thu Dec 25 00:58:00 MST 2003 - repaired "nist-vectors" test scripts for MSWin32 portability -- use binmode for data files 4.0.9 Wed Dec 24 02:58:22 MST 2003 - use canonical file specs in test scripts -- enhances portability across different OSes - modify type declarations of objects in XS file -- re-declare as (SV *) and cast to (AV *) SvRV(self) -- in response to AVPtr problem on MSWin32 4.0.8 Thu Dec 18 23:32:00 MST 2003 - inherits from Digest::base if installed -- also checks for MIME::Base64 -- still fully-functional if neither are installed - added buffer overflow protection in underlying C code -- ref. shahex() and shabase64() routines -- prior code appeared impossible to exploit, but ... -- better safe than sorry -- does not impact runtime efficiency - minor code cleanup 4.0.7 Sat Dec 13 00:48:24 MST 2003 - check for undefined SHA handle when calling "shaclose()" -- was causing cleanup err during global destruction 4.0.6 Thu Dec 11 02:18:00 MST 2003 - more optimization and streamlining -- a bit faster on non-big-endians (e.g. Intel) - rewrote time-critical functions and methods in XS - removed unused C functions from source files 4.0.5 Sat Dec 6 00:02:24 MST 2003 - performance optimizations -- rewrote "add" method in XS -- unrolled loops in sha256 transform 4.0.4 Thu Dec 4 00:07:00 MST 2003 - made Digest::SHA into a self-contained module -- no longer depends on Digest::base -- more convenient for users -- no need to install Digest:: module 4.0.3 Wed Dec 3 00:01:20 MST 2003 - Digest::SHA now a subclass of Digest::base -- inherits hexdigest/b64digest/addfile methods - added "hashsize" method - removed old "shaopen()/shawrite()/..." legacy code -- in favor of standard, streamlined OO interface - renamed test vector files from NIST -- prevents problems on 8+3 filesystems - added test for Dave Ireland's SHA-256 vector 4.0.0 Sat Nov 29 21:14:09 MST 2003 - major streamlining of interface (hence, major version change) -- coordinated with Gisle Aas and J. Duque -- goal is to produce a single SHA module -- adheres to OO and functional styles of Digest:: -- greatly reduces the number of interface functions -- old functions still supported -- use Digest::SHA ':legacy' -- will be deprecated in near future - rewrote all test scripts to match new interface -- very easy to modify all 281 tests -- old interface maps cleanly to new one 3.0 Wed Nov 26 05:02:34 MST 2003 - added functions that conform to Digest:: interface -- both functional and OO styles -- byte-oriented data only -- continue to support original interface as well -- necessary for bit-oriented data - supplied formal test vectors for HMAC-SHA-256 -- from draft-ietf-ipsec-ciph-sha-256-01.txt - included tests for all OO methods 2.4 Sat Nov 22 17:10:22 MST 2003 - code cleanup -- "sha.c" now completely free of #ifdef's - modularized all 64-bit (long long) code - improved readability of header files - simplified logic of "fixdump" utility 2.3 Wed Nov 19 03:54:31 MST 2003 - minor optimizations and code cleanup -- improved maintainability by reducing #ifdef's -- sha1 transform code now easier to follow - streamlined shadump/shaload file format -- eliminated special "HQ" entry -- state now held in "H" for all transforms -- supplied "fixdump" utility to convert old format - SHA-384/512 functions now return NULL for no 64-bit operations -- previously they were undefined -- no longer necessary to use eval's to test for presence 2.2 Sun Nov 16 01:54:00 MST 2003 - optimized the performance of the SHA-1 transform -- around 20-30% faster than previous version -- achieved by loop unrolling and assignment consolidation - enhanced shaload/shadump to allow interaction with stdin/stdout -- "$filename" argument now optional 2.1 Sun Nov 9 03:28:04 MST 2003 - simplified data input routines -- length argument now optional for byte data (special thanks to Jeffrey Friedl for this idea) -- interface still compatible with earlier versions -- changes will not affect existing client code - streamlined underlying C code for easier maintenance - provided additional tests for persistent data 2.0 Sat Nov 1 03:55:36 MST 2003 - added functions for HMAC-SHA-1/256/384/512 (FIPS PUB 198) - shadump/shaload files now compatible between 32/64-bit machines 1.01 Sat Oct 25 02:44:55 MST 2003 - package now downloads and installs much faster - reduced distribution size by 80% -- pruned extensive NIST vectors to a useful subset -- still possible to test all vectors if desired --- see "t/nist/COPYRIGHT" file for details - added routines to provide persistent storage of SHA states -- shadump() and shaload() - reduced runtime of large bitstring tests (gillogly-hard) -- illustrates usefulness of shadump()/shaload() 1.0 Sat Oct 18 17:35:07 MST 2003 - documentation fixes - code cleanup: no more compiler warnings from gcc -Wall - added code to allow reading of intermediate digest state -- shahex() prior to shafinish() returns current state 0.9 Thu Oct 9 20:43:54 MST 2003 - version updated to reflect portability check and passing of all tests (1401) 0.01 Wed Oct 8 22:28:05 2003 - original version; created by h2xs 1.22 with options -x -A -n Digest::SHA sha.h Digest-SHA-5.86/Makefile.PL0000644000175000017500000000224712164252654015176 0ustar mshelormshelorrequire 5.003000; use strict; use ExtUtils::MakeMaker; use Getopt::Std; use Config qw(%Config); my $PM = 'lib/Digest/SHA.pm'; my %opts; getopts('tx', \%opts); # -t is no longer used, but allow it anyway my @defines; push(@defines, '-DSHA_PerlIO') if $] >= 5.004; push(@defines, '-DNO_SHA_384_512') if $opts{'x'}; my $define = join(' ', @defines); # Workaround for DEC compiler bug, adapted from Digest::MD5 my @extra = (); if ($^O eq 'VMS') { if (defined($Config{ccname})) { if (grep(/VMS_VAX/, @INC) && ($Config{ccname} eq 'DEC')) { # VAX compiler optimizer even up to v6.4 gets stuck push(@extra, OPTIMIZE => "/Optimize=(NODISJOINT)"); } } } # Enhance performance on Intel when using gcc if ($Config{archname} =~ /^i[3456]86/ && $Config{ccname} eq 'gcc') { push(@extra, OPTIMIZE => '-O1 -fomit-frame-pointer'); } my %att = ( 'NAME' => 'Digest::SHA', 'VERSION_FROM' => $PM, 'LIBS' => [''], 'DEFINE' => $define, 'INC' => '-I.', 'EXE_FILES' => [ 'shasum' ], 'INSTALLDIRS' => ($] >= 5.010 and $] < 5.011) ? 'perl' : 'site', @extra, ); my $MMversion = $ExtUtils::MakeMaker::VERSION || 0; $att{NO_META} = 1 unless $MMversion < 6.10_03; WriteMakefile(%att); Digest-SHA-5.86/lib/0000755000175000017500000000000012272467613013770 5ustar mshelormshelorDigest-SHA-5.86/lib/Digest/0000755000175000017500000000000012272467613015207 5ustar mshelormshelorDigest-SHA-5.86/lib/Digest/SHA.pm0000644000175000017500000004770312272467255016175 0ustar mshelormshelorpackage Digest::SHA; require 5.003000; use strict; use vars qw($VERSION @ISA @EXPORT @EXPORT_OK); use Fcntl; use integer; $VERSION = '5.86'; require Exporter; require DynaLoader; @ISA = qw(Exporter DynaLoader); @EXPORT_OK = qw( hmac_sha1 hmac_sha1_base64 hmac_sha1_hex hmac_sha224 hmac_sha224_base64 hmac_sha224_hex hmac_sha256 hmac_sha256_base64 hmac_sha256_hex hmac_sha384 hmac_sha384_base64 hmac_sha384_hex hmac_sha512 hmac_sha512_base64 hmac_sha512_hex hmac_sha512224 hmac_sha512224_base64 hmac_sha512224_hex hmac_sha512256 hmac_sha512256_base64 hmac_sha512256_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 sha512224 sha512224_base64 sha512224_hex sha512256 sha512256_base64 sha512256_hex); # If possible, inherit from Digest::base eval { require Digest::base; push(@ISA, 'Digest::base'); }; *addfile = \&Addfile; *hexdigest = \&Hexdigest; *b64digest = \&B64digest; # The following routines aren't time-critical, so they can be left in Perl sub new { my($class, $alg) = @_; $alg =~ s/\D+//g if defined $alg; if (ref($class)) { # instance method unless (defined($alg) && ($alg != $class->algorithm)) { sharewind($$class); return($class); } if ($$class) { shaclose($$class); $$class = undef } return unless $$class = shaopen($alg); 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; if ($$self) { shaclose($$self); $$self = undef } } 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); } $nbits = length($data) * 8 if $nbits > length($data) * 8; shawrite($data, $nbits, $$self); return($self); } sub _bail { my $msg = shift; $msg .= ": $!"; require Carp; Carp::croak($msg); } sub _addfile { # this is "addfile" from Digest::base 1.00 my ($self, $handle) = @_; my $n; my $buf = ""; while (($n = read($handle, $buf, 4096))) { $self->add($buf); } _bail("Read failed") unless defined $n; $self; } sub Addfile { my ($self, $file, $mode) = @_; return(_addfile($self, $file)) unless ref(\$file) eq 'SCALAR'; $mode = defined($mode) ? $mode : ""; my ($binary, $portable, $BITS) = map { $_ eq $mode } ("b", "p", "0"); ## Always interpret "-" to mean STDIN; otherwise use ## sysopen to handle full range of POSIX file names local *FH; $file eq '-' and open(FH, '< -') or sysopen(FH, $file, O_RDONLY) or _bail('Open failed'); if ($BITS) { my ($n, $buf) = (0, ""); while (($n = read(FH, $buf, 4096))) { $buf =~ s/[^01]//g; $self->add_bits($buf); } _bail("Read failed") unless defined $n; close(FH); return($self); } binmode(FH) if $binary || $portable; unless ($portable && -T $file) { $self->_addfile(*FH); close(FH); return($self); } my ($n1, $n2); my ($buf1, $buf2) = ("", ""); while (($n1 = read(FH, $buf1, 4096))) { while (substr($buf1, -1) eq "\015") { $n2 = read(FH, $buf2, 4096); _bail("Read failed") unless defined $n2; last unless $n2; $buf1 .= $buf2; } $buf1 =~ s/\015?\015\012/\012/g; # DOS/Windows $buf1 =~ s/\015/\012/g; # early MacOS $self->add($buf1); } _bail("Read failed") unless defined $n1; close(FH); $self; } sub dump { my $self = shift; my $file = shift; $file = "" unless defined $file; shadump($file, $$self) || return; return($self); } sub load { my $class = shift; my $file = shift; $file = "" unless defined $file; if (ref($class)) { # instance method if ($$class) { shaclose($$class); $$class = undef } return unless $$class = shaload($file); return($class); } my $state = shaload($file) || return; my $self = \$state; bless($self, $class); return($self); } Digest::SHA->bootstrap($VERSION); 1; __END__ =head1 NAME Digest::SHA - Perl extension for SHA-1/224/256/384/512 =head1 SYNOPSIS In programs: # Functional interface use Digest::SHA qw(sha1 sha1_hex sha1_base64 ...); $digest = sha1($data); $digest = sha1_hex($data); $digest = sha1_base64($data); $digest = sha256($data); $digest = sha384_hex($data); $digest = sha512_base64($data); # Object-oriented use Digest::SHA; $sha = Digest::SHA->new($alg); $sha->add($data); # feed data into stream $sha->addfile(*F); $sha->addfile($filename); $sha->add_bits($bits); $sha->add_bits($data, $nbits); $sha_copy = $sha->clone; # if needed, make copy of $sha->dump($file); # current digest state, $sha->load($file); # or save it on disk $digest = $sha->digest; # compute digest $digest = $sha->hexdigest; $digest = $sha->b64digest; From the command line: $ shasum files $ shasum --help =head1 SYNOPSIS (HMAC-SHA) # Functional interface only use Digest::SHA qw(hmac_sha1 hmac_sha1_hex ...); $digest = hmac_sha1($data, $key); $digest = hmac_sha224_hex($data, $key); $digest = hmac_sha256_base64($data, $key); =head1 ABSTRACT Digest::SHA is a complete implementation of the NIST Secure Hash Standard. It gives Perl programmers a convenient way to calculate SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, and SHA-512/256 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 module. The programming interface is easy to use: it's the same one found in CPAN's L module. So, if your applications currently use L 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 is not a multiple of 8, use the I 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, 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 method generates portable, human-readable text describing the current state of computation. You can subsequently retrieve the file with I 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, I, and I 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 UNICODE AND SIDE EFFECTS Perl supports Unicode strings as of version 5.6. Such strings may contain wide characters, namely, characters whose ordinal values are greater than 255. This can cause problems for digest algorithms such as SHA that are specified to operate on sequences of bytes. The rule by which Digest::SHA handles a Unicode string is easy to state, but potentially confusing to grasp: the string is interpreted as a sequence of byte values, where each byte value is equal to the ordinal value (viz. code point) of its corresponding Unicode character. That way, the Unicode string 'abc' has exactly the same digest value as the ordinary string 'abc'. Since a wide character does not fit into a byte, the Digest::SHA routines croak if they encounter one. Whereas if a Unicode string contains no wide characters, the module accepts it quite happily. The following code illustrates the two cases: $str1 = pack('U*', (0..255)); print sha1_hex($str1); # ok $str2 = pack('U*', (0..256)); print sha1_hex($str2); # croaks Be aware that the digest routines silently convert UTF-8 input into its equivalent byte sequence in the native encoding (cf. utf8::downgrade). This side effect influences only the way Perl stores the data internally, but otherwise leaves the actual value of the data intact. =head1 NIST STATEMENT ON SHA-1 NIST acknowledges that the work of Prof. Xiaoyun Wang constitutes a practical collision attack on SHA-1. Therefore, NIST encourages the rapid adoption of the SHA-2 hash functions (e.g. SHA-256) for applications requiring strong collision resistance, such as digital signatures. ref. L =head1 PADDING OF BASE64 DIGESTS By convention, CPAN Digest modules do B pad their Base64 output. Problems can occur when feeding such digests to other software that expects properly padded Base64 encodings. For the time being, any necessary padding must be done by the user. Fortunately, this is a simple operation: if the length of a Base64-encoded digest isn't a multiple of 4, simply append "=" characters to the end of the digest until it is: while (length($b64_digest) % 4) { $b64_digest .= '='; } To illustrate, I is computed to be ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0 which has a length of 43. So, the properly padded version is ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0= =head1 EXPORT None by default. =head1 EXPORTABLE FUNCTIONS Provided your C compiler supports a 64-bit type (e.g. the I 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 =over 4 =item B =item B =item B =item B =item B =item B =item B 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 =item B =item B =item B =item B =item B =item B 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 =item B =item B =item B =item B =item B =item B Logically joins the arguments into a single string, and returns its SHA-1/224/256/384/512 digest encoded as a Base64 string. It's important to note that the resulting string does B contain the padding characters typical of Base64 encodings. This omission is deliberate, and is done to maintain compatibility with the family of CPAN Digest modules. See L for details. =back I =over 4 =item B Returns a new Digest::SHA object. Allowed values for I<$alg> are 1, 224, 256, 384, 512, 512224, or 512256. 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 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 This method has exactly the same effect as I. In fact, I is just an alias for I. =item B Returns the number of digest bits for this object. The values are 160, 224, 256, 384, 512, 224, and 256 for SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 and SHA-512/256, respectively. =item B Returns the digest algorithm for this object. The values are 1, 224, 256, 384, 512, 512224, and 512256 for SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, and SHA-512/256, respectively. =item B Returns a duplicate copy of the object. =item B 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 =item B 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 Reads from I until EOF, and appends that data to the current state. The return value is the updated object itself. =item B Reads the contents of I<$filename>, and appends that data to the current state. The return value is the updated object itself. By default, I<$filename> is simply opened and read; no special modes or I/O disciplines are used. To change this, set the optional I<$mode> argument to one of the following values: "b" read file in binary mode "p" use portable mode "0" use BITS mode The "p" mode ensures that the digest value of I<$filename> will be the same when computed on different operating systems. It accomplishes this by internally translating all newlines in text files to UNIX format before calculating the digest. Binary files are read in raw mode with no translation whatsoever. The BITS mode ("0") interprets the contents of I<$filename> as a logical stream of bits, where each ASCII '0' or '1' character represents a 0 or 1 bit, respectively. All other characters are ignored. This provides a convenient way to calculate the digest values of partial-byte data by using files, rather than having to write programs using the I method. =item B 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 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 Returns the digest encoded as a binary string. Note that the I 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-Eclone-Edigest> if it's necessary to preserve the original digest state. =item B Returns the digest encoded as a hexadecimal string. Like I, this method is a read-once operation. Call I<$sha-Eclone-Ehexdigest> if it's necessary to preserve the original digest state. This method is inherited if L is installed on your system. Otherwise, a functionally equivalent substitute is used. =item B Returns the digest encoded as a Base64 string. Like I, this method is a read-once operation. Call I<$sha-Eclone-Eb64digest> if it's necessary to preserve the original digest state. This method is inherited if L is installed on your system. Otherwise, a functionally equivalent substitute is used. It's important to note that the resulting string does B contain the padding characters typical of Base64 encodings. This omission is deliberate, and is done to maintain compatibility with the family of CPAN Digest modules. See L for details. =back I =over 4 =item B =item B =item B =item B =item B =item B =item B 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 =item B =item B =item B =item B =item B =item B 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 =item B =item B =item B =item B =item B =item B Returns the HMAC-SHA-1/224/256/384/512 digest of I<$data>/I<$key>, with the result encoded as a Base64 string. Multiple I<$data> arguments are allowed, provided that I<$key> is the last argument in the list. It's important to note that the resulting string does B contain the padding characters typical of Base64 encodings. This omission is deliberate, and is done to maintain compatibility with the family of CPAN Digest modules. See L for details. =back =head1 SEE ALSO L, L The Secure Hash Standard (Draft FIPS PUB 180-4) can be found at: L The Keyed-Hash Message Authentication Code (HMAC): L =head1 AUTHOR Mark Shelor =head1 ACKNOWLEDGMENTS The author is particularly grateful to Gisle Aas Sean Burke Chris Carey Alexandr Ciornii Jim Doble Thomas Drugeon Julius Duque Jeffrey Friedl Robert Gilmour Brian Gladman Adam Kennedy Andy Lester Alex Muntada Steve Peters Chris Skiscim Martin Thurn Gunnar Wolf Adam Woodbury "who by trained skill rescued life from such great billows and such thick darkness and moored it in so perfect a calm and in so brilliant a light" - Lucretius =head1 COPYRIGHT AND LICENSE Copyright (C) 2003-2014 Mark Shelor This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. L =cut Digest-SHA-5.86/README0000644000175000017500000000226312272467255014107 0ustar mshelormshelorDigest::SHA version 5.86 ======================== 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, SHA-512, SHA-512/224, and SHA-512/256 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 NOTE: Option -t is still allowed but no longer necessary. DEPENDENCIES None COPYRIGHT AND LICENSE Copyright (C) 2003-2014 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 Digest-SHA-5.86/shasum0000755000175000017500000002046712272467255014463 0ustar mshelormshelor#!perl -w ## shasum: filter for computing SHA digests (ref. sha1sum/md5sum) ## ## Copyright (C) 2003-2014 Mark Shelor, All Rights Reserved ## ## Version: 5.86 ## Thu Jan 30 08:24:28 MST 2014 ## shasum SYNOPSIS adapted from GNU Coreutils sha1sum. ## Add an "-a" option for algorithm selection, a "-p" ## option for portable digest computation, and a "-0" ## option for reading bit strings. my $POD = <<'END_OF_POD'; =head1 NAME shasum - Print or Check SHA Checksums =head1 SYNOPSIS Usage: shasum [OPTION]... [FILE]... Print or check SHA checksums. With no FILE, or when FILE is -, read standard input. -a, --algorithm 1 (default), 224, 256, 384, 512, 512224, 512256 -b, --binary read in binary mode -c, --check read SHA sums from the FILEs and check them -t, --text read in text mode (default) -p, --portable read in portable mode produces same digest on Windows/Unix/Mac -0, --01 read in BITS mode ASCII '0' interpreted as 0-bit, ASCII '1' interpreted as 1-bit, all other characters ignored The following two options are useful only when verifying checksums: -s, --status don't output anything, status code shows success -w, --warn warn about improperly formatted checksum lines -h, --help display this help and exit -v, --version output version information and exit When verifying SHA-512/224 or SHA-512/256 checksums, indicate the algorithm explicitly using the -a option, e.g. shasum -a 512224 -c checksumfile The sums are computed as described in FIPS-180-4. 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, `?' for portable, `^' for BITS), and name for each FILE. Report shasum bugs to mshelor@cpan.org =head1 DESCRIPTION Running I is often the quickest way to compute SHA message digests. The user simply feeds data to the script through files or standard input, and then collects the results from standard output. The following command shows how to compute digests for typical inputs such as the NIST test vector "abc": perl -e "print qq(abc)" | shasum Or, if you want to use SHA-256 instead of the default SHA-1, simply say: perl -e "print qq(abc)" | shasum -a 256 Since I mimics the behavior of the combined GNU I, I, I, I, and I programs, you can install this script as a convenient drop-in replacement. Unlike the GNU programs, I encompasses the full SHA standard by allowing partial-byte inputs. This is accomplished through the BITS option (I<-0>). The following example computes the SHA-224 digest of the 7-bit message I<0001100>: perl -e "print qq(0001100)" | shasum -0 -a 224 =head1 AUTHOR Copyright (c) 2003-2014 Mark Shelor . =head1 SEE ALSO I is implemented using the Perl module L or L. =cut END_OF_POD use strict; use Fcntl; use Getopt::Long; my $VERSION = "5.86"; ## Try to use Digest::SHA. If not installed, use the slower ## but functionally equivalent 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 $@; } sub usage { my($err, $msg) = @_; $msg = "" unless defined $msg; if ($err) { warn($msg . "Type shasum -h for help\n"); exit($err); } my($USAGE) = $POD =~ /SYNOPSIS\n\n(.+)\n=head1 DESCRIPTION\n/sm; $USAGE =~ s/^ //gm; print $USAGE; exit($err); } ## Sync stdout and stderr by forcing a flush after every write select((select(STDOUT), $| = 1)[0]); select((select(STDERR), $| = 1)[0]); ## Collect options from command line my ($alg, $binary, $check, $text, $status, $warn, $help, $version); my ($portable, $BITS); eval { Getopt::Long::Configure ("bundling") }; GetOptions( 'b|binary' => \$binary, 'c|check' => \$check, 't|text' => \$text, 'a|algorithm=i' => \$alg, 's|status' => \$status, 'w|warn' => \$warn, 'h|help' => \$help, 'v|version' => \$version, 'p|portable' => \$portable, '0|01' => \$BITS ) or usage(1, ""); ## Deal with help requests and incorrect uses usage(0) if $help; usage(1, "shasum: Ambiguous file mode\n") if scalar(grep {defined $_} ($binary, $portable, $text, $BITS)) > 1; usage(1, "shasum: --warn option used only when verifying checksums\n") if $warn && !$check; usage(1, "shasum: --status option used only when verifying checksums\n") if $status && !$check; ## Default to SHA-1 unless overridden by command line option $alg = 1 unless defined $alg; grep { $_ == $alg } (1, 224, 256, 384, 512, 512224, 512256) or usage(1, "shasum: Unrecognized algorithm\n"); ## Display version information if requested if ($version) { print "$VERSION\n"; exit(0); } ## Try to figure out if the OS is DOS-like. If it is, ## default to binary mode when reading files, unless ## explicitly overridden by command line "--text" or ## "--portable" options. my $isDOSish = ($^O =~ /^(MSWin\d\d|os2|dos|mint|cygwin)$/); if ($isDOSish) { $binary = 1 unless $text || $portable } my $modesym = $binary ? '*' : ($portable ? '?' : ($BITS ? '^' : ' ')); ## Read from STDIN (-) if no files listed on command line @ARGV = ("-") unless @ARGV; ## sumfile($file): computes SHA digest of $file sub sumfile { my $file = shift; my $mode = $portable ? 'p' : ($binary ? 'b' : ($BITS ? '0' : '')); my $digest = eval { $module->new($alg)->addfile($file, $mode) }; if ($@) { warn "shasum: $file: $!\n"; return } $digest->hexdigest; } ## %len2alg: maps hex digest length to SHA algorithm my %len2alg = (40 => 1, 56 => 224, 64 => 256, 96 => 384, 128 => 512); $len2alg{56} = 512224 if $alg == 512224; $len2alg{64} = 512256 if $alg == 512256; ## unescape: convert backslashed filename to plain filename sub unescape { $_ = shift; s/\\\\/\0/g; s/\\n/\n/g; return if /\\/; s/\0/\\/g; return $_; } ## verify: confirm the digest values in a checksum file sub verify { my $checkfile = shift; my ($err, $fmt_errs, $read_errs, $match_errs) = (0, 0, 0, 0); my ($num_lines, $num_files) = (0, 0); my ($bslash, $sum, $fname, $rsp, $digest); local *FH; $checkfile eq '-' and open(FH, '< -') and $checkfile = 'standard input' or sysopen(FH, $checkfile, O_RDONLY) or die "shasum: $checkfile: $!\n"; while () { next if /^#/; s/\n$//; s/^[ \t]+//; $num_lines++; $bslash = s/^\\//; ($sum, $modesym, $fname) = /^([\da-fA-F]+)[ \t]([ *?^])([^\0]*)/; $alg = defined $sum ? $len2alg{length($sum)} : undef; $fname = unescape($fname) if defined $fname && $bslash; if (grep { ! defined $_ } ($alg, $sum, $modesym, $fname)) { $alg = 1 unless defined $alg; warn("shasum: $checkfile: $.: improperly " . "formatted SHA$alg checksum line\n") if $warn; $fmt_errs++; next; } $fname =~ s/\r$// unless -e $fname; $rsp = "$fname: "; $num_files++; ($binary, $portable, $text, $BITS) = map { $_ eq $modesym } ('*', '?', ' ', '^'); unless ($digest = sumfile($fname)) { $rsp .= "FAILED open or read\n"; $err = 1; $read_errs++; } else { if (lc($sum) eq $digest) { $rsp .= "OK\n" } else { $rsp .= "FAILED\n"; $err = 1; $match_errs++ } } print $rsp unless $status; } close(FH); unless ($num_files) { $alg = 1 unless defined $alg; warn("shasum: $checkfile: no properly formatted " . "SHA$alg checksum lines found\n"); $err = 1; } elsif (! $status) { warn("shasum: WARNING: $fmt_errs line" . ($fmt_errs>1? 's are':' is') . " improperly formatted\n") if $fmt_errs; warn("shasum: WARNING: $read_errs listed file" . ($read_errs>1?'s':'') . " could not be read\n") if $read_errs; warn("shasum: WARNING: $match_errs computed checksum" . ($match_errs>1?'s':'') . " did NOT match\n") if $match_errs; } return($err == 0); } ## Verify or compute SHA checksums of requested files my($file, $digest); my $STATUS = 0; for $file (@ARGV) { if ($check) { $STATUS = 1 unless verify($file) } elsif ($digest = sumfile($file)) { if ($file =~ /[\n\\]/) { $file =~ s/\\/\\\\/g; $file =~ s/\n/\\n/g; $digest = "\\$digest"; } print "$digest $modesym", "$file\n"; } else { $STATUS = 1 } } exit($STATUS) Digest-SHA-5.86/SHA.xs0000644000175000017500000001156312164252654014214 0ustar mshelormshelor#include "EXTERN.h" #include "perl.h" #include "XSUB.h" #ifdef SvPVbyte #if PERL_REVISION == 5 && PERL_VERSION < 8 #undef SvPVbyte #define SvPVbyte(sv, lp) \ (sv_utf8_downgrade((sv), 0), SvPV((sv), (lp))) #endif #else #define SvPVbyte SvPV #endif #include "src/sha.c" static int ix2alg[] = {1,1,1,224,224,224,256,256,256,384,384,384,512,512,512, 512224,512224,512224,512256,512256,512256}; MODULE = Digest::SHA PACKAGE = Digest::SHA PROTOTYPES: ENABLE #ifndef INT2PTR #define INT2PTR(p, i) (p) (i) #endif #define MAX_WRITE_SIZE 16384 int shaclose(s) SHA * s CODE: RETVAL = shaclose(s); sv_setiv(SvRV(ST(0)), 0); 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 Digest::SHA::sha512224 = 15 Digest::SHA::sha512224_hex = 16 Digest::SHA::sha512224_base64 = 17 Digest::SHA::sha512256 = 18 Digest::SHA::sha512256_hex = 19 Digest::SHA::sha512256_base64 = 20 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 *) (SvPVbyte(ST(i), len)); while (len > MAX_WRITE_SIZE) { shawrite(data, MAX_WRITE_SIZE << 3, state); data += MAX_WRITE_SIZE; len -= MAX_WRITE_SIZE; } 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 Digest::SHA::hmac_sha512224 = 15 Digest::SHA::hmac_sha512224_hex = 16 Digest::SHA::hmac_sha512224_base64 = 17 Digest::SHA::hmac_sha512256 = 18 Digest::SHA::hmac_sha512256_hex = 19 Digest::SHA::hmac_sha512256_base64 = 20 PREINIT: int i; unsigned char *key; unsigned char *data; STRLEN len; HMAC *state; char *result; PPCODE: key = (unsigned char *) (SvPVbyte(ST(items-1), len)); if ((state = hmacopen(ix2alg[ix], key, len)) == NULL) XSRETURN_UNDEF; for (i = 0; i < items - 1; i++) { data = (unsigned char *) (SvPVbyte(ST(i), len)); while (len > MAX_WRITE_SIZE) { hmacwrite(data, MAX_WRITE_SIZE << 3, state); data += MAX_WRITE_SIZE; len -= MAX_WRITE_SIZE; } 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 = ix ? shaalg(state) : shadsize(state) << 3; 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 *) (SvPVbyte(ST(i), len)); while (len > MAX_WRITE_SIZE) { shawrite(data, MAX_WRITE_SIZE << 3, state); data += MAX_WRITE_SIZE; len -= MAX_WRITE_SIZE; } 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); Digest-SHA-5.86/META.yml0000644000175000017500000000055212272467255014477 0ustar mshelormshelor--- #YAML:1.0 name: Digest-SHA version: 5.86 abstract: Perl extension for SHA-1/224/256/384/512 license: perl author: - Mark Shelor, mshelor@cpan.org requires: perl: 5.003 provides: Digest::SHA: file: lib/Digest/SHA.pm version: 5.86 meta-spec: version: 1.3 url: http://module-build.sourceforge.net/META-spec-v1.3.html generated_by: Mark Shelor Digest-SHA-5.86/t/0000755000175000017500000000000012272467613013465 5ustar mshelormshelorDigest-SHA-5.86/t/rfc2202.t0000644000175000017500000000225612164252654014734 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(hmac_sha1_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @data = map { eval } ; my $numtests = scalar @data; print "1..$numtests\n"; my @keys = ( chr(0x0b) x 20, "Jefe", chr(0xaa) x 20, join("", map { chr } (1 .. 25)), chr(0x0c) x 20, chr(0xaa) x 80, chr(0xaa) x 80 ); my @out = ( "b617318655057264e28bc0b6fb378c8ef146be00", "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79", "125d7342b9ac11cd91a39af48aa17b4f63f175d3", "4c9007f4026250c6bc8414f9bf50c86c2d7235da", "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04", "aa4ae5e15272d00e95705637ce8a3b55ed402112", "e8e99d0f45237d786d6bbaa7965c7808bbff1a91" ); my $testnum = 1; while (@data) { print "not " unless hmac_sha1_hex(shift @data, shift @keys) eq shift @out; print "ok ", $testnum++, "\n"; } __DATA__ "Hi There" "what do ya want for nothing?" chr(0xdd) x 50 chr(0xcd) x 50 "Test With Truncation" "Test Using Larger Than Block-Size Key - Hash Key First" "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data" Digest-SHA-5.86/t/sha512.t0000644000175000017500000000223112164252654014650 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha512_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @vecs = map { eval } ; $#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl"; my $numtests = scalar(@vecs) / 2; print "1..$numtests\n"; my $skip = sha512_hex("") ? 0 : 1; for (1 .. $numtests) { my $data = shift @vecs; my $digest = shift @vecs; unless ($skip) { print "not " unless sha512_hex($data) eq $digest; } print "ok ", $_, $skip ? " # skip: no 64-bit" : "", "\n"; } __DATA__ "abc" "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f" "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909" "a" x 1000000 "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b" Digest-SHA-5.86/t/gg.t0000644000175000017500000000441312164252654014246 0ustar mshelormshelor# Test against short bitwise vectors from Jim Gillogly and Francois Grieu use strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw()); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } # SHA-1 Test Vectors # # In the following we use the notation bitstring#n to mean a bitstring # repeated n (in decimal) times, and we use | for concatenation. # Therefore 110#3|1 is 1101101101. # # 110#148|11 : CE7387AE 577337BE 54EA94F8 2C842E8B E76BC3E1 # 110#149 : DE244F06 3142CB2F 4C903B7F 7660577F 9E0D8791 # 110#149|1 : A3D29824 27AE39C8 920CA5F4 99D6C2BD 71EBF03C # 110#149|11 : 351AAB58 FF93CF12 AF7D5A58 4CFC8F7D 81023D10 # # 110#170 : 99638692 1E480D4E 2955E727 5DF3522C E8F5AB6E # 110#170|1 : BB5F4AD4 8913F51B 157EB985 A5C2034B 8243B01B # 110#170|11 : 9E92C554 2237B957 BA2244E8 141FDB66 DEC730A5 # 110#171 : 2103E454 DA4491F4 E32DD425 A3341DC9 C2A90848 # # 011#490 : B4B18049 DE405027 528CD9E7 4B2EC540 D4E6F06B # 011#490|0 : 34C63356 B3087427 20AB9669 14EB0FC9 26E4294B # 011#490|01 : 75FACE18 02B9F84F 326368AB 06E73E05 02E9EA34 # 011#491 : 7C2C3D62 F6AEC28D 94CDF93F 02E739E7 490698A1 my @vecs = ( "110",148,"11","ce7387ae577337be54ea94f82c842e8be76bc3e1", "110",149,"","de244f063142cb2f4c903b7f7660577f9e0d8791", "110",149,"1","a3d2982427ae39c8920ca5f499d6c2bd71ebf03c", "110",149,"11","351aab58ff93cf12af7d5a584cfc8f7d81023d10", "110",170,"","996386921e480d4e2955e7275df3522ce8f5ab6e", "110",170,"1","bb5f4ad48913f51b157eb985a5c2034b8243b01b", "110",170,"11","9e92c5542237b957ba2244e8141fdb66dec730a5", "110",171,"","2103e454da4491f4e32dd425a3341dc9c2a90848", "011",490,"","b4b18049de405027528cd9e74b2ec540d4e6f06b", "011",490,"0","34c63356b308742720ab966914eb0fc926e4294b", "011",490,"01","75face1802b9f84f326368ab06e73e0502e9ea34", "011",491,"","7c2c3d62f6aec28d94cdf93f02e739e7490698a1", ); my $numtests = scalar(@vecs) / 4; print "1..$numtests\n"; my $testnum = 1; my $sha = $MODULE->new(1); while (@vecs) { my $frag = shift @vecs; my $reps = shift @vecs; my $tail = shift @vecs; my $bitstr = ($frag x $reps) . $tail; print "not " unless $sha->add_bits($bitstr)->hexdigest eq shift @vecs; print "ok ", $testnum++, "\n"; } Digest-SHA-5.86/t/gglong.t0000644000175000017500000000755012164252654015133 0ustar mshelormshelor# Test against long bitwise vectors from Jim Gillogly and Francois Grieu use strict; use FileHandle; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw()); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } # SHA-1 Test Vectors # # In the following we use the notation bitstring#n to mean a bitstring # repeated n (in decimal) times, and we use | for concatenation. # Therefore 110#3|1 is 1101101101. # # Here is a set near 2^32 bits to test the roll-over in the length # field from one to two 32-bit words: # # 110#1431655764|11 1eef5a18 969255a3 b1793a2a 955c7ec2 8cd221a5 # 110#1431655765| 7a1045b9 14672afa ce8d90e6 d19b3a6a da3cb879 # 110#1431655765|1 d5e09777 a94f1ea9 240874c4 8d9fecb6 b634256b # 110#1431655765|11 eb256904 3c3014e5 1b2862ae 6eb5fb4e 0b851d99 # # 011#1431655764|01 4CB0C4EF 69143D5B F34FC35F 1D4B19F6 ECCAE0F2 # 011#1431655765 47D92F91 1FC7BB74 DE00ADFC 4E981A81 05556D52 # 011#1431655765|0 A3D7438C 589B0B93 2AA91CC2 446F06DF 9ABC73F0 # 011#1431655765|01 3EEE3E1E 28DEDE2C A444D68D A5675B2F AAAB3203 my @vec110 = ( # 110 rep 1431655764 "11", "1eef5a18969255a3b1793a2a955c7ec28cd221a5", "110", "7a1045b914672aface8d90e6d19b3a6ada3cb879", "1101", "d5e09777a94f1ea9240874c48d9fecb6b634256b", "11011", "eb2569043c3014e51b2862ae6eb5fb4e0b851d99" ); my @vec011 = ( # 011 rep 1431655764 "01", "4cb0c4ef69143d5bf34fc35f1d4b19f6eccae0f2", "011", "47d92f911fc7bb74de00adfc4e981a8105556d52", "0110", "a3d7438c589b0b932aa91cc2446f06df9abc73f0", "01101", "3eee3e1e28dede2ca444d68da5675b2faaab3203" ); print "1..", scalar(@vec110) / 2 + scalar(@vec011) / 2, "\n"; my $STATE110 = "gglong0.tmp"; my $STATE011 = "gglong1.tmp"; END { 1 while unlink $STATE110, $STATE011 } for ($STATE011, $STATE110) { my $fh = FileHandle->new($_, "w"); for (1 .. 8) { my $line = ; print $fh $line } $fh->close; } my $reps = 1 << 14; my $loops = int(1431655764 / $reps); my $rest = 3 * (1431655764 - $loops * $reps); sub state110 { my $i; my $state; my $bitstr; $state = $MODULE->new(1); if (-r $STATE110) { if ($state->load($STATE110)) { return($state); } } $bitstr = pack("B*", "110" x $reps); $state->reset; for ($i = 0; $i < $loops; $i++) { $state->add_bits($bitstr, 3 * $reps); } $state->add_bits($bitstr, $rest); $state->dump($STATE110); return($state); } sub state011 { my $i; my $state; my $bitstr; $state = $MODULE->new(1); if (-r $STATE011) { if ($state->load($STATE011)) { return($state); } } $bitstr = pack("B*", "011" x $reps); $state->reset; for ($i = 0; $i < $loops; $i++) { $state->add_bits($bitstr, 3 * $reps); } $state->add_bits($bitstr, $rest); $state->dump($STATE011); return($state); } my $i; my $testnum = 1; my $state110 = state110(); for ($i = 0; $i < @vec110/2; $i++) { my $state = $state110->clone; $state->add_bits($vec110[2*$i]); print "not " unless $state->hexdigest eq $vec110[2*$i+1]; print "ok ", $testnum++, "\n"; } my $state011 = state011(); for ($i = 0; $i < @vec011/2; $i++) { my $state = $state011->clone; $state->add_bits($vec011[2*$i]); print "not " unless $state->hexdigest eq $vec011[2*$i+1]; print "ok ", $testnum++, "\n"; } __DATA__ alg:1 H:7950cbe2:86a45aa0:91ff7dff:29015b42:3912e764:00000000:00000000:00000000 block:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6 blockcnt:508 lenhh:0 lenhl:0 lenlh:0 lenll:4294967292 alg:1 H:dfc51a14:87b4a4b7:ecf19acd:8cbbe40e:03a435f8:00000000:00000000:00000000 block:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d:b6:db:6d blockcnt:508 lenhh:0 lenhl:0 lenlh:0 lenll:4294967292 Digest-SHA-5.86/t/pod.t0000644000175000017500000000046012164252654014431 0ustar mshelormshelorBEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } BEGIN { eval "use Test::More"; if ($@) { print "1..0 # Skipped: Test::More not installed\n"; exit; } } eval "use Test::Pod 1.00"; plan skip_all => "Test::Pod 1.00 required for testing POD" if $@; all_pod_files_ok(); Digest-SHA-5.86/t/hmacsha.t0000644000175000017500000000406112164252654015254 0ustar mshelormshelor# HMAC-SHA-256 test vectors from draft-ietf-ipsec-ciph-sha-256-01.txt use strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(hmac_sha256_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @data = map { eval } ; my $numtests = scalar @data; print "1..$numtests\n"; my $k1 = join( "", map { chr } (1 .. 32) ); my $k2 = join( "", map { chr } (1 .. 37) ); my @keys = ( $k1, $k1, $k1, chr(0x0b) x 32, "Jefe", chr(0xaa) x 32, $k2, chr(0x0c) x 32, chr(0xaa) x 80, chr(0xaa) x 80 ); my @out = ( "a21b1f5d4cf4f73a4dd939750f7a066a7f98cc131cb16a6692759021cfab8181", "104fdc1257328f08184ba73131c53caee698e36119421149ea8c712456697d30", "470305fc7e40fe34d3eeb3e773d95aab73acf0fd060447a5eb4595bf33a9d1a3", "198a607eb44bfbc69903a0f1cf2bbdc5ba0aa3f3d9ae3c1c7a3b1696a0b68cf7", "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843", "cdcb1220d1ecccea91e53aba3092f962e549fe6ce9ed7fdc43191fbde45c30b0", "d4633c17f6fb8d744c66dee0f8f074556ec4af55ef07998541468eb49bd2e917", "7546af01841fc09b1ab9c3749a5f1c17d4f589668a587b2700a9c97c1193cf42", "6953025ed96f0c09f80a96f78e6538dbe2e7b820e3dd970e7ddd39091b32352f", "6355ac22e890d0a3c8481a5ca4825bc884d3e7a1ff98a2fc2ac7d8e064c3b2e6" ); # do the first one using multi-argument data feed my $testnum = 1; my @args = split(//, shift @data); print "not " unless hmac_sha256_hex(@args, shift @keys) eq shift @out; print "ok ", $testnum++, "\n"; while (@data) { print "not " unless hmac_sha256_hex(shift @data, shift @keys) eq shift @out; print "ok ", $testnum++, "\n"; } __DATA__ "abc" "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" "Hi There" "what do ya want for nothing?" chr(0xdd) x 50 chr(0xcd) x 50 "Test With Truncation" "Test Using Larger Than Block-Size Key - Hash Key First" "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data" Digest-SHA-5.86/t/base64.t0000644000175000017500000000176412164252654014743 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha1_base64 sha224_base64 sha256_base64 sha384_base64 sha512_base64)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my $in = "abc"; my @out = map { eval } ; my @fcn = (\&sha1_base64, \&sha224_base64, \&sha256_base64, \&sha384_base64, \&sha512_base64); print "1..", scalar @out, "\n"; my $testnum = 1; while (@out) { my $fcn = shift @fcn; my $rsp = shift @out; my $skip = &$fcn("") ? 0 : 1; unless ($skip) { print "not " unless &$fcn($in) eq $rsp; } print "ok ", $testnum++, $skip ? " # skip: no 64-bit" : "", "\n"; } __DATA__ "qZk+NkcGgWq6PiVxeFDCbJzQ2J0" "Iwl9IjQF2CKGQqR3vaJVsyqtvOS9oLP342ydpw" "ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0" "ywB1P0WjXou1oD1pmsZQBycsMqsO3tFjGotgWkP/W+2AhgcroefMI1i67KE0yCWn" "3a81oZNherrMQXNJriBBMRLm+k6JqX6iCp7u5ktV05ohkpkqJ0/BqDa6PCOj/uu9RU1EI2Q86A4qmslPpUyknw" Digest-SHA-5.86/t/fips180-4.t0000644000175000017500000000233212164252654015202 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha512_hex sha512224_hex sha512256_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @vecs = map { eval } ; # $#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl"; my $numtests = scalar(@vecs) / 2; print "1..$numtests\n"; my $skip = sha512_hex("") ? 0 : 1; for (1 .. $numtests) { my $data = shift @vecs; my $digest = shift @vecs; unless ($skip) { my $rsp = ($_ <= $numtests/2) ? sha512224_hex($data) : sha512256_hex($data); print "not " unless $rsp eq $digest; } print "ok ", $_, $skip ? " # skip: no 64-bit" : "", "\n"; } __DATA__ "abc" "4634270f707b6a54daae7530460842e20e37ed265ceee9a43e8924aa" "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" "23fec5bb94d60b23308192640b0c453335d664734fe40e7268674af9" "abc" "53048e2681941ef99b2e29b76b4c7dabe4c2d0c634fc6d46e0e2f13107e7af23" "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" "3928e184fb8690f840da3988121d31be65cb9d3ef83ee6146feac861e19b563a" Digest-SHA-5.86/t/unicode.t0000644000175000017500000000172012164252654015275 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha1_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my $skip = $] < 5.006 ? 1 : 0; my $TEMPLATE = $] >= 5.006 ? 'U*' : 'C*'; my $empty_unicode = pack($TEMPLATE, ()); my $ok_unicode = pack($TEMPLATE, (0..255)); my $wide_unicode = pack($TEMPLATE, (0..256)); print "1..3\n"; unless ($skip) { print "not " unless sha1_hex($empty_unicode."abc") eq "a9993e364706816aba3e25717850c26c9cd0d89d"; } print "ok 1", $skip ? " # skip: no Unicode" : "", "\n"; unless ($skip) { print "not " unless sha1_hex($ok_unicode) eq "4916d6bdb7f78e6803698cab32d1586ea457dfc8"; } print "ok 2", $skip ? " # skip: no Unicode" : "", "\n"; unless ($skip) { eval { sha1_hex($wide_unicode) }; print "not " unless $@ =~ /Wide character/; } print "ok 3", $skip ? " # skip: no Unicode" : "", "\n"; Digest-SHA-5.86/t/bitbuf.t0000644000175000017500000000272112164252654015124 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw()); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my $numtests = 4; print "1..$numtests\n"; # Here's the bitstring to test against, and its SHA-1 digest my $ONEBITS = pack("B*", "1" x 80000); my $digest = "11003389959355c2773af6b0f36d842fe430ec49"; my $state = $MODULE->new("sHa1"); my $testnum = 1; $state->add_bits($ONEBITS, 80000); print "not " unless $state->hexdigest eq $digest; print "ok ", $testnum++, "\n"; # buffer using a series of increasingly large bitstrings # Note that (1 + 2 + ... + 399) + 200 = 80000 for (1 .. 399) { $state->add_bits($ONEBITS, $_); } $state->add_bits($ONEBITS, 200); print "not " unless $state->hexdigest eq $digest; print "ok ", $testnum++, "\n"; # create a buffer-alignment nuisance $state = $MODULE->new("1"); $state->add_bits($ONEBITS, 1); for (1 .. 99) { $state->add_bits($ONEBITS, 800); } $state->add_bits($ONEBITS, 799); print "not " unless $state->hexdigest eq $digest; print "ok ", $testnum++, "\n"; # buffer randomly-sized bitstrings my $reps = 80000; my $maxbits = 8 * 127; $state = $MODULE->new(1); while ($reps > $maxbits) { my $num = int(rand($maxbits)); $state->add_bits($ONEBITS, $num); $reps -= $num; } $state->add_bits($ONEBITS, $reps); print "not " unless $state->hexdigest eq $digest; print "ok ", $testnum++, "\n"; Digest-SHA-5.86/t/sha384.t0000644000175000017500000000207112164252654014661 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha384_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @vecs = map { eval } ; $#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl"; my $numtests = scalar(@vecs) / 2; print "1..$numtests\n"; my $skip = sha384_hex("") ? 0 : 1; for (1 .. $numtests) { my $data = shift @vecs; my $digest = shift @vecs; unless ($skip) { print "not " unless sha384_hex($data) eq $digest; } print "ok ", $_, $skip ? " # skip: no 64-bit" : "", "\n"; } __DATA__ "abc" "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7" "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039" "a" x 1000000 "9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b07b8b3dc38ecc4ebae97ddd87f3d8985" Digest-SHA-5.86/t/fips198.t0000644000175000017500000000161212164252654015052 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(hmac_sha1_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @data = map { "Sample #$_" } (1 .. 4); my @out = ( "4f4ca3d5d68ba7cc0a1208c9c61e9c5da0403c0a", "0922d3405faa3d194f82a45830737d5cc6c75d24", "bcf41eab8bb2d802f3d05caf7cb092ecf8d1a3aa", "9ea886efe268dbecce420c7524df32e0751a2a26" ); my @keys = ("", "", "", ""); for (0x00 .. 0x00+63) { $keys[0] .= chr($_) } for (0x30 .. 0x30+19) { $keys[1] .= chr($_) } for (0x50 .. 0x50+99) { $keys[2] .= chr($_) } for (0x70 .. 0x70+48) { $keys[3] .= chr($_) } my $numtests = scalar @data; print "1..$numtests\n"; my $testnum = 1; while (@data) { print "not " unless hmac_sha1_hex(shift @data, shift @keys) eq shift @out; print "ok ", $testnum++, "\n"; } Digest-SHA-5.86/t/podcover.t0000644000175000017500000000127412164252654015474 0ustar mshelormshelormy $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw()); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } BEGIN { eval "use Test::More"; if ($@) { print "1..0 # Skipped: Test::More not installed\n"; exit; } } eval "use Test::Pod::Coverage 0.08"; plan skip_all => "Test::Pod::Coverage 0.08 required for testing POD coverage" if $@; my @privfcns = (); if ($MODULE eq "Digest::SHA") { @privfcns = qw( Addfile B64digest Hexdigest shaclose shadump shadup shaload shaopen sharewind shawrite ); } all_pod_coverage_ok( { also_private => \@privfcns } ); Digest-SHA-5.86/t/woodbury.t0000644000175000017500000001156612164252654015532 0ustar mshelormshelor# Test Vectors for HMAC-SHA-256/384/512 # # Vectors and initial script courtesy of Adam Woodbury, The MITRE Corporation use strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(hmac_sha256_hex hmac_sha384_hex hmac_sha512_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @plex = map { eval } ; my $numtests = scalar(@plex) / 3; print "1..$numtests\n"; # Use RFC 2202 data/key values for 512-bit blocks my @data_bs512 = splice(@plex, 0, 7); my @keys_bs512 = splice(@plex, 0, 7); my @hmac256rsp = splice(@plex, 0, 7); # Lengthen final RFC 2202 data/key values for 1024-bit blocks my @data_bs1024 = splice(@plex, 0, 7); my @keys_bs1024 = splice(@plex, 0, 7); my @hmac384rsp = splice(@plex, 0, 7); my @dat2_bs1024 = splice(@plex, 0, 7); my @key2_bs1024 = splice(@plex, 0, 7); my @hmac512rsp = splice(@plex, 0, 7); my $testnum = 1; while (@data_bs512) { print "not " unless hmac_sha256_hex(shift @data_bs512, shift @keys_bs512) eq shift @hmac256rsp; print "ok ", $testnum++, "\n"; } my $skip = hmac_sha384_hex("", "") ? 0 : 1; while (@data_bs1024) { if ($skip) { print "ok ", $testnum++, $skip ? " # skip: no 64-bit" : "", "\n"; shift @data_bs1024; next; } print "not " unless hmac_sha384_hex(shift @data_bs1024, shift @keys_bs1024) eq shift @hmac384rsp; print "ok ", $testnum++, "\n"; } while (@dat2_bs1024) { if ($skip) { print "ok ", $testnum++, $skip ? " # skip: no 64-bit" : "", "\n"; shift @dat2_bs1024; next; } print "not " unless hmac_sha512_hex(shift @dat2_bs1024, shift @key2_bs1024) eq shift @hmac512rsp; print "ok ", $testnum++, "\n"; } __DATA__ "Hi There" "what do ya want for nothing?" chr(0xdd) x 50 chr(0xcd) x 50 "Test With Truncation" "Test Using Larger Than Block-Size Key - Hash Key First" "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data" chr(0x0b) x 20 "Jefe" chr(0xaa) x 20 join("", map { chr } (1 .. 25)) chr(0x0c) x 20 chr(0xaa) x 80 chr(0xaa) x 80 "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7" "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843" "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe" "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b" "a3b6167473100ee06e0c796c2955552bfa6f7c0a6a8aef8b93f860aab0cd20c5" "6953025ed96f0c09f80a96f78e6538dbe2e7b820e3dd970e7ddd39091b32352f" "6355ac22e890d0a3c8481a5ca4825bc884d3e7a1ff98a2fc2ac7d8e064c3b2e6" "Hi There" "what do ya want for nothing?" chr(0xdd) x 50 chr(0xcd) x 50 "Test With Truncation" "Test Using Larger Than Block-Size Key - Hash Key First" "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data. The Larger Block-Sizes Make For Much Longer Test Vectors" chr(0x0b) x 20 "Jefe" chr(0xaa) x 20 join("", map { chr } (1 .. 25)) chr(0x0c) x 20 chr(0xaa) x 200 chr(0xaa) x 200 "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6" "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649" "88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27" "3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb" "3abf34c3503b2a23a46efc619baef897f4c8e42c934ce55ccbae9740fcbc1af4ca62269e2a37cd88ba926341efe4aeea" "ec629fe0dc1fab504fc1c89572d6573cf15c3a4b5b69d53f0c13849561a6c13e153af48d2538ce056a3fe10d69da16c3" "07109d2c6c2fdcac39c3a8b5f36fc9a69e029d3d8647cc3e4ddb77888418c5c09d807942e5f96d17ee9fd46aed64b7f2" "Hi There" "what do ya want for nothing?" chr(0xdd) x 50 chr(0xcd) x 50 "Test With Truncation" "Test Using Larger Than Block-Size Key - Hash Key First" "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data. The Larger Block-Sizes Make For Much Longer Test Vectors" chr(0x0b) x 20 "Jefe" chr(0xaa) x 20 join("", map { chr } (1 .. 25)) chr(0x0c) x 20 chr(0xaa) x 200 chr(0xaa) x 200 "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854" "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737" "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb" "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd" "415fad6271580a531d4179bc891d87a650188707922a4fbb36663a1eb16da008711c5b50ddd0fc235084eb9d3364a1454fb2ef67cd1d29fe6773068ea266e96b" "9dc6330f4c966b62b735d565343cb77413deccdf42a92d9ef5e4e2ae33f6c924bbc8e34c47111bc069482d4dbcfee148419a6547f2d01500e8160b39cc2e4ae8" "396ed3a17cef82cddbd987ea66a5dd1f38b68167df31f049463b85fa10b531d0e90d1052f8c9c7cda263468ec3f980a8fec06213c2944c92a0ac95a2d8ade76d" Digest-SHA-5.86/t/ireland.t0000644000175000017500000000255712164252654015276 0ustar mshelormsheloruse strict; use FileHandle; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw()); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } # David Ireland's test vector - SHA-256 digest of "a" x 536870912 # Adapted from Julius Duque's original script (t/24-ireland.tmp) # - modified to use state cache via dump()/load() methods print "1..1\n"; my $tempfile = "ireland.tmp"; END { 1 while unlink $tempfile } my $fh = FileHandle->new($tempfile, "w"); while () { print $fh $_ } close($fh); my $rsp = "b9045a713caed5dff3d3b783e98d1ce5778d8bc331ee4119d707072312af06a7"; my $sha; if ($sha = $MODULE->load($tempfile)) { $sha->add("aa"); print "not " unless $sha->hexdigest eq $rsp; print "ok 1\n"; } else { print "not ok 1\n" } __DATA__ alg:256 H:dd75eb45:02d4f043:06b41193:6fda751d:73064db9:787d54e1:52dc3fe0:48687dfa block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00 blockcnt:496 lenhh:0 lenhl:0 lenlh:0 lenll:4294967280 Digest-SHA-5.86/t/nistbyte.t0000644000175000017500000000323012164252654015506 0ustar mshelormshelor# Test against SHA-1 Sample Vectors from NIST use strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw()); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my $nist_hashes = <new(1); for (@lines) { next unless /^[\d ^]/; $message .= $_; next unless /\^\s*$/; my @vals = $message =~ /\d+/g; $message = ""; my $count = shift(@vals); my $bit = shift(@vals); my $bitstr = ""; while (@vals) { $bitstr .= $bit x shift(@vals); $bit = 1 - $bit; } print "not " unless uc($sha->add(pack("B*", $bitstr))->hexdigest) eq shift(@hashes); print "ok ", $testnum++, "\n"; } Digest-SHA-5.86/t/dumpload.t0000644000175000017500000000676712164252654015474 0ustar mshelormsheloruse strict; use FileHandle; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha384_hex sha512_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @sharsp = ( "34aa973cd4c4daa4f61eeb2bdbad27316534016f", "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0", "9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b07b8b3dc38ecc4ebae97ddd87f3d8985", "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b" ); my $numtests = scalar @sharsp; print "1..$numtests\n"; my @tempfiles; END { 1 while unlink @tempfiles } my @statefiles = ("dl001.tmp", "dl256.tmp", "dl384.tmp", "dl512.tmp"); for (@statefiles) { push @tempfiles, $_; my $fh = FileHandle->new($_, "w"); for (1 .. 8) { my $line = ; print $fh $line } $fh->close; } my $tmpfile = "dumpload.tmp"; push @tempfiles, $tmpfile; my @alg = (1, 256, 384, 512); my $data = "a" x 990000; my $testnum = 1; while (@sharsp) { my $skip = 0; my $alg = shift @alg; my $rsp = shift @sharsp; my $file = shift @statefiles; push(@statefiles, $file); if ($alg == 384) { $skip = sha384_hex("") ? 0 : 1 } if ($alg == 512) { $skip = sha512_hex("") ? 0 : 1 } if ($skip) { print "ok ", $testnum++, " # skip: no 64-bit\n"; next; } my $digest; my $state; unless ($state = $MODULE->load($file)) { print "not ok ", $testnum++, "\n"; next; } $state->add_bits($data, 79984)->dump($tmpfile); $state->load($tmpfile)->add_bits($data, 16); $digest = $state->hexdigest; print "not " unless $digest eq $rsp; print "ok ", $testnum++, "\n"; } __DATA__ alg:1 H:9d6f7d2f:65e21307:c6f41af6:7c7fd3a9:8dec6058:00000000:00000000:00000000 block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00 blockcnt:384 lenhh:0 lenhl:0 lenlh:0 lenll:7920000 alg:256 H:2d6c0def:4244ade7:fc8c121c:108f4493:ec3fbec2:91425a6e:b8d30d2a:9db24273 block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00 blockcnt:384 lenhh:0 lenhl:0 lenlh:0 lenll:7920000 alg:384 H:598147f4583a61f7:8d194a4d7c9008cb:39725c96557d600f:d7f2079ce8251f19:bd735d446f9a3c7c:234de90b9060898d:a5b481b9d635d190:81c6e74ee4556125 block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00 blockcnt:384 lenhh:0 lenhl:0 lenlh:0 lenll:7920000 alg:512 H:0442fe29a02b8c30:13553e6dbedc2aa0:8f891a0cb2ac3107:6fa1762b40ac04dd:dcbf420d729eea79:34703e9672dcf145:7bf9aaa14d400433:2aa65f044825466d block:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:61:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00 blockcnt:384 lenhh:0 lenhl:0 lenlh:0 lenll:7920000 Digest-SHA-5.86/t/sha256.t0000644000175000017500000000150412164252654014657 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha256_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @vecs = map { eval } ; $#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl"; my $numtests = scalar(@vecs) / 2; print "1..$numtests\n"; for (1 .. $numtests) { my $data = shift @vecs; my $digest = shift @vecs; print "not " unless sha256_hex($data) eq $digest; print "ok ", $_, "\n"; } __DATA__ "abc" "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1" "a" x 1000000 "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0" Digest-SHA-5.86/t/methods.t0000644000175000017500000000607512164252654015322 0ustar mshelormsheloruse strict; use FileHandle; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw()); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @out = ( "ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0", "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1", ); my $numtests = 8 + scalar @out; print "1..$numtests\n"; # attempt to use an invalid algorithm, and check for failure my $testnum = 1; my $NSA = "SHA-42"; # No Such Algorithm print "not " if $MODULE->new($NSA); print "ok ", $testnum++, "\n"; my $tempfile = "methods.tmp"; END { 1 while unlink $tempfile } # test OO methods using first two SHA-256 vectors from NIST my $fh = FileHandle->new($tempfile, "w"); binmode($fh); print $fh "bcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; $fh->close; my $sha = $MODULE->new()->reset("SHA-256")->new(); $sha->add_bits("a", 5)->add_bits("001"); my $rsp = shift(@out); print "not " unless $sha->clone->add("b", "c")->b64digest eq $rsp; print "ok ", $testnum++, "\n"; $rsp = shift(@out); # test addfile with bareword filehandle open(FILE, "<$tempfile"); binmode(FILE); print "not " unless $sha->clone->addfile(*FILE)->hexdigest eq $rsp; print "ok ", $testnum++, "\n"; close(FILE); # test addfile with indirect filehandle $fh = FileHandle->new($tempfile, "r"); binmode($fh); print "not " unless $sha->clone->addfile($fh)->hexdigest eq $rsp; print "ok ", $testnum++, "\n"; $fh->close; # test addfile using file name instead of handle print "not " unless $sha->addfile($tempfile, "b")->hexdigest eq $rsp; print "ok ", $testnum++, "\n"; # test addfile portable mode $fh = FileHandle->new($tempfile, "w"); binmode($fh); print $fh "abc\012" x 2048; # using UNIX newline $fh->close; print "not " unless $sha->new(1)->addfile($tempfile, "p")->hexdigest eq "d449e19c1b0b0c191294c8dc9fa2e4a6ff77fc51"; print "ok ", $testnum++, "\n"; $fh = FileHandle->new($tempfile, "w"); binmode($fh); print $fh "abc\015\012" x 2048; # using DOS/Windows newline $fh->close; print "not " unless $sha->new(1)->addfile($tempfile, "p")->hexdigest eq "d449e19c1b0b0c191294c8dc9fa2e4a6ff77fc51"; print "ok ", $testnum++, "\n"; $fh = FileHandle->new($tempfile, "w"); binmode($fh); print $fh "abc\015" x 2048; # using early-Mac newline $fh->close; print "not " unless $sha->new(1)->addfile($tempfile, "p")->hexdigest eq "d449e19c1b0b0c191294c8dc9fa2e4a6ff77fc51"; print "ok ", $testnum++, "\n"; # test addfile BITS mode $fh = FileHandle->new($tempfile, "w"); print $fh "0100010"; # using NIST 7-bit test vector $fh->close; print "not " unless $sha->new(1)->addfile($tempfile, "0")->hexdigest eq "04f31807151181ad0db278a1660526b0aeef64c2"; print "ok ", $testnum++, "\n"; $fh = FileHandle->new($tempfile, "w"); binmode($fh); print $fh map(chr, (0..127)); # this is actually NIST 2-bit test $fh->close; # vector "01" (other chars ignored) print "not " unless $sha->new(1)->addfile($tempfile, "0")->hexdigest eq "ec6b39952e1a3ec3ab3507185cf756181c84bbe2"; print "ok ", $testnum++, "\n"; Digest-SHA-5.86/t/sha1.t0000644000175000017500000000137012164252654014504 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha1_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @vecs = map { eval } ; $#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl"; my $numtests = scalar(@vecs) / 2; print "1..$numtests\n"; for (1 .. $numtests) { my $data = shift @vecs; my $digest = shift @vecs; print "not " unless sha1_hex($data) eq $digest; print "ok ", $_, "\n"; } __DATA__ "abc" "a9993e364706816aba3e25717850c26c9cd0d89d" "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" "84983e441c3bd26ebaae4aa1f95129e5e54670f1" "a" x 1000000 "34aa973cd4c4daa4f61eeb2bdbad27316534016f" Digest-SHA-5.86/t/sha224.t0000644000175000017500000000145412164252654014656 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw(sha224_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my @vecs = map { eval } ; $#vecs -= 2 if $MODULE eq "Digest::SHA::PurePerl"; my $numtests = scalar(@vecs) / 2; print "1..$numtests\n"; for (1 .. $numtests) { my $data = shift @vecs; my $digest = shift @vecs; print "not " unless sha224_hex($data) eq $digest; print "ok ", $_, "\n"; } __DATA__ "abc" "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7" "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" "75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525" "a" x 1000000 "20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67" Digest-SHA-5.86/t/allfcns.t0000644000175000017500000000125712164252654015276 0ustar mshelormsheloruse strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw( hmac_sha1 hmac_sha1_base64 hmac_sha1_hex hmac_sha224 hmac_sha224_base64 hmac_sha224_hex hmac_sha256 hmac_sha256_base64 hmac_sha256_hex hmac_sha384 hmac_sha384_base64 hmac_sha384_hex hmac_sha512 hmac_sha512_base64 hmac_sha512_hex sha1 sha1_base64 sha1_hex sha224 sha224_base64 sha224_hex sha256 sha256_base64 sha256_hex sha384 sha384_base64 sha384_hex sha512 sha512_base64 sha512_hex)); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } print "1..1\n"; print "ok 1\n"; Digest-SHA-5.86/t/nistbit.t0000644000175000017500000000300212164252654015316 0ustar mshelormshelor# Test against SHA-1 Sample Vectors from NIST use strict; my $MODULE; BEGIN { $MODULE = (-d "src") ? "Digest::SHA" : "Digest::SHA::PurePerl"; eval "require $MODULE" || die $@; $MODULE->import(qw()); } BEGIN { if ($ENV{PERL_CORE}) { chdir 't' if -d 't'; @INC = '../lib'; } } my $nist_hashes = <new(1); for (@lines) { next unless /^[\d ^]/; $message .= $_; next unless /\^\s*$/; my @vals = $message =~ /\d+/g; $message = ""; my $count = shift(@vals); my $bit = shift(@vals); my $bitstr = ""; while (@vals) { $bitstr .= $bit x shift(@vals); $bit = 1 - $bit; } print "not " unless uc($sha->add_bits($bitstr)->hexdigest) eq shift(@hashes); print "ok ", $testnum++, "\n"; } Digest-SHA-5.86/src/0000755000175000017500000000000012272467613014011 5ustar mshelormshelorDigest-SHA-5.86/src/sha.h0000644000175000017500000001125012272467255014736 0ustar mshelormshelor/* * sha.h: header file for SHA-1/224/256/384/512 routines * * Ref: NIST FIPS PUB 180-2 Secure Hash Standard * * Copyright (C) 2003-2014 Mark Shelor, All Rights Reserved * * Version: 5.86 * Thu Jan 30 08:24:28 MST 2014 * */ #ifndef _INCLUDE_SHA_H_ #define _INCLUDE_SHA_H_ #include #define SHA32_MAX 4294967295U #define SHA32_SHR(x, n) ((x) >> (n)) #define SHA32_SHL(x, n) ((x) << (n)) #define SHA64_SHR(x, n) ((x) >> (n)) #define SHA64_SHL(x, n) ((x) << (n)) #define SHA32_ALIGNED #define SHA64_ALIGNED #define SHA_LO32(x) (x) #if USHRT_MAX == SHA32_MAX #define SHA32 unsigned short #define SHA32_CONST(c) c ## U #elif UINT_MAX == SHA32_MAX #define SHA32 unsigned int #define SHA32_CONST(c) c ## U #elif ULONG_MAX == SHA32_MAX #define SHA32 unsigned long #define SHA32_CONST(c) c ## UL #else #undef SHA32_ALIGNED #undef SHA_LO32 #define SHA_LO32(x) ((x) & SHA32_MAX) #undef SHA32_SHR #define SHA32_SHR(x, n) (SHA_LO32(x) >> (n)) #define SHA32 unsigned long #define SHA32_CONST(c) c ## UL #endif #if defined(ULONG_LONG_MAX) || defined(ULLONG_MAX) || defined(HAS_LONG_LONG) #define SHA_ULL_EXISTS #endif #if (((ULONG_MAX >> 16) >> 16) >> 16) >> 15 == 1UL #define SHA64 unsigned long #define SHA64_CONST(c) c ## UL #elif defined(SHA_ULL_EXISTS) && defined(LONGLONGSIZE) && LONGLONGSIZE == 8 #define SHA64 unsigned long long #define SHA64_CONST(c) c ## ULL #elif defined(SHA_ULL_EXISTS) #undef SHA64_ALIGNED #undef SHA64_SHR #define SHA64_MAX 18446744073709551615ULL #define SHA64_SHR(x, n) (((x) & SHA64_MAX) >> (n)) #define SHA64 unsigned long long #define SHA64_CONST(c) c ## ULL /* The following cases detect compilers that * support 64-bit types in a non-standard way */ #elif defined(_MSC_VER) /* Microsoft C */ #define SHA64 unsigned __int64 #define SHA64_CONST(c) (SHA64) c #endif #if defined(SHA64) && !defined(NO_SHA_384_512) #define SHA_384_512 #endif #if defined(BYTEORDER) && (BYTEORDER & 0xffff) == 0x4321 #if defined(SHA32_ALIGNED) #define SHA32_SCHED(W, b) memcpy(W, b, 64) #endif #if defined(SHA64) && defined(SHA64_ALIGNED) #define SHA64_SCHED(W, b) memcpy(W, b, 128) #endif #endif #if !defined(SHA32_SCHED) #define SHA32_SCHED(W, b) { int t; SHA32 *q = W; \ for (t = 0; t < 16; t++, b += 4) *q++ = \ (SHA32) b[0] << 24 | (SHA32) b[1] << 16 | \ (SHA32) b[2] << 8 | (SHA32) b[3]; } #endif #if defined(SHA64) && !defined(SHA64_SCHED) #define SHA64_SCHED(W, b) { int t; SHA64 *q = W; \ for (t = 0; t < 16; t++, b += 8) *q++ = \ (SHA64) b[0] << 56 | (SHA64) b[1] << 48 | \ (SHA64) b[2] << 40 | (SHA64) b[3] << 32 | \ (SHA64) b[4] << 24 | (SHA64) b[5] << 16 | \ (SHA64) b[6] << 8 | (SHA64) b[7]; } #endif #define SHA_new New #define SHA_newz Newz #define SHA_free Safefree #ifdef SHA_PerlIO #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_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 SHA512224 512224 #define SHA512256 512256 #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 SHA512224_BLOCK_BITS SHA512_BLOCK_BITS #define SHA512256_BLOCK_BITS SHA512_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 SHA512224_DIGEST_BITS 224 #define SHA512256_DIGEST_BITS 256 #define SHA_MAX_BLOCK_BITS SHA512_BLOCK_BITS #define SHA_MAX_DIGEST_BITS SHA512_DIGEST_BITS #define SHA_MAX_HEX_LEN (SHA_MAX_DIGEST_BITS / 4) #define SHA_MAX_BASE64_LEN (1 + (SHA_MAX_DIGEST_BITS / 6)) #if defined(SHA64) #define SHA_H_SIZE sizeof(SHA64) * 8 #else #define SHA_H_SIZE sizeof(SHA32) * 8 #endif typedef struct SHA { int alg; void (*sha)(struct SHA *, unsigned char *); unsigned char H[SHA_H_SIZE]; unsigned char block[SHA_MAX_BLOCK_BITS/8]; unsigned int blockcnt; unsigned int blocksize; SHA32 lenhh, lenhl, lenlh, lenll; unsigned char digest[SHA_MAX_DIGEST_BITS/8]; int digestlen; char hex[SHA_MAX_HEX_LEN+1]; char base64[SHA_MAX_BASE64_LEN+1]; } SHA; typedef struct { SHA *ksha; SHA *isha; SHA *osha; unsigned char key[SHA_MAX_BLOCK_BITS/8]; } HMAC; #endif /* _INCLUDE_SHA_H_ */ Digest-SHA-5.86/src/sha.c0000644000175000017500000005103712272467255014740 0ustar mshelormshelor/* * sha.c: routines to compute SHA-1/224/256/384/512 digests * * Ref: NIST FIPS PUB 180-2 Secure Hash Standard * * Copyright (C) 2003-2014 Mark Shelor, All Rights Reserved * * Version: 5.86 * Thu Jan 30 08:24:28 MST 2014 * */ #include #include #include #include #include #include "sha.h" #include "sha64bit.h" #define W32 SHA32 /* useful abbreviations */ #define C32 SHA32_CONST #define SR32 SHA32_SHR #define SL32 SHA32_SHL #define LO32 SHA_LO32 #define UCHR unsigned char #define UINT unsigned int #define ULNG unsigned long #define VP void * #define ROTR(x, n) (SR32(x, n) | SL32(x, 32-(n))) #define ROTL(x, n) (SL32(x, n) | SR32(x, 32-(n))) #define Ch(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) #define Pa(x, y, z) ((x) ^ (y) ^ (z)) #define Ma(x, y, z) (((x) & (y)) | ((z) & ((x) | (y)))) #define SIGMA0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)) #define SIGMA1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)) #define sigma0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SR32(x, 3)) #define sigma1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SR32(x, 10)) #define K1 C32(0x5a827999) /* SHA-1 constants */ #define K2 C32(0x6ed9eba1) #define K3 C32(0x8f1bbcdc) #define K4 C32(0xca62c1d6) static W32 K256[64] = /* SHA-224/256 constants */ { C32(0x428a2f98), C32(0x71374491), C32(0xb5c0fbcf), C32(0xe9b5dba5), C32(0x3956c25b), C32(0x59f111f1), C32(0x923f82a4), C32(0xab1c5ed5), C32(0xd807aa98), C32(0x12835b01), C32(0x243185be), C32(0x550c7dc3), C32(0x72be5d74), C32(0x80deb1fe), C32(0x9bdc06a7), C32(0xc19bf174), C32(0xe49b69c1), C32(0xefbe4786), C32(0x0fc19dc6), C32(0x240ca1cc), C32(0x2de92c6f), C32(0x4a7484aa), C32(0x5cb0a9dc), C32(0x76f988da), C32(0x983e5152), C32(0xa831c66d), C32(0xb00327c8), C32(0xbf597fc7), C32(0xc6e00bf3), C32(0xd5a79147), C32(0x06ca6351), C32(0x14292967), C32(0x27b70a85), C32(0x2e1b2138), C32(0x4d2c6dfc), C32(0x53380d13), C32(0x650a7354), C32(0x766a0abb), C32(0x81c2c92e), C32(0x92722c85), C32(0xa2bfe8a1), C32(0xa81a664b), C32(0xc24b8b70), C32(0xc76c51a3), C32(0xd192e819), C32(0xd6990624), C32(0xf40e3585), C32(0x106aa070), C32(0x19a4c116), C32(0x1e376c08), C32(0x2748774c), C32(0x34b0bcb5), C32(0x391c0cb3), C32(0x4ed8aa4a), C32(0x5b9cca4f), C32(0x682e6ff3), C32(0x748f82ee), C32(0x78a5636f), C32(0x84c87814), C32(0x8cc70208), C32(0x90befffa), C32(0xa4506ceb), C32(0xbef9a3f7), C32(0xc67178f2) }; static W32 H01[5] = /* SHA-1 initial hash value */ { C32(0x67452301), C32(0xefcdab89), C32(0x98badcfe), C32(0x10325476), C32(0xc3d2e1f0) }; static W32 H0224[8] = /* SHA-224 initial hash value */ { C32(0xc1059ed8), C32(0x367cd507), C32(0x3070dd17), C32(0xf70e5939), C32(0xffc00b31), C32(0x68581511), C32(0x64f98fa7), C32(0xbefa4fa4) }; static W32 H0256[8] = /* SHA-256 initial hash value */ { C32(0x6a09e667), C32(0xbb67ae85), C32(0x3c6ef372), C32(0xa54ff53a), C32(0x510e527f), C32(0x9b05688c), C32(0x1f83d9ab), C32(0x5be0cd19) }; static void sha1(SHA *s, UCHR *block) /* SHA-1 transform */ { W32 a, b, c, d, e; W32 W[16]; W32 *wp = W; W32 *H = (W32 *) s->H; SHA32_SCHED(W, block); /* * Use SHA-1 alternate method from FIPS PUB 180-2 (ref. 6.1.3) * * To improve performance, unroll the loop and consolidate assignments * by changing the roles of variables "a" through "e" at each step. * Note that the variable "T" is no longer needed. */ #define M1(a, b, c, d, e, f, k, w) \ e += ROTL(a, 5) + f(b, c, d) + k + w; \ b = ROTL(b, 30) #define M11(f, k, w) M1(a, b, c, d, e, f, k, w); #define M12(f, k, w) M1(e, a, b, c, d, f, k, w); #define M13(f, k, w) M1(d, e, a, b, c, f, k, w); #define M14(f, k, w) M1(c, d, e, a, b, f, k, w); #define M15(f, k, w) M1(b, c, d, e, a, f, k, w); #define W11(s) W[(s+ 0) & 0xf] #define W12(s) W[(s+13) & 0xf] #define W13(s) W[(s+ 8) & 0xf] #define W14(s) W[(s+ 2) & 0xf] #define A1(s) (W11(s) = ROTL(W11(s) ^ W12(s) ^ W13(s) ^ W14(s), 1)) a = H[0]; b = H[1]; c = H[2]; d = H[3]; e = H[4]; M11(Ch, K1, *wp++); M12(Ch, K1, *wp++); M13(Ch, K1, *wp++); M14(Ch, K1, *wp++); M15(Ch, K1, *wp++); M11(Ch, K1, *wp++); M12(Ch, K1, *wp++); M13(Ch, K1, *wp++); M14(Ch, K1, *wp++); M15(Ch, K1, *wp++); M11(Ch, K1, *wp++); M12(Ch, K1, *wp++); M13(Ch, K1, *wp++); M14(Ch, K1, *wp++); M15(Ch, K1, *wp++); M11(Ch, K1, *wp ); M12(Ch, K1, A1( 0)); M13(Ch, K1, A1( 1)); M14(Ch, K1, A1( 2)); M15(Ch, K1, A1( 3)); M11(Pa, K2, A1( 4)); M12(Pa, K2, A1( 5)); M13(Pa, K2, A1( 6)); M14(Pa, K2, A1( 7)); M15(Pa, K2, A1( 8)); M11(Pa, K2, A1( 9)); M12(Pa, K2, A1(10)); M13(Pa, K2, A1(11)); M14(Pa, K2, A1(12)); M15(Pa, K2, A1(13)); M11(Pa, K2, A1(14)); M12(Pa, K2, A1(15)); M13(Pa, K2, A1( 0)); M14(Pa, K2, A1( 1)); M15(Pa, K2, A1( 2)); M11(Pa, K2, A1( 3)); M12(Pa, K2, A1( 4)); M13(Pa, K2, A1( 5)); M14(Pa, K2, A1( 6)); M15(Pa, K2, A1( 7)); M11(Ma, K3, A1( 8)); M12(Ma, K3, A1( 9)); M13(Ma, K3, A1(10)); M14(Ma, K3, A1(11)); M15(Ma, K3, A1(12)); M11(Ma, K3, A1(13)); M12(Ma, K3, A1(14)); M13(Ma, K3, A1(15)); M14(Ma, K3, A1( 0)); M15(Ma, K3, A1( 1)); M11(Ma, K3, A1( 2)); M12(Ma, K3, A1( 3)); M13(Ma, K3, A1( 4)); M14(Ma, K3, A1( 5)); M15(Ma, K3, A1( 6)); M11(Ma, K3, A1( 7)); M12(Ma, K3, A1( 8)); M13(Ma, K3, A1( 9)); M14(Ma, K3, A1(10)); M15(Ma, K3, A1(11)); M11(Pa, K4, A1(12)); M12(Pa, K4, A1(13)); M13(Pa, K4, A1(14)); M14(Pa, K4, A1(15)); M15(Pa, K4, A1( 0)); M11(Pa, K4, A1( 1)); M12(Pa, K4, A1( 2)); M13(Pa, K4, A1( 3)); M14(Pa, K4, A1( 4)); M15(Pa, K4, A1( 5)); M11(Pa, K4, A1( 6)); M12(Pa, K4, A1( 7)); M13(Pa, K4, A1( 8)); M14(Pa, K4, A1( 9)); M15(Pa, K4, A1(10)); M11(Pa, K4, A1(11)); M12(Pa, K4, A1(12)); M13(Pa, K4, A1(13)); M14(Pa, K4, A1(14)); M15(Pa, K4, A1(15)); H[0] += a; H[1] += b; H[2] += c; H[3] += d; H[4] += e; } static void sha256(SHA *s, UCHR *block) /* SHA-224/256 transform */ { W32 a, b, c, d, e, f, g, h, T1; 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) + 7) >> 3) #define HEXLEN(nbytes) ((nbytes) << 1) #define B64LEN(nbytes) (((nbytes) % 3 == 0) ? ((nbytes) / 3) * 4 \ : ((nbytes) / 3) * 4 + ((nbytes) % 3) + 1) /* w32mem: writes 32-bit word to memory in big-endian order */ static void w32mem(UCHR *mem, W32 w32) { int i; for (i = 0; i < 4; i++) *mem++ = (UCHR) (SR32(w32, 24-i*8) & 0xff); } /* digcpy: writes current state to digest buffer */ static void digcpy(SHA *s) { UINT i; UCHR *d = s->digest; W32 *p32 = (W32 *) s->H; W64 *p64 = (W64 *) s->H; if (s->alg <= SHA256) for (i = 0; i < 8; i++, d += 4) w32mem(d, *p32++); else for (i = 0; i < 8; i++, d += 8) { w32mem(d, (W32) ((*p64 >> 16) >> 16)); w32mem(d+4, (W32) (*p64++ & SHA32_MAX)); } } #define SHA_INIT(algo, transform) \ do { \ memset(s, 0, sizeof(SHA)); \ s->alg = algo; s->sha = sha ## transform; \ memcpy(s->H, H0 ## algo, sizeof(H0 ## algo)); \ s->blocksize = SHA ## algo ## _BLOCK_BITS; \ s->digestlen = SHA ## algo ## _DIGEST_BITS >> 3; \ } while (0) /* sharewind: re-initializes the digest object */ static void sharewind(SHA *s) { if (s->alg == SHA1) SHA_INIT(1, 1); else if (s->alg == SHA224) SHA_INIT(224, 256); else if (s->alg == SHA256) SHA_INIT(256, 256); else if (s->alg == SHA384) SHA_INIT(384, 512); else if (s->alg == SHA512) SHA_INIT(512, 512); else if (s->alg == SHA512224) SHA_INIT(512224, 512); else if (s->alg == SHA512256) SHA_INIT(512256, 512); } /* shaopen: creates a new digest object */ static SHA *shaopen(int alg) { SHA *s = NULL; if (alg != SHA1 && alg != SHA224 && alg != SHA256 && alg != SHA384 && alg != SHA512 && alg != SHA512224 && alg != SHA512256) 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); } /* shaclose: de-allocates digest object */ static int shaclose(SHA *s) { if (s != NULL) { memset(s, 0, sizeof(SHA)); SHA_free(s); } return(0); } /* shadirect: updates state directly (w/o going through s->block) */ static ULNG shadirect(UCHR *bitstr, ULNG bitcnt, SHA *s) { ULNG savecnt = bitcnt; while (bitcnt >= s->blocksize) { s->sha(s, bitstr); bitstr += (s->blocksize >> 3); bitcnt -= s->blocksize; } if (bitcnt > 0) { memcpy(s->block, bitstr, NBYTES(bitcnt)); s->blockcnt = bitcnt; } return(savecnt); } /* shabytes: updates state for byte-aligned input data */ static ULNG shabytes(UCHR *bitstr, ULNG bitcnt, SHA *s) { UINT offset; UINT nbits; ULNG savecnt = bitcnt; offset = s->blockcnt >> 3; if (s->blockcnt + bitcnt >= s->blocksize) { nbits = s->blocksize - s->blockcnt; memcpy(s->block+offset, bitstr, nbits>>3); bitcnt -= nbits; bitstr += (nbits >> 3); s->sha(s, s->block), s->blockcnt = 0; shadirect(bitstr, bitcnt, s); } else { memcpy(s->block+offset, bitstr, NBYTES(bitcnt)); s->blockcnt += bitcnt; } return(savecnt); } /* shabits: updates state for bit-aligned input data */ static ULNG shabits(UCHR *bitstr, ULNG bitcnt, SHA *s) { UINT i; UINT gap; ULNG nbits; UCHR buf[1<<9]; UINT bufsize = sizeof(buf); ULNG bufbits = (ULNG) bufsize << 3; UINT nbytes = NBYTES(bitcnt); ULNG savecnt = bitcnt; gap = 8 - s->blockcnt % 8; s->block[s->blockcnt>>3] &= ~0 << gap; s->block[s->blockcnt>>3] |= *bitstr >> (8 - gap); s->blockcnt += bitcnt < gap ? bitcnt : gap; if (bitcnt < gap) return(savecnt); if (s->blockcnt == s->blocksize) s->sha(s, s->block), s->blockcnt = 0; if ((bitcnt -= gap) == 0) return(savecnt); while (nbytes > bufsize) { for (i = 0; i < bufsize; i++) buf[i] = bitstr[i] << gap | bitstr[i+1] >> (8-gap); nbits = bitcnt < bufbits ? bitcnt : bufbits; shabytes(buf, nbits, s); bitcnt -= nbits, bitstr += bufsize, nbytes -= bufsize; } for (i = 0; i < nbytes - 1; i++) buf[i] = bitstr[i] << gap | bitstr[i+1] >> (8-gap); buf[nbytes-1] = bitstr[nbytes-1] << gap; shabytes(buf, bitcnt, s); return(savecnt); } /* shawrite: triggers a state update using data in bitstr/bitcnt */ static ULNG shawrite(UCHR *bitstr, ULNG bitcnt, SHA *s) { if (bitcnt < 1) return(0); if (SHA_LO32(s->lenll += bitcnt) < bitcnt) if (SHA_LO32(++s->lenlh) == 0) if (SHA_LO32(++s->lenhl) == 0) s->lenhh++; if (s->blockcnt == 0) return(shadirect(bitstr, bitcnt, s)); else if (s->blockcnt % 8 == 0) return(shabytes(bitstr, bitcnt, s)); else return(shabits(bitstr, bitcnt, s)); } /* shafinish: pads remaining block(s) and computes final digest state */ static void shafinish(SHA *s) { UINT lenpos, lhpos, llpos; lenpos = s->blocksize == SHA1_BLOCK_BITS ? 448 : 896; lhpos = s->blocksize == SHA1_BLOCK_BITS ? 56 : 120; llpos = s->blocksize == SHA1_BLOCK_BITS ? 60 : 124; SETBIT(s->block, s->blockcnt), s->blockcnt++; while (s->blockcnt > lenpos) if (s->blockcnt < s->blocksize) CLRBIT(s->block, s->blockcnt), s->blockcnt++; else s->sha(s, s->block), s->blockcnt = 0; while (s->blockcnt < lenpos) CLRBIT(s->block, s->blockcnt), s->blockcnt++; if (s->blocksize > SHA1_BLOCK_BITS) { w32mem(s->block + 112, s->lenhh); w32mem(s->block + 116, s->lenhl); } w32mem(s->block + lhpos, s->lenlh); w32mem(s->block + llpos, s->lenll); s->sha(s, s->block); } /* shadigest: returns pointer to current digest (binary) */ static UCHR *shadigest(SHA *s) { digcpy(s); return(s->digest); } /* xmap: translation map for hexadecimal encoding */ static char xmap[] = "0123456789abcdef"; /* shahex: returns pointer to current digest (hexadecimal) */ static char *shahex(SHA *s) { int i; char *h; UCHR *d; digcpy(s); s->hex[0] = '\0'; if (HEXLEN((size_t) s->digestlen) >= sizeof(s->hex)) return(s->hex); for (i = 0, h = s->hex, d = s->digest; i < s->digestlen; i++) { *h++ = xmap[(*d >> 4) & 0x0f]; *h++ = xmap[(*d++ ) & 0x0f]; } *h = '\0'; return(s->hex); } /* bmap: translation map for Base 64 encoding */ static char bmap[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /* encbase64: encodes input (0 to 3 bytes) into Base 64 */ static void encbase64(UCHR *in, int n, char *out) { UCHR byte[3] = {0, 0, 0}; out[0] = '\0'; if (n < 1 || n > 3) return; memcpy(byte, in, n); out[0] = bmap[byte[0] >> 2]; out[1] = bmap[((byte[0] & 0x03) << 4) | (byte[1] >> 4)]; out[2] = bmap[((byte[1] & 0x0f) << 2) | (byte[2] >> 6)]; out[3] = bmap[byte[2] & 0x3f]; out[n+1] = '\0'; } /* shabase64: returns pointer to current digest (Base 64) */ static char *shabase64(SHA *s) { int n; UCHR *q; char out[5]; digcpy(s); s->base64[0] = '\0'; if (B64LEN((size_t) 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 */ static int shadsize(SHA *s) { return(s->digestlen); } /* shaalg: returns which SHA algorithm is being used */ static int shaalg(SHA *s) { return(s->alg); } /* shadup: duplicates current digest object */ static SHA *shadup(SHA *s) { SHA *p; SHA_new(0, p, 1, SHA); if (p == NULL) return(NULL); memcpy(p, s, sizeof(SHA)); return(p); } /* shadump: dumps digest object to a human-readable ASCII file */ static int shadump(char *file, SHA *s) { int i, j; SHA_FILE *f; UCHR *p = shadigest(s); if (file == NULL || strlen(file) == 0) f = SHA_stdout(); else if ((f = SHA_open(file, "w")) == NULL) return(0); SHA_fprintf(f, "alg:%d\nH", s->alg); for (i = 0; i < 8; i++) for (j = 0; j < (s->alg <= 256 ? 4 : 8); j++) SHA_fprintf(f, "%s%02x", j==0 ? ":" : "", *p++); SHA_fprintf(f, "\nblock"); for (i = 0; i < (int) (s->blocksize >> 3); i++) SHA_fprintf(f, ":%02x", s->block[i]); SHA_fprintf(f, "\nblockcnt:%u\n", s->blockcnt); SHA_fprintf(f, "lenhh:%lu\nlenhl:%lu\nlenlh:%lu\nlenll:%lu\n", (ULNG) LO32(s->lenhh), (ULNG) LO32(s->lenhl), (ULNG) LO32(s->lenlh), (ULNG) LO32(s->lenll)); if (f != SHA_stdout()) SHA_close(f); return(1); } /* fgetstr: reads (and returns pointer to) next line of file */ static char *fgetstr(char *line, UINT maxsize, SHA_FILE *f) { char *p; if (SHA_feof(f) || maxsize == 0) return(NULL); for (p = line; !SHA_feof(f) && maxsize > 1; maxsize--) if ((*p++ = SHA_getc(f)) == '\n') break; *p = '\0'; return(line); } /* empty: returns true if line contains only whitespace characters */ static int empty(char *line) { char *p; for (p = line; *p; p++) if (!isspace(*p)) return(0); return(1); } /* getval: null-terminates field value, and sets pointer to rest of line */ static char *getval(char *line, char **pprest) { char *p, *v; for (v = line; *v == ':' || isspace(*v); v++) ; for (p = v; *p; p++) { if (*p == ':' || isspace(*p)) { *p++ = '\0'; break; } } *pprest = p; return(p == v ? NULL : v); } /* types of values present in dump file */ #define T_C 1 /* character */ #define T_I 2 /* normal integer */ #define T_L 3 /* 32-bit value */ #define T_Q 4 /* 64-bit value */ /* ldvals: checks next line in dump file against tag, and loads values */ static int ldvals( SHA_FILE *f, const char *tag, int type, void *pval, int reps, int base) { char *p, *pr, line[512]; UCHR *pc = (UCHR *) pval; UINT *pi = (UINT *) pval; W32 *pl = (W32 *) pval; W64 *pq = (W64 *) pval; while ((p = fgetstr(line, sizeof(line), f)) != NULL) if (line[0] != '#' && !empty(line)) break; if (p == NULL || strcmp(getval(line, &pr), tag) != 0) return(0); while (reps-- > 0) { if ((p = getval(pr, &pr)) == NULL) return(1); switch (type) { case T_C: *pc++ = (UCHR) strtoul(p, NULL, base); break; case T_I: *pi++ = (UINT) strtoul(p, NULL, base); break; case T_L: *pl++ = (W32 ) strtoul(p, NULL, base); break; case T_Q: *pq++ = (W64 ) strto64(p ); break; } } return(1); } /* closeall: closes dump file and de-allocates digest object */ static SHA *closeall(SHA_FILE *f, SHA *s) { if (f != NULL && f != SHA_stdin()) SHA_close(f); if (s != NULL) shaclose(s); return(NULL); } /* shaload: creates digest object corresponding to contents of dump file */ static SHA *shaload(char *file) { int alg; SHA *s = NULL; SHA_FILE *f; if (file == NULL || strlen(file) == 0) f = SHA_stdin(); else if ((f = SHA_open(file, "r")) == NULL) return(NULL); if ( /* avoid parens by exploiting precedence of (type)&-> */ !ldvals(f,"alg",T_I,(VP)&alg,1,10) || ((s = shaopen(alg)) == NULL) || !ldvals(f,"H",alg<=SHA256?T_L:T_Q,(VP)s->H,8,16) || !ldvals(f,"block",T_C,(VP)s->block,s->blocksize/8,16) || !ldvals(f,"blockcnt",T_I,(VP)&s->blockcnt,1,10) || (alg <= SHA256 && s->blockcnt >= SHA1_BLOCK_BITS) || (alg >= SHA384 && s->blockcnt >= SHA384_BLOCK_BITS) || !ldvals(f,"lenhh",T_L,(VP)&s->lenhh,1,10) || !ldvals(f,"lenhl",T_L,(VP)&s->lenhl,1,10) || !ldvals(f,"lenlh",T_L,(VP)&s->lenlh,1,10) || !ldvals(f,"lenll",T_L,(VP)&s->lenll,1,10) ) return(closeall(f, s)); if (f != SHA_stdin()) SHA_close(f); return(s); } /* hmacopen: creates a new HMAC-SHA digest object */ static HMAC *hmacopen(int alg, UCHR *key, UINT keylen) { UINT 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 */ static ULNG hmacwrite(UCHR *bitstr, ULNG bitcnt, HMAC *h) { return(shawrite(bitstr, bitcnt, h->isha)); } /* hmacfinish: computes final digest state */ static void hmacfinish(HMAC *h) { shafinish(h->isha); shawrite(shadigest(h->isha), h->isha->digestlen * 8, h->osha); shaclose(h->isha); shafinish(h->osha); } /* hmacdigest: returns pointer to digest (binary) */ static UCHR *hmacdigest(HMAC *h) { return(shadigest(h->osha)); } /* hmachex: returns pointer to digest (hexadecimal) */ static char *hmachex(HMAC *h) { return(shahex(h->osha)); } /* hmacbase64: returns pointer to digest (Base 64) */ static char *hmacbase64(HMAC *h) { return(shabase64(h->osha)); } /* hmacclose: de-allocates digest object */ static int hmacclose(HMAC *h) { if (h != NULL) { shaclose(h->osha); memset(h, 0, sizeof(HMAC)); SHA_free(h); } return(0); } Digest-SHA-5.86/src/sha64bit.h0000644000175000017500000000073112162547442015604 0ustar mshelormshelor/* * 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 #define H0512224 H01 #define H0512256 H01 Digest-SHA-5.86/src/sha64bit.c0000644000175000017500000001075112162547442015602 0ustar mshelormshelor#ifdef SHA_384_512 #undef sha_384_512 #undef W64 #undef strto64 #undef sha512 #undef H0384 #undef H0512 #undef H0512224 #undef H0512256 #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) }; static W64 H0512224[8] = /* SHA-512/224 initial hash value */ { C64(0x8c3d37c819544da2), C64(0x73e1996689dcd4d6), C64(0x1dfab7ae32ff9c82), C64(0x679dd514582f9fcf), C64(0x0f6d2b697bd44da8), C64(0x77e36f7304c48942), C64(0x3f9d85a86a1d36c8), C64(0x1112e6ad91d692a1) }; static W64 H0512256[8] = /* SHA-512/256 initial hash value */ { C64(0x22312194fc2bf72c), C64(0x9f555fa3c84c64c2), C64(0x2393b86b6f53b151), C64(0x963877195940eabd), C64(0x96283ee2a88effe3), C64(0xbe5e1e2553863992), C64(0x2b0199fc2c85b8aa), C64(0x0eb72ddc81c52ca2) }; /* strto64: converts hex string to a 64-bit word */ static W64 strto64(char *s) { char str[2] = {0, 0}; W64 u = C64(0); while (isxdigit(str[0] = *s++)) u = (u << 4) + strtoul(str, NULL, 16); return(u); } static void sha512(SHA *s, unsigned char *block) /* SHA-384/512 transform */ { W64 a, b, c, d, e, f, g, h, T1, T2; 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 */ Digest-SHA-5.86/typemap0000644000175000017500000000005112164252654014615 0ustar mshelormshelorSHA * T_PTROBJ HMAC * T_PTROBJ