ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- base.pm000064400000003414152346026450006025 0ustar00package Digest::base; use strict; use vars qw($VERSION); $VERSION = "1.16"; # subclass is supposed to implement at least these sub new; sub clone; sub add; sub digest; sub reset { my $self = shift; $self->new(@_); # ugly } sub addfile { my ($self, $handle) = @_; my $n; my $buf = ""; while (($n = read($handle, $buf, 4*1024))) { $self->add($buf); } unless (defined $n) { require Carp; Carp::croak("Read failed: $!"); } $self; } sub add_bits { my $self = shift; my $bits; my $nbits; if (@_ == 1) { my $arg = shift; $bits = pack("B*", $arg); $nbits = length($arg); } else { ($bits, $nbits) = @_; } if (($nbits % 8) != 0) { require Carp; Carp::croak("Number of bits must be multiple of 8 for this algorithm"); } return $self->add(substr($bits, 0, $nbits/8)); } sub hexdigest { my $self = shift; return unpack("H*", $self->digest(@_)); } sub b64digest { my $self = shift; require MIME::Base64; my $b64 = MIME::Base64::encode($self->digest(@_), ""); $b64 =~ s/=+$//; return $b64; } 1; __END__ =head1 NAME Digest::base - Digest base class =head1 SYNOPSIS package Digest::Foo; use base 'Digest::base'; =head1 DESCRIPTION The C class provide implementations of the methods C and C in terms of C, and of the methods C and C in terms of C. Digest implementations might want to inherit from this class to get this implementations of the alternative I and I methods. A minimal subclass needs to implement the following methods by itself: new clone add digest The arguments and expected behaviour of these methods are described in L. =head1 SEE ALSO L HMAC_MD5.pm000064400000002132152346026450006264 0ustar00package Digest::HMAC_MD5; $VERSION="1.01"; use strict; use Digest::MD5 qw(md5); use Digest::HMAC qw(hmac); # OO interface use vars qw(@ISA); @ISA=qw(Digest::HMAC); sub new { my $class = shift; $class->SUPER::new($_[0], "Digest::MD5", 64); } # Functional interface require Exporter; *import = \&Exporter::import; use vars qw(@EXPORT_OK); @EXPORT_OK=qw(hmac_md5 hmac_md5_hex); sub hmac_md5 { hmac($_[0], $_[1], \&md5, 64); } sub hmac_md5_hex { unpack("H*", &hmac_md5) } 1; __END__ =head1 NAME Digest::HMAC_MD5 - Keyed-Hashing for Message Authentication =head1 SYNOPSIS # Functional style use Digest::HMAC_MD5 qw(hmac_md5 hmac_md5_hex); $digest = hmac_md5($data, $key); print hmac_md5_hex($data, $key); # OO style use Digest::HMAC_MD5; $hmac = Digest::HMAC_MD5->new($key); $hmac->add($data); $hmac->addfile(*FILE); $digest = $hmac->digest; $digest = $hmac->hexdigest; $digest = $hmac->b64digest; =head1 DESCRIPTION This module provide HMAC-MD5 hashing. =head1 SEE ALSO L, L, L =head1 AUTHOR Gisle Aas =cut HMAC.pm000064400000005511152346026450005623 0ustar00package Digest::HMAC; $VERSION = "1.03"; use strict; # OO interface sub new { my($class, $key, $hasher, $block_size) = @_; $block_size ||= 64; $key = $hasher->new->add($key)->digest if length($key) > $block_size; my $self = bless {}, $class; $self->{k_ipad} = $key ^ (chr(0x36) x $block_size); $self->{k_opad} = $key ^ (chr(0x5c) x $block_size); $self->{hasher} = $hasher->new->add($self->{k_ipad}); $self; } sub reset { my $self = shift; $self->{hasher}->reset->add($self->{k_ipad}); $self; } sub add { my $self = shift; $self->{hasher}->add(@_); $self; } sub addfile { my $self = shift; $self->{hasher}->addfile(@_); $self; } sub _digest { my $self = shift; my $inner_digest = $self->{hasher}->digest; $self->{hasher}->reset->add($self->{k_opad}, $inner_digest); } sub digest { shift->_digest->digest; } sub hexdigest { shift->_digest->hexdigest; } sub b64digest { shift->_digest->b64digest; } # Functional interface require Exporter; *import = \&Exporter::import; use vars qw(@EXPORT_OK); @EXPORT_OK = qw(hmac hmac_hex); sub hmac { my($data, $key, $hash_func, $block_size) = @_; $block_size ||= 64; $key = &$hash_func($key) if length($key) > $block_size; my $k_ipad = $key ^ (chr(0x36) x $block_size); my $k_opad = $key ^ (chr(0x5c) x $block_size); &$hash_func($k_opad, &$hash_func($k_ipad, $data)); } sub hmac_hex { unpack("H*", &hmac); } 1; __END__ =head1 NAME Digest::HMAC - Keyed-Hashing for Message Authentication =head1 SYNOPSIS # Functional style use Digest::HMAC qw(hmac hmac_hex); $digest = hmac($data, $key, \&myhash); print hmac_hex($data, $key, \&myhash); # OO style use Digest::HMAC; $hmac = Digest::HMAC->new($key, "Digest::MyHash"); $hmac->add($data); $hmac->addfile(*FILE); $digest = $hmac->digest; $digest = $hmac->hexdigest; $digest = $hmac->b64digest; =head1 DESCRIPTION HMAC is used for message integrity checks between two parties that share a secret key, and works in combination with some other Digest algorithm, usually MD5 or SHA-1. The HMAC mechanism is described in RFC 2104. HMAC follow the common C interface, but the constructor takes the secret key and the name of some other simple C as argument. The hmac() and hmac_hex() functions and the Digest::HMAC->new() constructor takes an optional $blocksize argument as well. The HMAC algorithm assumes the digester to hash by iterating a basic compression function on blocks of data and the $blocksize should match the byte-length of such blocks. The default $blocksize is 64 which is suitable for the MD5 and SHA-1 digest functions. For stronger algorithms the blocksize probably needs to be increased. =head1 SEE ALSO L, L RFC 2104 =head1 AUTHORS Graham Barr , Gisle Aas =cut file.pm000064400000003304152346026450006030 0ustar00package Digest::file; use strict; use Exporter (); use Carp qw(croak); use Digest (); use vars qw($VERSION @ISA @EXPORT_OK); $VERSION = "1.16"; @ISA = qw(Exporter); @EXPORT_OK = qw(digest_file_ctx digest_file digest_file_hex digest_file_base64); sub digest_file_ctx { my $file = shift; croak("No digest algorithm specified") unless @_; local *F; open(F, "<", $file) || croak("Can't open '$file': $!"); binmode(F); my $ctx = Digest->new(@_); $ctx->addfile(*F); close(F); return $ctx; } sub digest_file { digest_file_ctx(@_)->digest; } sub digest_file_hex { digest_file_ctx(@_)->hexdigest; } sub digest_file_base64 { digest_file_ctx(@_)->b64digest; } 1; __END__ =head1 NAME Digest::file - Calculate digests of files =head1 SYNOPSIS # Poor mans "md5sum" command use Digest::file qw(digest_file_hex); for (@ARGV) { print digest_file_hex($_, "MD5"), " $_\n"; } =head1 DESCRIPTION This module provide 3 convenience functions to calculate the digest of files. The following functions are provided: =over =item digest_file( $file, $algorithm, [$arg,...] ) This function will calculate and return the binary digest of the bytes of the given file. The function will croak if it fails to open or read the file. The $algorithm is a string like "MD2", "MD5", "SHA-1", "SHA-512". Additional arguments are passed to the constructor for the implementation of the given algorithm. =item digest_file_hex( $file, $algorithm, [$arg,...] ) Same as digest_file(), but return the digest in hex form. =item digest_file_base64( $file, $algorithm, [$arg,...] ) Same as digest_file(), but return the digest as a base64 encoded string. =back =head1 SEE ALSO L HMAC_SHA1.pm000064400000002213152346026450006373 0ustar00package Digest::HMAC_SHA1; $VERSION="1.03"; use strict; use Digest::SHA qw(sha1); use Digest::HMAC qw(hmac); # OO interface use vars qw(@ISA); @ISA=qw(Digest::HMAC); sub new { my $class = shift; $class->SUPER::new($_[0], "Digest::SHA", 64); # Digest::SHA defaults to SHA-1 } # Functional interface require Exporter; *import = \&Exporter::import; use vars qw(@EXPORT_OK); @EXPORT_OK=qw(hmac_sha1 hmac_sha1_hex); sub hmac_sha1 { hmac($_[0], $_[1], \&sha1, 64); } sub hmac_sha1_hex { unpack("H*", &hmac_sha1) } 1; __END__ =head1 NAME Digest::HMAC_SHA1 - Keyed-Hashing for Message Authentication =head1 SYNOPSIS # Functional style use Digest::HMAC_SHA1 qw(hmac_sha1 hmac_sha1_hex); $digest = hmac_sha1($data, $key); print hmac_sha1_hex($data, $key); # OO style use Digest::HMAC_SHA1; $hmac = Digest::HMAC_SHA1->new($key); $hmac->add($data); $hmac->addfile(*FILE); $digest = $hmac->digest; $digest = $hmac->hexdigest; $digest = $hmac->b64digest; =head1 DESCRIPTION This module provide HMAC-SHA-1 hashing. =head1 SEE ALSO L, L, L =head1 AUTHOR Gisle Aas =cut