debmon/libdigest-sha1-perl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: debmon:master
Branches Tags
debmon:master
debmon:pristine-tar
debmon:upstream
debmon:upstream/2.13
..
compare: debmon:pristine-tar
Branches Tags
debmon:master
debmon:pristine-tar
debmon:upstream
debmon:upstream/2.13

No commits in common. "master" and "pristine-tar" have entirely different histories.
master ... pristine-t

23 changed files with 1 additions and 2784 deletions
Show Stats Expand all files Collapse all files

587
Changes
View File

@ -1,587 +0,0 @@
2010-07-03 Release 2.13
Mike McCauley (1):
Fix memory leak in sha1_transform
2009-05-23 Release 2.12
Gisle Aas (6):
Get rid of the old CVS ids
Avoid "redefined" error for ULONG on Win64
Less optimizations on IRIX [RT#8999]
Clean up the 'git status' output
Mention that SHA-1 might be weak [RT#11880]
Ensure more stuff in the META.yml file [RT#40757]
Steve Peters (1):
Quiet warnings when compiled with -Wwrite-strings [RT#31915]
2006-01-18 Gisle Aas <gisle@ActiveState.com>
Release 2.11
Internal cleanup to avoid some compiler warnings.
2004-04-05 Gisle Aas <gisle@ActiveState.com>
Release 2.10
Restore compatibility with perl-5.004 and perl-5.005.
2004-04-01 Gisle Aas <gisle@ActiveState.com>
Release 2.09
The 2.08 release did not compile with a threaded debugging
perl, because assert() then needs my_perl. Fixed by commenting
out the asserts.
2004-04-01 Gisle Aas <gisle@ActiveState.com>
Release 2.08
Enable PERL_NO_GET_CONTEXT for more more efficient execution
on a threaded perl.
Fix up md5 references. Patch by Ville Skyttä <ville.skytta@iki.fi>.
2003-12-05 Gisle Aas <gisle@ActiveState.com>
Release 2.07
Inherit add_bits() from Digest::base if available.
2003-10-13 Gisle Aas <gisle@ActiveState.com>
Release 2.06
The sha1_transform() function did not check that it was actually
passed any arguments.
Complete self-contained documentation included (copied from
Digest::MD5), since the Digest.pm manpage is not always available.
2003-10-06 Gisle Aas <gisle@ActiveState.com>
Release 2.05
Added missing cast to support C++ compilation. Patch by Jan Dubois.
Document that the sha1_base64 function and the b64digest method
does not pad their result.
2003-07-22 Gisle Aas <gisle@ActiveState.com>
Release 2.04
Don't assume PerlIO_read() works like fread() even though
it was documented like that for perl 5.6. It returns negative
on read failure.
Kill test #3 in t/badfile.t. I don't know a reliable way
to test read failures on a file handle. Seems better not to
test than to make many worry.
2003-07-05 Gisle Aas <gisle@ActiveState.com>
Release 2.03
Implemented sha1_transform, required to implement NIST FIPS 186-2.
Contributed by Mike McCauley <mikem@open.com.au>.
Make it build on 64-bit platforms with 32-bit longs. At least
I hope it will.
Sync up with the Digest::MD5 implementation:
- added clone method
- addfile croaks if it can't read
- the sha1*() functions warn if called as method
or with reference arguments.
2002-12-27 Gisle Aas <gisle@ActiveState.com>
Release 2.02
Make it work when there is a mismatch between the
sizeof(BYTEORDER) and sizeof(long). Based on patch
by Allen Smith <easmith@beatrice.rutgers.edu>.
Support UTF8 strings in newer versions of Perl.
2001-12-30 Gisle Aas <gisle@ActiveState.com>
Release 2.01
Applied trivial win32 fix from Gurusamy Sarathy that
avoids stray temp files left after 'make test'.
2001-03-13 Gisle Aas <gisle@ActiveState.com>
Release 2.00
Broken out of the Digest-MD5-2.12 distribution and made into
a separate dist.
-------------------------------------------------------------------
Changes below from the Digest-MD5 dist.
2000-09-18 Gisle Aas <gisle@ActiveState.com>
Release 2.12
Avoid pointer cast warning for machines with bigger ints
than pointers. Patch by Robin Barker <rmb1@cise.npl.co.uk>.
2000-08-19 Gisle Aas <gisle@ActiveState.com>
Release 2.11
The fallback code introduced in 2.10 did only work for
perl-5.6.0. It should now for for perl5.004 and 5.005
as well. Patch by Ville Skyttä <ville@office.popsystems.com>.
2000-08-18 Gisle Aas <gisle@ActiveState.com>
Release 2.10
Digest::MD5 will now try to fallback to the pure perl
implementation of Digest::Perl::MD5 if bootstrap fails.
Added a bit internal paranoia about casting the IV
in the Digest::MD5 object to the MD5_CTX* pointer.
1999-08-06 Gisle Aas <gisle@aas.no>
Release 2.09
Documentation update.
1999-07-28 Gisle Aas <gisle@aas.no>
Release 2.08
The addfile() methods could trigger a core dump when passed
a filehandle that had failed to open.
1999-04-26 Gisle Aas <gisle@aas.no>
Release 2.07
The Digest::SHA1 module failed on some 64-bit systems, because I
assumed there was a correspondence between the U32 size and
BYTEORDER. This version use 'unsigned long' as Uwe's original
SHA module did.
The module should now work better when liked statically with perl,
because we now use a safer module-loaded test in Digest.pm.
Assume we know the outcome of the alignment test on VMS. Patch by
Chuck Lane <lane@duphy4.physics.drexel.edu>
1999-03-26 Gisle Aas <gisle@aas.no>
Release 2.06
Avoid LONG and BYTE types in SHA.xs as they was in conflict
with similar definitions in <winnt.h>.
Patch by Marko Asplund <aspa@hip.fi> to make the the alignment
test program link successfully with sfio-perl.
Fixed a typo in MD5.xs that might have affected 64-bit systems.
Spotted by Nick Ing-Simmons
1999-03-15 Gisle Aas <gisle@aas.no>
Release 2.05
Included Digest::SHA1 based on Uwe Hollerbach's SHA module.
1999-03-05 Gisle Aas <gisle@aas.no>
Release 2.04
Avoid the -o option when compiling alignment test program
for Win32 as suggested by Gurusamy Sarathy.
DEC Compiler bug workaround. Contributed by D Roland Walker
<walker@ncbi.nlm.nih.gov>
Having references to a local variable called "na" was not
very safe either. Some older versions of Perl can apparently
macroize this into something completely different.
1999-02-27 Gisle Aas <gisle@aas.no>
Release 2.03
Patch from Christopher J. Madsen <chris_madsen@geocities.com> that
should help getting the u32align test program to compile with
Visual C++ 5 on Windows NT.
Got rid of references to PL_na.
1999-01-31 Gisle Aas <gisle@aas.no>
Release 2.02
Added a hints file as workaround for an IRIX compiler bug.
Contributed by D Roland Walker <walker@ncbi.nlm.nih.gov>.
Note that the rfc2202 test can still fail on some DEC Alpha,
because of a compiler bug that affects the perl 'x' operator.
The Digest:: modules should work and be safe to install anyway.
1998-12-18 Gisle Aas <aas@sn.no>
Release 2.01
Some casts and tweaks to make picky compilers more happy.
1998-11-04 Gisle Aas <aas@sn.no>
Release 2.00.
Taken out Digest::SHA1 as this module will be provided from Uwe
Hollerbach later.
Some tweaks to MD2.xs and MD5.xs since "na" disappeared in
perl5.005_53
1998-10-30 Gisle Aas <aas@sn.no>
Release 1.99_60
The 1.99_59 release introduced compilation problems for big-endian
systems with free U32 alignment. Bug reported, and fix suggested
by Paul J. Schinder <schinder@pobox.com>.
1998-10-28 Gisle Aas <aas@sn.no>
Release 1.99_59
Makefile.PL will run a test program to find out if U32 values can
be aligned anywhere. This hopefully cures the core dumps reported
on Solaris and other big endian systems. Thanks to Graham Barr for
debugging this.
1998-10-28 Gisle Aas <aas@sn.no>
Release 1.99_58
Should be very close to a 2.00 release now. Need some success
reports from people running on big-endian machines first I think.
Added a Digest::MD2 implementation.
Wrote Digest.pm documentation. This define the interface that all
Digest:: modules should provide.
Avoided some code duplication in MD5.xs
Fixed typo, that prevented Digest::SHA1::sha1_base64() from working.
1998-10-27 Gisle Aas <aas@sn.no>
Release 1.99_57
Rewritten most of the MD5 C code to make it real fast (especially
on little-endian machines without alignment restrictions for U32).
Compared to MD5-1.7 we can process files 4 times as fast and we
digest small stuff in memory 7 times faster. I came to these
conclusions after these tests (gcc -O2, i586, Linux):
First tested calculation of the digest of a 31 MB file, using
perl -le 'print Digest::MD5->new->addfile(*STDIN)->hexdigest'
and similar stuff:
MD5-1.7: 21.06s
Digest::MD5-1.99_57: 5.23s
md5sum (GNU textutils): 4.90s
As you can see, we do nearly as good as the md5sum program. I
think the reason we don't beat md5sum is that perl always insist on
loading extra modules like Config.pm, Carp.pm, strict.pm, vars.pm,
AutoLoader.pm and DynaLoader.pm. When I simply wrapped the MD5.xs
hasher code in a C program I managed to process the file in 4.68s.
Then we calculated the digest of the same 6 byte sting, 20000
times:
MD5-1.7: 11.81s
Digest::MD5-1.99_57: 1.68s
Digest::MD5 benefit from making this into a plain procedure call
instead of a static method call.
Other changes in this release are:
Documentation update
Internal MD5.xs cleanup.
$md5->digest will automatically reset now.
Digest::HMAC methods add() and addfile() did not return the
correct object.
Added Digest.pm loading module. I am not sure this is a good idea.
Added Digest::SHA1 and Digest::HMAC_SHA1 module. The Digest::SHA1
module is just a wrapper around SHA.pm. I hope to get the author
of SHA.pm to move his module to the Digest:: category.
1998-10-25 Gisle Aas <aas@sn.no>
Release 1.99_56
Fix memcpy_byteswap() function in MD5.xs. Must be careful with
htovl() as it might evaluate its arguments more than once.
1998-10-25 Gisle Aas <aas@sn.no>
Release 1.99_55
Grahams HMAC_MD5.pm splitted into two modules. Digest::HMAC and
Digest::HMAC_MD5. Also provide functional interface. Documentation
is still lacking.
Included RFC 2202 based test for HMAC-MD5.
1998-10-24 Gisle Aas <aas@sn.no>
Release 1.99_54
Included HMAC_MD5.pm, contributed by Graham Barr <gbarr@ti.com>.
I have a hard time to make up my mind :-) md5_bin() renamed back
to md5(). Functions are not exported by default any more.
Try to Encode/Decode with memcpy_byteswap for 32-bit big-endian
machines.
1998-10-23 Gisle Aas <aas@sn.no>
Release 1.99_53
Renamed core module as Digest::MD5. Leave a MD5.pm stub for
legacy code.
The md5() function renamed as md5_bin().
The constructor, Digest::MD5->new, no longer takes any extra
arguments.
Added some new tests.
Updated the documentation.
$md5->b64digest implemented with same base64 encoder as md5_base64.
1998-10-23 Gisle Aas <aas@sn.no>
Release 1.99_52
Patch from Graham Barr which make it work for big-endian machines
again.
1998-10-22 Gisle Aas <aas@sn.no>
Release 1.99_51
The MD5 class is now subclassable.
The add() and addfile() methods now return $self.
The reset() method is just an alias for new().
The constructor (MD5->new) now takes optional arguments which are
automatically added. It means that we can now write:
MD5->new($data)->hexdigest;
New $md5->b64digest method.
New functions that are exported on request: md5, md5_hex, md5_base64
Included RFC 1321
Barely started to update the documentation.
1998-10-22 Gisle Aas <aas@sn.no>
Release 1.99_50
Much better performance (more than twice as fast now). Mostly
because we use Copy/Zero instead of the original MD5_memcpy and
MD5_memset functions.
The addfile() and hexdigest() methods are now XS implemented.
All RSA functions now included in MD5.xs and made static.
Use perl's Copy/Zero.
Random cleanup, simplifications and reformatting.
Merged things better with the perl configuration.
Neil Winton's versions below:
*** 96/06/20 Version 1.7
MD5 is now completely 64-bit clean (I hope). The basic MD5 code uses
32-bit quantities and requires a typedef UINT4 to be defined in
global.h. Perl configuration data (the value of BYTEORDER) is used to
determine if unsigned longs have 4 or 8 bytes. On 64-bit platforms (eg
DEC Alpha) then it assumes that "unsigned int" will be a 32-bit type.
If this is incorrect then adding -DUINT4_IS_LONG to the DEFINES line in
Makefile.PL will override this.
On some machines (at least Cray that I know of) there is no 32-bit
integer type. In this case defining TRUNCATE_UINT4 (which is done
automatically for a Cray) will ensure that 64-bit values are masked
down to 32 bits. I have done my best to test this but without easy
access to a true 64-bit machine I can not totally guarantee it (unless
anyone wants to lend me a spare Cray :-)
There is one remaining limitation for 64-bit enabled processors. The
amount of data passed to any single call to the underlying MD5
routines is limited to (2^32 - 1) bytes -- that's 4 gigabytes. I'm
sorry if that's a real problem for you ...
And finally, a minor compilation warning (unsigned char * used with
function having char * prototype) has also been eliminated.
*** 96/04/09 Version 1.6
Re-generated module framework using h2xs to pick up the latest module
conventions for versions etc. You can now say "use MD5 1.6;" and things
should work correctly. MD5.pod has been integrated into MD5.pm and
CHANGES renamed to Changes. There is a fairly comprehensive test.pl
which can be invoked via "make test". There are no functional changes
to the MD5 routines themselves.
*** 96/03/14 Version 1.5.3
Fixed addfile method to accept type-glob references for the file-handle
(eg \*STDOUT). This is more consistent with other routines and is now the
recommended way of passing file-handles. The documentation now gives more
examples as to how the routines might be used.
*** 96/03/12 Version 1.5.2
Minor fixes from Christopher J Madsen <madsen@computek.net> to provide
support for building on OS/2 (and to work around a perl -w bug).
Remove warning about possible difference between add('foo', 'bar') and
add('foobar'). This is not true (it may have been true in the earliest
version of the module but is no longer the case).
*** 96/03/08 Version 1.5.1
Add CHANGES file to make it easier for people to figure out what has
been going on. (Meant to do this as part of 1.5)
*** 96/03/05 Version 1.5
Add hash() and hexhash() methods at the suggestion/request of Gary
Howland <gary@kampai.euronet.nl> before inclusion in a wider library
of cryptography modules.
*** 96/02/27 Version 1.4
Finally fixed the pesky Solaris dynamic loading bug. All kudos to Ken
Pizzini <kenp@spry.com>!
*** 95/11/29 Version 1.3.1
Add explanations of current known problems.
*** 95/06/02 Version 1.3
Fix problems with scope resolution in addfile() reported by
Jean-Claude Giese <Jean-Claude.Giese@loria.fr>. Basically ARGV is
always implicitly in package main while other filehandles aren't.
*** 95/05/23 Version 1.2.1
[Changes pre 1.2.1 not recorded]

14
MANIFEST
View File

@ -1,14 +0,0 @@
Changes
MANIFEST
Makefile.PL
README
SHA1.pm
SHA1.xs
fip180-1.gif
fip180-1.html
hints/irix_6.pl
t/badfile.t
t/bits.t
t/sha1.t
typemap
META.yml Module meta-data (added by MakeMaker)

24
META.yml
View File

@ -1,24 +0,0 @@
--- #YAML:1.0
name: Digest-SHA1
version: 2.13
abstract: Perl interface to the SHA-1 algorithm
author:
- Gisle Aas <gisle@activestate.com>
license: perl
distribution_type: module
configure_requires:
ExtUtils::MakeMaker: 0
build_requires:
ExtUtils::MakeMaker: 0
requires:
Digest::base: 1.00
perl: 5.004
no_index:
directory:
- t
- inc
generated_by: ExtUtils::MakeMaker version 6.56
meta-spec:
url: http://module-build.sourceforge.net/META-spec-v1.4.html
version: 1.4
repository: http://github.com/gisle/digest-sha1

41
Makefile.PL
View File

@ -1,41 +0,0 @@
require 5.004;
use ExtUtils::MakeMaker;
WriteMakefile(
'NAME' => 'Digest::SHA1',
'VERSION_FROM' => 'SHA1.pm',
'ABSTRACT' => 'Perl interface to the SHA-1 algorithm',
'AUTHOR' => 'Gisle Aas <gisle@activestate.com>',
'LICENSE' => "perl",
'MIN_PERL_VERSION' => 5.004,
'PREREQ_PM' => {
'Digest::base' => '1.00',
},
'META_MERGE' => {
repository => 'http://github.com/gisle/digest-sha1',
},
'dist' => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', },
);
BEGIN {
# compatibility with older versions of MakeMaker
my $developer = -f "NOTES.txt";
my %mm_req = (
LICENCE => 6.31,
META_MERGE => 6.45,
META_ADD => 6.45,
MIN_PERL_VERSION => 6.48,
);
undef(*WriteMakefile);
*WriteMakefile = sub {
my %arg = @_;
for (keys %mm_req) {
unless (eval { ExtUtils::MakeMaker->VERSION($mm_req{$_}) }) {
warn "$_ $@" if $developer;
delete $arg{$_};
}
}
ExtUtils::MakeMaker::WriteMakefile(%arg);
};
}

14
README
View File

@ -1,14 +0,0 @@
The Digest::SHA1 module allows you to use the NIST SHA-1 message
digest algorithm from within Perl programs. The algorithm takes as
input a message of arbitrary length and produces as output a 160-bit
"fingerprint" or "message digest" of the input.
SHA1 is described at <http://www.itl.nist.gov/fipspubs/fip180-1.htm>
You will need Perl version 5.004 or better to install this module.
Copyright 1999-2004 Gisle Aas.
Copyright 1997 Uwe Hollerbach.
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

246
SHA1.pm
View File

@ -1,246 +0,0 @@
package Digest::SHA1;
use strict;
use vars qw($VERSION @ISA @EXPORT_OK);
$VERSION = '2.13';
require Exporter;
*import = \&Exporter::import;
@EXPORT_OK = qw(sha1 sha1_hex sha1_base64 sha1_transform);
require DynaLoader;
@ISA=qw(DynaLoader);
eval {
require Digest::base;
push(@ISA, 'Digest::base');
};
if ($@) {
my $err = $@;
*add_bits = sub { die $err };
}
Digest::SHA1->bootstrap($VERSION);
1;
__END__
=head1 NAME
Digest::SHA1 - Perl interface to the SHA-1 algorithm
=head1 SYNOPSIS
# Functional style
use Digest::SHA1 qw(sha1 sha1_hex sha1_base64);
$digest = sha1($data);
$digest = sha1_hex($data);
$digest = sha1_base64($data);
$digest = sha1_transform($data);
# OO style
use Digest::SHA1;
$sha1 = Digest::SHA1->new;
$sha1->add($data);
$sha1->addfile(*FILE);
$sha1_copy = $sha1->clone;
$digest = $sha1->digest;
$digest = $sha1->hexdigest;
$digest = $sha1->b64digest;
$digest = $sha1->transform;
=head1 DESCRIPTION
The C<Digest::SHA1> module allows you to use the NIST SHA-1 message
digest algorithm from within Perl programs. The algorithm takes as
input a message of arbitrary length and produces as output a 160-bit
"fingerprint" or "message digest" of the input.
In 2005, security flaws were identified in SHA-1, namely that a possible
mathematical weakness might exist, indicating that a stronger hash function
would be desirable. The L<Digest::SHA> module implements the stronger
algorithms in the SHA family.
The C<Digest::SHA1> module provide a procedural interface for simple
use, as well as an object oriented interface that can handle messages
of arbitrary length and which can read files directly.
=head1 FUNCTIONS
The following functions can be exported from the C<Digest::SHA1>
module. No functions are exported by default.
=over 4
=item sha1($data,...)
This function will concatenate all arguments, calculate the SHA-1
digest of this "message", and return it in binary form. The returned
string will be 20 bytes long.
The result of sha1("a", "b", "c") will be exactly the same as the
result of sha1("abc").
=item sha1_hex($data,...)
Same as sha1(), but will return the digest in hexadecimal form. The
length of the returned string will be 40 and it will only contain
characters from this set: '0'..'9' and 'a'..'f'.
=item sha1_base64($data,...)
Same as sha1(), but will return the digest as a base64 encoded string.
The length of the returned string will be 27 and it will only contain
characters from this set: 'A'..'Z', 'a'..'z', '0'..'9', '+' and
'/'.
Note that the base64 encoded string returned is not padded to be a
multiple of 4 bytes long. If you want interoperability with other
base64 encoded sha1 digests you might want to append the redundant
string "=" to the result.
=item sha1_transform($data)
Implements the basic SHA1 transform on a 64 byte block. The $data
argument and the returned $digest are in binary form. This algorithm
is used in NIST FIPS 186-2
=back
=head1 METHODS
The object oriented interface to C<Digest::SHA1> is described in this
section. After a C<Digest::SHA1> object has been created, you will add
data to it and finally ask for the digest in a suitable format. A
single object can be used to calculate multiple digests.
The following methods are provided:
=over 4
=item $sha1 = Digest::SHA1->new
The constructor returns a new C<Digest::SHA1> object which encapsulate
the state of the SHA-1 message-digest algorithm.
If called as an instance method (i.e. $sha1->new) it will just reset the
state the object to the state of a newly created object. No new
object is created in this case.
=item $sha1->reset
This is just an alias for $sha1->new.
=item $sha1->clone
This a copy of the $sha1 object. It is useful when you do not want to
destroy the digests state, but need an intermediate value of the
digest, e.g. when calculating digests iteratively on a continuous data
stream. Example:
my $sha1 = Digest::SHA1->new;
while (<>) {
$sha1->add($_);
print "Line $.: ", $sha1->clone->hexdigest, "\n";
}
=item $sha1->add($data,...)
The $data provided as argument are appended to the message we
calculate the digest for. The return value is the $sha1 object itself.
All these lines will have the same effect on the state of the $sha1
object:
$sha1->add("a"); $sha1->add("b"); $sha1->add("c");
$sha1->add("a")->add("b")->add("c");
$sha1->add("a", "b", "c");
$sha1->add("abc");
=item $sha1->addfile($io_handle)
The $io_handle will be read until EOF and its content appended to the
message we calculate the digest for. The return value is the $sha1
object itself.
The addfile() method will croak() if it fails reading data for some
reason. If it croaks it is unpredictable what the state of the $sha1
object will be in. The addfile() method might have been able to read
the file partially before it failed. It is probably wise to discard
or reset the $sha1 object if this occurs.
In most cases you want to make sure that the $io_handle is in
C<binmode> before you pass it as argument to the addfile() method.
=item $sha1->add_bits($data, $nbits)
=item $sha1->add_bits($bitstring)
This implementation of SHA-1 only supports byte oriented input so you
might only add bits as multiples of 8. If you need bit level support
please consider using the C<Digest::SHA> module instead. The
add_bits() method is provided here for compatibility with other digest
implementations. See L<Digest> for description of the arguments that
add_bits() take.
=item $sha1->digest
Return the binary digest for the message. The returned string will be
20 bytes long.
Note that the C<digest> operation is effectively a destructive,
read-once operation. Once it has been performed, the C<Digest::SHA1>
object is automatically C<reset> and can be used to calculate another
digest value. Call $sha1->clone->digest if you want to calculate the
digest without reseting the digest state.
=item $sha1->hexdigest
Same as $sha1->digest, but will return the digest in hexadecimal
form. The length of the returned string will be 40 and it will only
contain characters from this set: '0'..'9' and 'a'..'f'.
=item $sha1->b64digest
Same as $sha1->digest, but will return the digest as a base64 encoded
string. The length of the returned string will be 27 and it will only
contain characters from this set: 'A'..'Z', 'a'..'z', '0'..'9', '+'
and '/'.
The base64 encoded string returned is not padded to be a multiple of 4
bytes long. If you want interoperability with other base64 encoded
SHA-1 digests you might want to append the string "=" to the result.
=back
=head1 SEE ALSO
L<Digest>, L<Digest::HMAC_SHA1>, L<Digest::SHA>, L<Digest::MD5>
http://www.itl.nist.gov/fipspubs/fip180-1.htm
http://en.wikipedia.org/wiki/SHA_hash_functions
=head1 COPYRIGHT
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
Copyright 1999-2004 Gisle Aas.
Copyright 1997 Uwe Hollerbach.
=head1 AUTHORS
Peter C. Gutmann,
Uwe Hollerbach <uh@alumni.caltech.edu>,
Gisle Aas <gisle@aas.no>
=cut

622
SHA1.xs
View File

@ -1,622 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#define PERL_NO_GET_CONTEXT /* we want efficiency */
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#ifdef __cplusplus
}
#endif
#ifndef PERL_VERSION
# include <patchlevel.h>
# if !(defined(PERL_VERSION) || (SUBVERSION > 0 && defined(PATCHLEVEL)))
# include <could_not_find_Perl_patchlevel.h>
# endif
# define PERL_REVISION 5
# define PERL_VERSION PATCHLEVEL
# define PERL_SUBVERSION SUBVERSION
#endif
#if PERL_VERSION <= 4 && !defined(PL_dowarn)
#define PL_dowarn dowarn
#endif
#ifdef G_WARN_ON
#define DOWARN (PL_dowarn & G_WARN_ON)
#else
#define DOWARN PL_dowarn
#endif
#ifdef SvPVbyte
#if PERL_REVISION == 5 && PERL_VERSION < 7
/* SvPVbyte does not work in perl-5.6.1, borrowed version for 5.7.3 */
#undef SvPVbyte
#define SvPVbyte(sv, lp) \
((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
? ((lp = SvCUR(sv)), SvPVX(sv)) : my_sv_2pvbyte(aTHX_ sv, &lp))
static char *
my_sv_2pvbyte(pTHX_ register SV *sv, STRLEN *lp)
{
sv_utf8_downgrade(sv,0);
return SvPV(sv,*lp);
}
#endif
#else
#define SvPVbyte SvPV
#endif
#ifndef dTHX
#define pTHX_
#define aTHX_
#endif
/* NIST Secure Hash Algorithm */
/* heavily modified by Uwe Hollerbach <uh@alumni.caltech edu> */
/* from Peter C. Gutmann's implementation as found in */
/* Applied Cryptography by Bruce Schneier */
/* Further modifications to include the "UNRAVEL" stuff, below */
/* This code is in the public domain */
/* Useful defines & typedefs */
#if defined(U64TYPE) && (defined(USE_64_BIT_INT) || ((BYTEORDER != 0x1234) && (BYTEORDER != 0x4321)))
typedef U64TYPE ULONGx;
# if BYTEORDER == 0x1234
# undef BYTEORDER
# define BYTEORDER 0x12345678
# elif BYTEORDER == 0x4321
# undef BYTEORDER
# define BYTEORDER 0x87654321
# endif
#else
typedef unsigned long ULONGx; /* 32-or-more-bit quantity */
#endif
#define SHA_BLOCKSIZE 64
#define SHA_DIGESTSIZE 20
typedef struct {
ULONGx digest[5]; /* message digest */
ULONGx count_lo, count_hi; /* 64-bit bit count */
U8 data[SHA_BLOCKSIZE]; /* SHA data buffer */
int local; /* unprocessed amount in data */
} SHA_INFO;
/* UNRAVEL should be fastest & biggest */
/* UNROLL_LOOPS should be just as big, but slightly slower */
/* both undefined should be smallest and slowest */
#define SHA_VERSION 1
#define UNRAVEL
/* #define UNROLL_LOOPS */
/* SHA f()-functions */
#define f1(x,y,z) ((x & y) | (~x & z))
#define f2(x,y,z) (x ^ y ^ z)
#define f3(x,y,z) ((x & y) | (x & z) | (y & z))
#define f4(x,y,z) (x ^ y ^ z)
/* SHA constants */
#define CONST1 0x5a827999L
#define CONST2 0x6ed9eba1L
#define CONST3 0x8f1bbcdcL
#define CONST4 0xca62c1d6L
/* truncate to 32 bits -- should be a null op on 32-bit machines */
#define T32(x) ((x) & 0xffffffffL)
/* 32-bit rotate */
#define R32(x,n) T32(((x << n) | (x >> (32 - n))))
/* the generic case, for when the overall rotation is not unraveled */
#define FG(n) \
T = T32(R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n); \
E = D; D = C; C = R32(B,30); B = A; A = T
/* specific cases, for when the overall rotation is unraveled */
#define FA(n) \
T = T32(R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n); B = R32(B,30)
#define FB(n) \
E = T32(R32(T,5) + f##n(A,B,C) + D + *WP++ + CONST##n); A = R32(A,30)
#define FC(n) \
D = T32(R32(E,5) + f##n(T,A,B) + C + *WP++ + CONST##n); T = R32(T,30)
#define FD(n) \
C = T32(R32(D,5) + f##n(E,T,A) + B + *WP++ + CONST##n); E = R32(E,30)
#define FE(n) \
B = T32(R32(C,5) + f##n(D,E,T) + A + *WP++ + CONST##n); D = R32(D,30)
#define FT(n) \
A = T32(R32(B,5) + f##n(C,D,E) + T + *WP++ + CONST##n); C = R32(C,30)
static void sha_transform(SHA_INFO *sha_info)
{
int i;
U8 *dp;
ULONGx T, A, B, C, D, E, W[80], *WP;
dp = sha_info->data;
/*
the following makes sure that at least one code block below is
traversed or an error is reported, without the necessity for nested
preprocessor if/else/endif blocks, which are a great pain in the
nether regions of the anatomy...
*/
#undef SWAP_DONE
#if BYTEORDER == 0x1234
#define SWAP_DONE
/* assert(sizeof(ULONGx) == 4); */
for (i = 0; i < 16; ++i) {
T = *((ULONGx *) dp);
dp += 4;
W[i] = ((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) |
((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff);
}
#endif
#if BYTEORDER == 0x4321
#define SWAP_DONE
/* assert(sizeof(ULONGx) == 4); */
for (i = 0; i < 16; ++i) {
T = *((ULONGx *) dp);
dp += 4;
W[i] = T32(T);
}
#endif
#if BYTEORDER == 0x12345678
#define SWAP_DONE
/* assert(sizeof(ULONGx) == 8); */
for (i = 0; i < 16; i += 2) {
T = *((ULONGx *) dp);
dp += 8;
W[i] = ((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) |
((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff);
T >>= 32;
W[i+1] = ((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) |
((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff);
}
#endif
#if BYTEORDER == 0x87654321
#define SWAP_DONE
/* assert(sizeof(ULONGx) == 8); */
for (i = 0; i < 16; i += 2) {
T = *((ULONGx *) dp);
dp += 8;
W[i] = T32(T >> 32);
W[i+1] = T32(T);
}
#endif
#ifndef SWAP_DONE
#error Unknown byte order -- you need to add code here
#endif /* SWAP_DONE */
for (i = 16; i < 80; ++i) {
W[i] = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
#if (SHA_VERSION == 1)
W[i] = R32(W[i], 1);
#endif /* SHA_VERSION */
}
A = sha_info->digest[0];
B = sha_info->digest[1];
C = sha_info->digest[2];
D = sha_info->digest[3];
E = sha_info->digest[4];
WP = W;
#ifdef UNRAVEL
FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1); FC(1); FD(1);
FE(1); FT(1); FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1);
FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2); FE(2); FT(2);
FA(2); FB(2); FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2);
FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3); FA(3); FB(3);
FC(3); FD(3); FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3);
FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4); FC(4); FD(4);
FE(4); FT(4); FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4);
sha_info->digest[0] = T32(sha_info->digest[0] + E);
sha_info->digest[1] = T32(sha_info->digest[1] + T);
sha_info->digest[2] = T32(sha_info->digest[2] + A);
sha_info->digest[3] = T32(sha_info->digest[3] + B);
sha_info->digest[4] = T32(sha_info->digest[4] + C);
#else /* !UNRAVEL */
#ifdef UNROLL_LOOPS
FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
#else /* !UNROLL_LOOPS */
for (i = 0; i < 20; ++i) { FG(1); }
for (i = 20; i < 40; ++i) { FG(2); }
for (i = 40; i < 60; ++i) { FG(3); }
for (i = 60; i < 80; ++i) { FG(4); }
#endif /* !UNROLL_LOOPS */
sha_info->digest[0] = T32(sha_info->digest[0] + A);
sha_info->digest[1] = T32(sha_info->digest[1] + B);
sha_info->digest[2] = T32(sha_info->digest[2] + C);
sha_info->digest[3] = T32(sha_info->digest[3] + D);
sha_info->digest[4] = T32(sha_info->digest[4] + E);
#endif /* !UNRAVEL */
}
/* initialize the SHA digest */
static void sha_init(SHA_INFO *sha_info)
{
sha_info->digest[0] = 0x67452301L;
sha_info->digest[1] = 0xefcdab89L;
sha_info->digest[2] = 0x98badcfeL;
sha_info->digest[3] = 0x10325476L;
sha_info->digest[4] = 0xc3d2e1f0L;
sha_info->count_lo = 0L;
sha_info->count_hi = 0L;
sha_info->local = 0;
}
/* update the SHA digest */
static void sha_update(SHA_INFO *sha_info, U8 *buffer, int count)
{
int i;
ULONGx clo;
clo = T32(sha_info->count_lo + ((ULONGx) count << 3));
if (clo < sha_info->count_lo) {
++sha_info->count_hi;
}
sha_info->count_lo = clo;
sha_info->count_hi += (ULONGx) count >> 29;
if (sha_info->local) {
i = SHA_BLOCKSIZE - sha_info->local;
if (i > count) {
i = count;
}
memcpy(((U8 *) sha_info->data) + sha_info->local, buffer, i);
count -= i;
buffer += i;
sha_info->local += i;
if (sha_info->local == SHA_BLOCKSIZE) {
sha_transform(sha_info);
} else {
return;
}
}
while (count >= SHA_BLOCKSIZE) {
memcpy(sha_info->data, buffer, SHA_BLOCKSIZE);
buffer += SHA_BLOCKSIZE;
count -= SHA_BLOCKSIZE;
sha_transform(sha_info);
}
memcpy(sha_info->data, buffer, count);
sha_info->local = count;
}
static void sha_transform_and_copy(unsigned char digest[20], SHA_INFO *sha_info)
{
sha_transform(sha_info);
digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);
digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);
digest[ 2] = (unsigned char) ((sha_info->digest[0] >> 8) & 0xff);
digest[ 3] = (unsigned char) ((sha_info->digest[0] ) & 0xff);
digest[ 4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);
digest[ 5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);
digest[ 6] = (unsigned char) ((sha_info->digest[1] >> 8) & 0xff);
digest[ 7] = (unsigned char) ((sha_info->digest[1] ) & 0xff);
digest[ 8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);
digest[ 9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);
digest[10] = (unsigned char) ((sha_info->digest[2] >> 8) & 0xff);
digest[11] = (unsigned char) ((sha_info->digest[2] ) & 0xff);
digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);
digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);
digest[14] = (unsigned char) ((sha_info->digest[3] >> 8) & 0xff);
digest[15] = (unsigned char) ((sha_info->digest[3] ) & 0xff);
digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);
digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);
digest[18] = (unsigned char) ((sha_info->digest[4] >> 8) & 0xff);
digest[19] = (unsigned char) ((sha_info->digest[4] ) & 0xff);
}
/* finish computing the SHA digest */
static void sha_final(unsigned char digest[20], SHA_INFO *sha_info)
{
int count;
ULONGx lo_bit_count, hi_bit_count;
lo_bit_count = sha_info->count_lo;
hi_bit_count = sha_info->count_hi;
count = (int) ((lo_bit_count >> 3) & 0x3f);
((U8 *) sha_info->data)[count++] = 0x80;
if (count > SHA_BLOCKSIZE - 8) {
memset(((U8 *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count);
sha_transform(sha_info);
memset((U8 *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
} else {
memset(((U8 *) sha_info->data) + count, 0,
SHA_BLOCKSIZE - 8 - count);
}
sha_info->data[56] = (U8)((hi_bit_count >> 24) & 0xff);
sha_info->data[57] = (U8)((hi_bit_count >> 16) & 0xff);
sha_info->data[58] = (U8)((hi_bit_count >> 8) & 0xff);
sha_info->data[59] = (U8)((hi_bit_count >> 0) & 0xff);
sha_info->data[60] = (U8)((lo_bit_count >> 24) & 0xff);
sha_info->data[61] = (U8)((lo_bit_count >> 16) & 0xff);
sha_info->data[62] = (U8)((lo_bit_count >> 8) & 0xff);
sha_info->data[63] = (U8)((lo_bit_count >> 0) & 0xff);
sha_transform_and_copy(digest, sha_info);
}
/*----------------------------------------------------------------*/
#ifndef INT2PTR
#define INT2PTR(any,d) (any)(d)
#endif
static SHA_INFO* get_sha_info(pTHX_ SV* sv)
{
if (sv_derived_from(sv, "Digest::SHA1"))
return INT2PTR(SHA_INFO*, SvIV(SvRV(sv)));
croak("Not a reference to a Digest::SHA1 object");
return (SHA_INFO*)0; /* some compilers insist on a return value */
}
static char* hex_20(const unsigned char* from, char* to)
{
static const char *hexdigits = "0123456789abcdef";
const unsigned char *end = from + 20;
char *d = to;
while (from < end) {
*d++ = hexdigits[(*from >> 4)];
*d++ = hexdigits[(*from & 0x0F)];
from++;
}
*d = '\0';
return to;
}
static char* base64_20(const unsigned char* from, char* to)
{
static const char* base64 =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const unsigned char *end = from + 20;
unsigned char c1, c2, c3;
char *d = to;
while (1) {
c1 = *from++;
c2 = *from++;
*d++ = base64[c1>>2];
*d++ = base64[((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4)];
if (from == end) {
*d++ = base64[(c2 & 0xF) << 2];
break;
}
c3 = *from++;
*d++ = base64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
*d++ = base64[c3 & 0x3F];
}
*d = '\0';
return to;
}
/* Formats */
#define F_BIN 0
#define F_HEX 1
#define F_B64 2
static SV* make_mortal_sv(pTHX_ const unsigned char *src, int type)
{
STRLEN len;
char result[41];
char *ret;
switch (type) {
case F_BIN:
ret = (char*)src;
len = 20;
break;
case F_HEX:
ret = hex_20(src, result);
len = 40;
break;
case F_B64:
ret = base64_20(src, result);
len = 27;
break;
default:
croak("Bad convertion type (%d)", type);
break;
}
return sv_2mortal(newSVpv(ret,len));
}
/********************************************************************/
typedef PerlIO* InputStream;
MODULE = Digest::SHA1 PACKAGE = Digest::SHA1
PROTOTYPES: DISABLE
void
new(xclass)
SV* xclass
PREINIT:
SHA_INFO* context;
PPCODE:
if (!SvROK(xclass)) {
STRLEN my_na;
char *sclass = SvPV(xclass, my_na);
New(55, context, 1, SHA_INFO);
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), sclass, (void*)context);
SvREADONLY_on(SvRV(ST(0)));
} else {
context = get_sha_info(aTHX_ xclass);
}
sha_init(context);
XSRETURN(1);
void
clone(self)
SV* self
PREINIT:
SHA_INFO* cont = get_sha_info(aTHX_ self);
const char *myname = sv_reftype(SvRV(self),TRUE);
SHA_INFO* context;
PPCODE:
New(55, context, 1, SHA_INFO);
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), myname , (void*)context);
SvREADONLY_on(SvRV(ST(0)));
memcpy(context,cont,sizeof(SHA_INFO));
XSRETURN(1);
void
DESTROY(context)
SHA_INFO* context
CODE:
Safefree(context);
void
add(self, ...)
SV* self
PREINIT:
SHA_INFO* context = get_sha_info(aTHX_ self);
int i;
unsigned char *data;
STRLEN len;
PPCODE:
for (i = 1; i < items; i++) {
data = (unsigned char *)(SvPVbyte(ST(i), len));
sha_update(context, data, len);
}
XSRETURN(1); /* self */
void
addfile(self, fh)
SV* self
InputStream fh
PREINIT:
SHA_INFO* context = get_sha_info(aTHX_ self);
unsigned char buffer[4096];
int n;
CODE:
if (fh) {
/* Process blocks until EOF or error */
while ( (n = PerlIO_read(fh, buffer, sizeof(buffer))) > 0) {
sha_update(context, buffer, n);
}
if (PerlIO_error(fh)) {
croak("Reading from filehandle failed");
}
}
else {
croak("No filehandle passed");
}
XSRETURN(1); /* self */
void
digest(context)
SHA_INFO* context
ALIAS:
Digest::SHA1::digest = F_BIN
Digest::SHA1::hexdigest = F_HEX
Digest::SHA1::b64digest = F_B64
PREINIT:
unsigned char digeststr[20];
PPCODE:
sha_final(digeststr, context);
sha_init(context); /* In case it is reused */
ST(0) = make_mortal_sv(aTHX_ digeststr, ix);
XSRETURN(1);
void
sha1(...)
ALIAS:
Digest::SHA1::sha1 = F_BIN
Digest::SHA1::sha1_hex = F_HEX
Digest::SHA1::sha1_base64 = F_B64
PREINIT:
SHA_INFO ctx;
int i;
unsigned char *data;
STRLEN len;
unsigned char digeststr[20];
PPCODE:
sha_init(&ctx);
if (DOWARN) {
const char *msg = 0;
if (items == 1) {
if (SvROK(ST(0))) {
SV* sv = SvRV(ST(0));
if (SvOBJECT(sv) && strEQ(HvNAME(SvSTASH(sv)), "Digest::SHA1"))
msg = "probably called as method";
else
msg = "called with reference argument";
}
}
else if (items > 1) {
data = (unsigned char *)SvPVbyte(ST(0), len);
if (len == 12 && memEQ("Digest::SHA1", data, 12)) {
msg = "probably called as class method";
}
}
if (msg) {
const char *f = (ix == F_BIN) ? "sha1" :
(ix == F_HEX) ? "sha1_hex" : "sha1_base64";
warn("&Digest::SHA1::%s function %s", f, msg);
}
}
for (i = 0; i < items; i++) {
data = (unsigned char *)(SvPVbyte(ST(i), len));
sha_update(&ctx, data, len);
}
sha_final(digeststr, &ctx);
ST(0) = make_mortal_sv(aTHX_ digeststr, ix);
XSRETURN(1);
void
sha1_transform(data)
SV* data
PREINIT:
SHA_INFO ctx;
unsigned char *data_pv;
unsigned char test[64];
STRLEN len;
unsigned char digeststr[20];
PPCODE:
sha_init(&ctx);
memset (test, 0, 64);
data_pv = (unsigned char *)(SvPVbyte(data, len));
memcpy (test, data_pv, len);
memcpy ((&ctx)->data, test, 64);
sha_transform_and_copy(digeststr, &ctx);
ST(0) = sv_2mortal(newSVpv((char*)digeststr, 20));
XSRETURN(1);

11
debian/changelog vendored
View File

@ -1,11 +0,0 @@
libdigest-sha1-perl (2.13-2) UNRELEASED; urgency=medium
* build for debian
-- Mario Fetka <mario.fetka@gmail.com> Tue, 31 Oct 2017 15:15:38 +0100
libdigest-sha1-perl (2.13-1~gekkio1) trusty; urgency=low
* Initial Release.
-- Joonas Javanainen <joonas.javanainen@gmail.com> Mon, 24 Mar 2014 13:17:54 +0200

1
debian/compat vendored
View File

@ -1 +0,0 @@
9

26
debian/control vendored
View File

@ -1,26 +0,0 @@
Source: libdigest-sha1-perl
Section: perl
Priority: optional
Maintainer: Joonas Javanainen <joonas.javanainen@gmail.com>
Build-Depends: debhelper (>= 9.20120312),
perl
Standards-Version: 3.9.4
Homepage: https://metacpan.org/release/Digest-SHA1
Package: libdigest-sha1-perl
Architecture: any
Depends: ${misc:Depends}, ${perl:Depends}, ${shlibs:Depends}
Description: Perl interface to the SHA-1 algorithm
The Digest::SHA1 module allows you to use the NIST SHA-1 message digest
algorithm from within Perl programs. The algorithm takes as input a message
of arbitrary length and produces as output a 160-bit "fingerprint" or
"message digest" of the input.
.
In 2005, security flaws were identified in SHA-1, namely that a possible
mathematical weakness might exist, indicating that a stronger hash function
would be desirable. The Digest::SHA module implements the stronger algorithms
in the SHA family.
.
The Digest::SHA1 module provide a procedural interface for simple use, as
well as an object oriented interface that can handle messages of arbitrary
length and which can read files directly.

28
debian/copyright vendored
View File

@ -1,28 +0,0 @@
Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Source: https://metacpan.org/release/Digest-SHA1
Upstream-Contact: Gisle Aas <gisle@activestate.com>
Upstream-Name: Digest-SHA1
Files: *
Copyright: Gisle Aas <gisle@activestate.com>
License: Artistic or GPL-1+
Files: debian/*
Copyright: 2014, Joonas Javanainen <joonas.javanainen@gmail.com>
License: Artistic or GPL-1+
License: Artistic
This program is free software; you can redistribute it and/or modify
it under the terms of the Artistic License, which comes with Perl.
.
On Debian systems, the complete text of the Artistic License can be
found in `/usr/share/common-licenses/Artistic'.
License: GPL-1+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
.
On Debian systems, the complete text of version 1 of the GNU General
Public License can be found in `/usr/share/common-licenses/GPL-1'.

4
debian/rules vendored
View File

@ -1,4 +0,0 @@
#!/usr/bin/make -f
%:
dh $@

1
debian/source/format vendored
View File

@ -1 +0,0 @@
3.0 (quilt)

2
debian/watch vendored
View File

@ -1,2 +0,0 @@
version=3
https://metacpan.org/release/Digest-SHA1 .*/Digest-SHA1-v?(\d[\d.-]*)\.(?:tar(?:\.gz|\.bz2)?|tgz|zip)$

BIN
fip180-1.gif
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 7.8 KiB

1035
fip180-1.html
View File

File diff suppressed because it is too large Load Diff

6
hints/irix_6.pl
View File

@ -1,6 +0,0 @@
# The Mongoose v7.1 compiler freezes up somewhere in the optimization of
# MD5Transform() in MD5.c with optimization -O3. This is a workaround:
if ($Config{cc} =~ /64|n32/ && `$Config{cc} -version 2>&1` =~ /\s7\.1/) {
$self->{OPTIMIZE} = "-O1";
}

BIN
libdigest-sha1-perl_2.13.orig.tar.gz.delta Normal file
View File

Binary file not shown.

1
libdigest-sha1-perl_2.13.orig.tar.gz.id Normal file
View File

@ -0,0 +1 @@
ce6ea7233961d402a2e96d8fed714762d54f693d

19
t/badfile.t
View File

@ -1,19 +0,0 @@
print "1..2\n";
use Digest::SHA1 ();
$sha1 = Digest::SHA1->new;
eval {
use vars qw(*FOO);
$sha1->addfile(*FOO);
};
print "not " unless $@ =~ /^Bad filehandle: FOO at/;
print "ok 1\n";
open(BAR, "no-existing-file.$$");
eval {
$sha1->addfile(*BAR);
};
print "not " unless $@ =~ /^No filehandle passed at/;
print "ok 2\n";

36
t/bits.t
View File

@ -1,36 +0,0 @@
#!perl -w
BEGIN {
if ($] < 5.005) {
# Test module can't be expected to be available
# and I ended up with seg faults when trying to
# load it with eval { require Test };
print "1..0\n";
exit;
}
}
use Test qw(plan ok);
plan tests => 2;
use Digest::SHA1;
my $sha1 = Digest::SHA1->new;
if ($Digest::base::VERSION && $Digest::base::VERSION) {
$sha1->add_bits("01111111");
ok($sha1->hexdigest, "23833462f55515a900e016db2eb943fb474c19f6");
eval {
$sha1->add_bits("0111");
};
ok($@ =~ /must be multiple of 8/);
}
else {
print "# No Digest::base\n";
eval {
$sha1->add_bits("foo");
};
ok($@ =~ /^Can\'t locate Digest\/base\.pm in \@INC/);
ok(1); # dummy
}

62
t/sha1.t
View File

@ -1,62 +0,0 @@
print "1..13\n";
use Digest::SHA1 qw(sha1 sha1_hex sha1_base64 sha1_transform);
print "not " unless Digest::SHA1->new->add("abc")->hexdigest eq "a9993e364706816aba3e25717850c26c9cd0d89d";
print "ok 1\n";
print "not " unless sha1("abc") eq pack("H*", "a9993e364706816aba3e25717850c26c9cd0d89d");
print "ok 2\n";
print "not " unless sha1_hex("abc") eq "a9993e364706816aba3e25717850c26c9cd0d89d";
print "ok 3\n";
print "not " unless sha1_base64("abc") eq "qZk+NkcGgWq6PiVxeFDCbJzQ2J0";
print "ok 4\n";
# Test file checking from too...
open(FILE, ">stest$$.txt") || die;
binmode(FILE);
for (1..512) {
print FILE "This is line $_\n";
}
close(FILE);
open(FILE, "stest$$.txt") || die;
$digest = Digest::SHA1->new->addfile(*FILE)->b64digest;
print "$digest\nnot " unless $digest eq "1ZuIK/sQeBwqh+dIACqpnoRQUE4";
print "ok 5\n";
close(FILE);
unlink("stest$$.txt");
print "not " unless sha1_transform(pack('H*', 'dc71a8092d4b1b7b98101d58698d9d1cc48225bb'))
eq pack('H*', '2e4c75ad39160f52614d122e6c7ec80446f68567');
print "ok 6\n";
print "not " unless sha1_transform(pack('H*', '0abe1db666612acdf95d2f86d60c65210b78ab23'))
eq pack('H*', '7c1c2aabca822912f3016299b160035787477b48');
print "ok 7\n";
print "not " unless sha1_transform(pack('H*', '86da486230e353e0ec5e9220876c687892c0266c'))
eq pack('H*', '1da304aec652c21d4f54642434705c91aeaf9abe');
print "ok 8\n";
$digest = Digest::SHA1->new;
print "not " unless $digest->hexdigest eq "da39a3ee5e6b4b0d3255bfef95601890afd80709";
print "ok 9\n";
print "not " unless $digest->clone->hexdigest eq "da39a3ee5e6b4b0d3255bfef95601890afd80709";
print "ok 10\n";
$digest->add("abc");
print "not " unless $digest->clone->hexdigest eq "a9993e364706816aba3e25717850c26c9cd0d89d";
print "ok 11\n";
$digest->add("d");
print "not " unless $digest->hexdigest eq "81fe8bfe87576c3ecb22426f8e57847382917acf";
print "ok 12\n";
print "not " unless $digest->hexdigest eq "da39a3ee5e6b4b0d3255bfef95601890afd80709";
print "ok 13\n";

5
typemap
View File

@ -1,5 +0,0 @@
SHA_INFO* T_SHA_INFO
INPUT
T_SHA_INFO
$var = get_sha_info(aTHX_ $arg)