KevinSchoenmayer/GseTDDUebungKCLR
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial Commit

Browse Source
This commit is contained in:
Riley Schneider
2025-12-03 16:38:10 +01:00
parent c5e26bf594
commit b732d8d4b5
17680 changed files with 5977495 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
database/perl/vendor/lib/Digest/CMAC.pm vendored Normal file
View File

@@ -0,0 +1,121 @@
package Digest::CMAC;
use base qw(Digest::OMAC::Base);
use strict;
#use warnings;
use Carp;
use MIME::Base64;
use vars qw($VERSION);
$VERSION = '0.04';
sub _lu2 {
my ( $self, $blocksize, $L, $Lu ) = @_;
$self->_lu( $blocksize, $Lu );
}
1;
__END__
=head1 NAME
Digest::CMAC - The One-key CBC MAC message authentication code.
=head1 SYNOPSIS
use Digest::CMAC;
my $omac1 = Digest::CMAC->new($key);
$omac1->add($data);
my $binary_tag = $omac1->digest;
my $hex_tag = $omac1->hexdigest;
my $base64_tag = $omac1->b64digest;
=head1 DESCRIPTION
This module implements OMAC1 blockcipher-based message authentication code for perl. For OMAC1/OMAC. Check http://www.nuee.nagoya-u.ac.jp/labs/tiwata/omac/omac.html. Here is an excerpt of that page
=over 4
OMAC is a blockcipher-based message authentication code designed and analyzed by me and Kaoru Kurosawa.
OMAC is a simple variant of the CBC MAC (Cipher Block Chaining Message Authentication Code). OMAC stands for One-Key CBC MAC.
OMAC allows and is secure for messages of any bit length (while the CBC MAC is only secure on messages of one fixed length, and the length must be a multiple of the block length). Also, the efficiency of OMAC is highly optimized. It is almost as efficient as the CBC MAC.
"NIST Special Publication 800-38B Recommendation for Block Cipher Modes of Operation: the CMAC Mode for Authentication" has been finalized on May 18, 2005. This Recommendation specifies CMAC, which is equivalent to OMAC (OMAC1).
=back 4
Like many block-cipher's Crypt:: modules like L<Crypt::Rijndael>, and L<MIME::Base64>.
=head1 METHODS
=over 4
=item new
my $omac1 = Digest::CMAC->new($key [, $cipher]);
This creates a new Digest::CMAC object, using $key.
$cipher is 'Crypt::Rijndael'(default), 'Crypt::Misty1', Crypt::Blowfish', or whatever blockcipher you like. $key is fixed length string that blockcipher demands.
=item add
$omac1->add($message,...);
The $message provided as argument are appended to the message we calculate the MAC. The return value is the $cmac object itself;
=item reset
$omac1->reset;
This is just an alias for $cmac->new;
=item digest
my $digest = $omac1->digest;
Return the binary authentication code for the message. The returned string will be blockcipher's block size.
=item hexdigest
my $digest = $omac1->hexdigest;
Same as $cmac->digest, but will return the digest in hexadecimal form.
=item b64digest
Same as $omac1->digest, but will return the digest as a base64 encoded string.
=back
=head1 SEE ALSO
L<Crypt::Rijndael>,
http://www.nuee.nagoya-u.ac.jp/labs/tiwata/omac/omac.html,
http://www.csrc.nist.gov/publications/nistpubs/800-38B/SP_800-38B.pdf
=head1 AUTHOR
OMAC designed and analyzed by
Tetsu Iwata and Kaoru Kurosawa
"Crypt::CMAC" was written by
Hiroyuki OYAMA <oyama@module.jp>
OMAC2 support added by Yuval Kogman
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2006 by Hiroyuki OYAMA, 2007 by Hiroyuki OYAMA, Yuval Kogman
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.8.6 or,
at your option, any later version of Perl 5 you may have available.
=cut

120
database/perl/vendor/lib/Digest/HMAC.pm vendored Normal file
View File

@@ -0,0 +1,120 @@
package 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<Digest::> interface, but the constructor
takes the secret key and the name of some other simple C<Digest::>
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<Digest::HMAC_MD5>, L<Digest::HMAC_SHA1>
RFC 2104
=head1 AUTHORS
Graham Barr <gbarr@ti.com>, Gisle Aas <gisle@aas.no>
=cut

71
database/perl/vendor/lib/Digest/HMAC_MD5.pm vendored Normal file
View File

@@ -0,0 +1,71 @@
package 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<Digest::HMAC>, L<Digest::MD5>, L<Digest::HMAC_SHA1>
=head1 AUTHOR
Gisle Aas <gisle@aas.no>
=cut

71
database/perl/vendor/lib/Digest/HMAC_SHA1.pm vendored Normal file
View File

@@ -0,0 +1,71 @@
package 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<Digest::HMAC>, L<Digest::SHA>, L<Digest::HMAC_MD5>
=head1 AUTHOR
Gisle Aas <gisle@aas.no>
=cut

72
database/perl/vendor/lib/Digest/MD2.pm vendored Normal file
View File

@@ -0,0 +1,72 @@
package Digest::MD2;
use strict;
use vars qw($VERSION @ISA @EXPORT_OK);
$VERSION = '2.04';
require Exporter;
*import = \&Exporter::import;
@EXPORT_OK = qw(md2 md2_hex md2_base64);
require DynaLoader;
@ISA=qw(DynaLoader);
Digest::MD2->bootstrap($VERSION);
*reset = \&new;
1;
__END__
=head1 NAME
Digest::MD2 - Perl interface to the MD2 Algorithm
=head1 SYNOPSIS
# Functional style
use Digest::MD2 qw(md2 md2_hex md2_base64);
$digest = md2($data);
$digest = md2_hex($data);
$digest = md2_base64($data);
# OO style
use Digest::MD2;
$ctx = Digest::MD2->new;
$ctx->add($data);
$ctx->addfile(*FILE);
$digest = $ctx->digest;
$digest = $ctx->hexdigest;
$digest = $ctx->b64digest;
=head1 DESCRIPTION
The C<Digest::MD2> module allows you to use the RSA Data Security
Inc. MD2 Message Digest algorithm from within Perl programs. The
algorithm takes as input a message of arbitrary length and produces as
output a 128-bit "fingerprint" or "message digest" of the input.
The C<Digest::MD2> programming interface is identical to the interface
of C<Digest::MD5>.
=head1 SEE ALSO
L<Digest::MD5>
=head1 COPYRIGHT
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
Copyright 1998-2003 Gisle Aas.
Copyright 1990-1992 RSA Data Security, Inc.
=head1 AUTHOR
Gisle Aas <gisle@aas.no>
=cut

231
database/perl/vendor/lib/Digest/OMAC/Base.pm vendored Normal file
View File

@@ -0,0 +1,231 @@
package Digest::OMAC::Base;
use strict;
#use warnings;
use Carp;
use MIME::Base64;
use constant DEBUG => 0;
use constant UNPACK_CAN_GROUP => $] >= 5.008;
sub new {
my ( $class, $key, $cipher, @args ) = @_;
if ( ref $key ) {
$cipher = $key;
$key = undef;
}
$cipher ||= 'Crypt::Rijndael';
my $self = bless {
cipher => undef,
}, $class;
return $self->_init($key, $cipher, @args);
}
sub add {
my ( $self, @msg ) = @_;
my $msg = join('', grep { defined } $self->{saved_block}, @msg);
$self->{ix} += length($msg);
my $c = $self->{cipher};
my $blocksize = $c->blocksize;
my @blocks = UNPACK_CAN_GROUP
? unpack("(a$blocksize)*", $msg)
: ( $msg =~ /(.{1,$blocksize})/sg );
return unless @blocks;
if ( length($blocks[-1]) < $blocksize ) {
$self->{saved_block} = pop @blocks;
} else {
$self->{saved_block} = '';
}
return unless @blocks;
my $Y = $self->{Y}; # Y[i-1]
my $unenc_y;
foreach my $block ( @blocks ) {
$unenc_y = $block ^ $Y;
$Y = $c->encrypt( $unenc_y ); # Y[i] = E( M[1] xor Y[-1] )
}
$self->{unenc_Y} = $unenc_y;
$self->{Y} = $Y;
return;
}
sub digest {
my $self = shift;
my $c = $self->{cipher};
my $blocksize = $c->blocksize;
my $last_block = $self->{saved_block};
my $X;
if ( length($last_block) or !$self->{ix} ) {
my $padded = pack("B*", substr( unpack("B*", $last_block) . "1" . ( '0' x ($blocksize * 8) ), 0, $blocksize * 8 ) );
$X = $padded ^ $self->{Y} ^ $self->{Lu2};
} else {
$X = $self->{unenc_Y} ^ $self->{Lu};
}
$self->reset;
return $c->encrypt( $X );
}
sub reset {
my $self = shift;
my $blocksize = $self->{cipher}->blocksize;
$self->{Y} = "\x00" x $blocksize;
$self->{saved_block} = '';
return $self;
}
sub _init {
my ( $self, $key, $cipher ) = @_;
if ( ref $cipher ) {
$self->{cipher} = $cipher;
} else {
eval "require $cipher; 1;"
or croak "Couldn't load $cipher: $@";
$self->{cipher} = $cipher->new($key);
}
$self->{saved_block} = '';
my $c = $self->{cipher};
my $blocksize = $c->blocksize;
my $zero = "\x00" x $blocksize;
$self->{Y} = $zero;
my $L = $self->{cipher}->encrypt($zero);
if (DEBUG) { printf STDERR qq{DEBUG >> L=%s\n}, unpack "H*", $L }
$self->{Lu} = $self->_lu( $blocksize, $L );
if (DEBUG) { printf STDERR qq{DEBUG >> Lu=%s\n}, unpack "H*", $self->{Lu}; }
$self->{Lu2} = $self->_lu2( $blocksize, $L, $self->{Lu} ); # for OMAC2 this is actually Lu^-1, not Lu^2, but we still call it Lu2
if (DEBUG) { printf STDERR qq{DEBUG >> Lu2=%s\n}, unpack "H*", $self->{Lu2}; }
return $self;
}
sub _lu {
my ( $self, $blocksize, $L ) = @_;
$self->_shift_lu( $L, $self->_lu_constant($blocksize) );
}
sub _shift_lu {
my ( $self, $L, $constant ) = @_;
# used to do Bit::Vector's shift_left but that's broken
my ( $msb, $tail ) = unpack("a a*", unpack("B*",$L));
my $Lt = pack("B*", $tail . "0");
if ( $msb ) {
return $Lt ^ $constant;
} else {
return $Lt;
}
}
sub _lu_constant {
my ( $self, $blocksize ) = @_;
if ( $blocksize == 16 ) { # 128
return ( ("\x00" x 15) . "\x87" );
} elsif ( $blocksize == 8 ) { # 64
return ( ("\x00" x 7 ) . "\x1b" );
} else {
die "Blocksize $blocksize is not supported by OMAC";
}
}
sub _lu2 {
die "lu2 needs to be defined by subclass";
}
# support methods
sub hexdigest {
return unpack 'H*', $_[0]->digest;
}
sub b64digest {
my $result = MIME::Base64::encode($_[0]->digest);
$result =~ s/=+$//;
return $result;
}
sub addfile {
my $self = shift;
my $handle = shift;
my $n;
my $buff = '';
while (($n = read $handle, $buff, 4*1024)) {
$self->add($buff);
}
unless (defined $n) {
croak "read failed: $!";
}
return $self;
}
sub add_bits {
my $self = shift;
my $bits;
my $nbits;
if (scalar @_ == 1) {
my $arg = shift;
$bits = pack 'B*', $arg;
$nbits = length $arg;
}
else {
$bits = shift;
$nbits = shift;
}
if (($nbits % 8) != 0) {
croak 'Number of bits must be multiple of 8 for this algorithm';
}
return $self->add(substr $bits, 0, $nbits/8);
}
1;
__END__
=head1 NAME
Digest::OMAC::Base - The One-key CBC MAC message authentication code (base
class for OMAC hashes)
=head1 SYNOPSIS
use base qw(Digest::OMAC::Base);
=head1 DESCRIPTION
This module is used internally by L<Digest::CMAC>/L<Digest::OMAC1> and
L<Digest::OMAC2> (which does different shifting than OMAC1 but is otherwise the
same).

29
database/perl/vendor/lib/Digest/OMAC1.pm vendored Normal file
View File

@@ -0,0 +1,29 @@
#!/usr/bin/perl
package Digest::OMAC1;
use strict;
#use warnings;
use base qw(Digest::CMAC);
__PACKAGE__;
__END__
=pod
=head1 NAME
Digest::OMAC1 - An alias for L<Digest::CMAC>
=head1 SYNOPSIS
use Digest::OMAC1;
my $d = Digest::OMAC1->new( $key, $cipher );
=head1 DESCRIPTIOn
This module has an identical interface to L<Digest::CMAC>. NIST dubbed OMAC 1
"CMAC" when they reccomended it, much like L<Crypt::Rijndael> is known as AES.

64
database/perl/vendor/lib/Digest/OMAC2.pm vendored Normal file
View File

@@ -0,0 +1,64 @@
package Digest::OMAC2;
use base qw(Digest::OMAC::Base);
use strict;
#use warnings;
use Carp;
use MIME::Base64;
# we still call it Lu2 even though it's actually no longer squared ;-)
sub _lu2 {
my ( $self, $blocksize, $L ) = @_;
$self->_shift_lu2( $L, $self->_lu2_constant($blocksize) );
}
sub _shift_lu2 {
my ( $self, $L, $constant ) = @_;
# used to do Bit::Vector's shift_left but that's broken
my $unpacked = unpack("B*",$L);
my $lsb = chop $unpacked;
my $Lt = pack("B*", "0" . $unpacked);
if ( $lsb ) {
return $Lt ^ $constant;
} else {
return $Lt;
}
}
sub _lu2_constant {
my ( $self, $blocksize ) = @_;
if ( $blocksize == 16 ) { # 128
return ("\x80" . ("\x00" x 14) . "\x43");
} elsif ( $blocksize == 8 ) { # 64
return ("\x80" . ("\x00" x 6) . "\x0d");
} else {
die "Blocksize $blocksize is not supported by OMAC";
}
}
1;
__END__
=pod
=head1 NAME
Digest::OMAC2 - OMAC 2 implementation
=head1 SYNOPSIS
use Digest::OMAC2;
my $d = Digest::OMAC2->new( $key, $cipher );
=head1 DESCRIPTION
OMAC 2 is a variant of the CMAC/OMAC 1 algorithm. The initialization routines
are slightly different. OMAC2 actually precedes OMAC1, so
L<Digest::CMAC>/L<Digest::OMAC1> is the reccomended version. Supposedly OMAC1
was more rigorously analyzed.

476
database/perl/vendor/lib/Digest/Perl/MD5.pm vendored Normal file
View File

@@ -0,0 +1,476 @@
package Digest::Perl::MD5;
use strict;
use integer;
use Exporter;
use vars qw($VERSION @ISA @EXPORTER @EXPORT_OK);
@EXPORT_OK = qw(md5 md5_hex md5_base64);
@ISA = 'Exporter';
$VERSION = '1.9';
# I-Vektor
sub A() { 0x67_45_23_01 }
sub B() { 0xef_cd_ab_89 }
sub C() { 0x98_ba_dc_fe }
sub D() { 0x10_32_54_76 }
# for internal use
sub MAX() { 0xFFFFFFFF }
# pad a message to a multiple of 64
sub padding {
my $l = length (my $msg = shift() . chr(128));
$msg .= "\0" x (($l%64<=56?56:120)-$l%64);
$l = ($l-1)*8;
$msg .= pack 'VV', $l & MAX , ($l >> 16 >> 16);
}
sub rotate_left($$) {
#$_[0] << $_[1] | $_[0] >> (32 - $_[1]);
#my $right = $_[0] >> (32 - $_[1]);
#my $rmask = (1 << $_[1]) - 1;
($_[0] << $_[1]) | (( $_[0] >> (32 - $_[1]) ) & ((1 << $_[1]) - 1));
#$_[0] << $_[1] | (($_[0]>> (32 - $_[1])) & (1 << (32 - $_[1])) - 1);
}
sub gen_code {
# Discard upper 32 bits on 64 bit archs.
my $MSK = ((1 << 16) << 16) ? ' & ' . MAX : '';
# FF => "X0=rotate_left(((X1&X2)|(~X1&X3))+X0+X4+X6$MSK,X5)+X1$MSK;",
# GG => "X0=rotate_left(((X1&X3)|(X2&(~X3)))+X0+X4+X6$MSK,X5)+X1$MSK;",
my %f = (
FF => "X0=rotate_left((X3^(X1&(X2^X3)))+X0+X4+X6$MSK,X5)+X1$MSK;",
GG => "X0=rotate_left((X2^(X3&(X1^X2)))+X0+X4+X6$MSK,X5)+X1$MSK;",
HH => "X0=rotate_left((X1^X2^X3)+X0+X4+X6$MSK,X5)+X1$MSK;",
II => "X0=rotate_left((X2^(X1|(~X3)))+X0+X4+X6$MSK,X5)+X1$MSK;",
);
#unless ( (1 << 16) << 16) { %f = %{$CODES{'32bit'}} }
#else { %f = %{$CODES{'64bit'}} }
my %s = ( # shift lengths
S11 => 7, S12 => 12, S13 => 17, S14 => 22, S21 => 5, S22 => 9, S23 => 14,
S24 => 20, S31 => 4, S32 => 11, S33 => 16, S34 => 23, S41 => 6, S42 => 10,
S43 => 15, S44 => 21
);
my $insert = "\n";
while(defined( my $data = <DATA> )) {
chomp $data;
next unless $data =~ /^[FGHI]/;
my ($func,@x) = split /,/, $data;
my $c = $f{$func};
$c =~ s/X(\d)/$x[$1]/g;
$c =~ s/(S\d{2})/$s{$1}/;
$c =~ s/^(.*)=rotate_left\((.*),(.*)\)\+(.*)$//;
my $su = 32 - $3;
my $sh = (1 << $3) - 1;
$c = "$1=(((\$r=$2)<<$3)|((\$r>>$su)&$sh))+$4";
#my $rotate = "(($2 << $3) || (($2 >> (32 - $3)) & (1 << $2) - 1)))";
# $c = "\$r = $2;
# $1 = ((\$r << $3) | ((\$r >> (32 - $3)) & ((1 << $3) - 1))) + $4";
$insert .= "\t$c\n";
}
close DATA;
my $dump = '
sub round {
my ($a,$b,$c,$d) = @_[0 .. 3];
my $r;' . $insert . '
$_[0]+$a' . $MSK . ', $_[1]+$b ' . $MSK .
', $_[2]+$c' . $MSK . ', $_[3]+$d' . $MSK . ';
}';
eval $dump;
# print "$dump\n";
# exit 0;
}
gen_code();
#########################################
# Private output converter functions:
sub _encode_hex { unpack 'H*', $_[0] }
sub _encode_base64 {
my $res;
while ($_[0] =~ /(.{1,45})/gs) {
$res .= substr pack('u', $1), 1;
chop $res;
}
$res =~ tr|` -_|AA-Za-z0-9+/|;#`
chop $res; chop $res;
$res
}
#########################################
# OOP interface:
sub new {
my $proto = shift;
my $class = ref $proto || $proto;
my $self = {};
bless $self, $class;
$self->reset();
$self
}
sub reset {
my $self = shift;
delete $self->{_data};
$self->{_state} = [A,B,C,D];
$self->{_length} = 0;
$self
}
sub add {
my $self = shift;
$self->{_data} .= join '', @_ if @_;
my ($i,$c);
for $i (0 .. (length $self->{_data})/64-1) {
my @X = unpack 'V16', substr $self->{_data}, $i*64, 64;
@{$self->{_state}} = round(@{$self->{_state}},@X);
++$c;
}
if ($c) {
substr ($self->{_data}, 0, $c*64) = '';
$self->{_length} += $c*64;
}
$self
}
sub finalize {
my $self = shift;
$self->{_data} .= chr(128);
my $l = $self->{_length} + length $self->{_data};
$self->{_data} .= "\0" x (($l%64<=56?56:120)-$l%64);
$l = ($l-1)*8;
$self->{_data} .= pack 'VV', $l & MAX , ($l >> 16 >> 16);
$self->add();
$self
}
sub addfile {
my ($self,$fh) = @_;
if (!ref($fh) && ref(\$fh) ne "GLOB") {
require Symbol;
$fh = Symbol::qualify($fh, scalar caller);
}
# $self->{_data} .= do{local$/;<$fh>};
my $read = 0;
my $buffer = '';
$self->add($buffer) while $read = read $fh, $buffer, 8192;
die __PACKAGE__, " read failed: $!" unless defined $read;
$self
}
sub add_bits {
my $self = shift;
return $self->add( pack 'B*', shift ) if @_ == 1;
my ($b,$n) = @_;
die __PACKAGE__, " Invalid number of bits\n" if $n%8;
$self->add( substr $b, 0, $n/8 )
}
sub digest {
my $self = shift;
$self->finalize();
my $res = pack 'V4', @{$self->{_state}};
$self->reset();
$res
}
sub hexdigest {
_encode_hex($_[0]->digest)
}
sub b64digest {
_encode_base64($_[0]->digest)
}
sub clone {
my $self = shift;
my $clone = {
_state => [@{$self->{_state}}],
_length => $self->{_length},
_data => $self->{_data}
};
bless $clone, ref $self || $self;
}
#########################################
# Procedural interface:
sub md5 {
my $message = padding(join'',@_);
my ($a,$b,$c,$d) = (A,B,C,D);
my $i;
for $i (0 .. (length $message)/64-1) {
my @X = unpack 'V16', substr $message,$i*64,64;
($a,$b,$c,$d) = round($a,$b,$c,$d,@X);
}
pack 'V4',$a,$b,$c,$d;
}
sub md5_hex { _encode_hex &md5 }
sub md5_base64 { _encode_base64 &md5 }
1;
=head1 NAME
Digest::MD5::Perl - Perl implementation of Ron Rivests MD5 Algorithm
=head1 DISCLAIMER
This is B<not> an interface (like C<Digest::MD5>) but a Perl implementation of MD5.
It is written in perl only and because of this it is slow but it works without C-Code.
You should use C<Digest::MD5> instead of this module if it is available.
This module is only useful for
=over 4
=item
computers where you cannot install C<Digest::MD5> (e.g. lack of a C-Compiler)
=item
encrypting only small amounts of data (less than one million bytes). I use it to
hash passwords.
=item
educational purposes
=back
=head1 SYNOPSIS
# Functional style
use Digest::MD5 qw(md5 md5_hex md5_base64);
$hash = md5 $data;
$hash = md5_hex $data;
$hash = md5_base64 $data;
# OO style
use Digest::MD5;
$ctx = Digest::MD5->new;
$ctx->add($data);
$ctx->addfile(*FILE);
$digest = $ctx->digest;
$digest = $ctx->hexdigest;
$digest = $ctx->b64digest;
=head1 DESCRIPTION
This modules has the same interface as the much faster C<Digest::MD5>. So you can
easily exchange them, e.g.
BEGIN {
eval {
require Digest::MD5;
import Digest::MD5 'md5_hex'
};
if ($@) { # ups, no Digest::MD5
require Digest::Perl::MD5;
import Digest::Perl::MD5 'md5_hex'
}
}
If the C<Digest::MD5> module is available it is used and if not you take
C<Digest::Perl::MD5>.
You can also install the Perl part of Digest::MD5 together with Digest::Perl::MD5
and use Digest::MD5 as normal, it falls back to Digest::Perl::MD5 if it
cannot load its object files.
For a detailed Documentation see the C<Digest::MD5> module.
=head1 EXAMPLES
The simplest way to use this library is to import the md5_hex()
function (or one of its cousins):
use Digest::Perl::MD5 'md5_hex';
print 'Digest is ', md5_hex('foobarbaz'), "\n";
The above example would print out the message
Digest is 6df23dc03f9b54cc38a0fc1483df6e21
provided that the implementation is working correctly. The same
checksum can also be calculated in OO style:
use Digest::MD5;
$md5 = Digest::MD5->new;
$md5->add('foo', 'bar');
$md5->add('baz');
$digest = $md5->hexdigest;
print "Digest is $digest\n";
The digest methods are destructive. That means you can only call them
once and the $md5 objects is reset after use. You can make a copy with clone:
$md5->clone->hexdigest
=head1 LIMITATIONS
This implementation of the MD5 algorithm has some limitations:
=over 4
=item
It's slow, very slow. I've done my very best but Digest::MD5 is still about 100 times faster.
You can only encrypt Data up to one million bytes in an acceptable time. But it's very useful
for encrypting small amounts of data like passwords.
=item
You can only encrypt up to 2^32 bits = 512 MB on 32bit archs. But You should
use C<Digest::MD5> for those amounts of data anyway.
=back
=head1 SEE ALSO
L<Digest::MD5>
L<md5(1)>
RFC 1321
tools/md5: a small BSD compatible md5 tool written in pure perl.
=head1 COPYRIGHT
This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
Copyright 2000 Christian Lackas, Imperia Software Solutions
Copyright 1998-1999 Gisle Aas.
Copyright 1995-1996 Neil Winton.
Copyright 1991-1992 RSA Data Security, Inc.
The MD5 algorithm is defined in RFC 1321. The basic C code
implementing the algorithm is derived from that in the RFC and is
covered by the following copyright:
=over 4
=item
Copyright (C) 1991-1992, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
=back
This copyright does not prohibit distribution of any version of Perl
containing this extension under the terms of the GNU or Artistic
licenses.
=head1 AUTHORS
The original MD5 interface was written by Neil Winton
(<N.Winton (at) axion.bt.co.uk>).
C<Digest::MD5> was made by Gisle Aas <gisle (at) aas.no> (I took his Interface
and part of the documentation).
Thanks to Guido Flohr for his 'use integer'-hint.
This release was made by Christian Lackas <delta (at) lackas.net>.
=cut
__DATA__
FF,$a,$b,$c,$d,$_[4],7,0xd76aa478,/* 1 */
FF,$d,$a,$b,$c,$_[5],12,0xe8c7b756,/* 2 */
FF,$c,$d,$a,$b,$_[6],17,0x242070db,/* 3 */
FF,$b,$c,$d,$a,$_[7],22,0xc1bdceee,/* 4 */
FF,$a,$b,$c,$d,$_[8],7,0xf57c0faf,/* 5 */
FF,$d,$a,$b,$c,$_[9],12,0x4787c62a,/* 6 */
FF,$c,$d,$a,$b,$_[10],17,0xa8304613,/* 7 */
FF,$b,$c,$d,$a,$_[11],22,0xfd469501,/* 8 */
FF,$a,$b,$c,$d,$_[12],7,0x698098d8,/* 9 */
FF,$d,$a,$b,$c,$_[13],12,0x8b44f7af,/* 10 */
FF,$c,$d,$a,$b,$_[14],17,0xffff5bb1,/* 11 */
FF,$b,$c,$d,$a,$_[15],22,0x895cd7be,/* 12 */
FF,$a,$b,$c,$d,$_[16],7,0x6b901122,/* 13 */
FF,$d,$a,$b,$c,$_[17],12,0xfd987193,/* 14 */
FF,$c,$d,$a,$b,$_[18],17,0xa679438e,/* 15 */
FF,$b,$c,$d,$a,$_[19],22,0x49b40821,/* 16 */
GG,$a,$b,$c,$d,$_[5],5,0xf61e2562,/* 17 */
GG,$d,$a,$b,$c,$_[10],9,0xc040b340,/* 18 */
GG,$c,$d,$a,$b,$_[15],14,0x265e5a51,/* 19 */
GG,$b,$c,$d,$a,$_[4],20,0xe9b6c7aa,/* 20 */
GG,$a,$b,$c,$d,$_[9],5,0xd62f105d,/* 21 */
GG,$d,$a,$b,$c,$_[14],9,0x2441453,/* 22 */
GG,$c,$d,$a,$b,$_[19],14,0xd8a1e681,/* 23 */
GG,$b,$c,$d,$a,$_[8],20,0xe7d3fbc8,/* 24 */
GG,$a,$b,$c,$d,$_[13],5,0x21e1cde6,/* 25 */
GG,$d,$a,$b,$c,$_[18],9,0xc33707d6,/* 26 */
GG,$c,$d,$a,$b,$_[7],14,0xf4d50d87,/* 27 */
GG,$b,$c,$d,$a,$_[12],20,0x455a14ed,/* 28 */
GG,$a,$b,$c,$d,$_[17],5,0xa9e3e905,/* 29 */
GG,$d,$a,$b,$c,$_[6],9,0xfcefa3f8,/* 30 */
GG,$c,$d,$a,$b,$_[11],14,0x676f02d9,/* 31 */
GG,$b,$c,$d,$a,$_[16],20,0x8d2a4c8a,/* 32 */
HH,$a,$b,$c,$d,$_[9],4,0xfffa3942,/* 33 */
HH,$d,$a,$b,$c,$_[12],11,0x8771f681,/* 34 */
HH,$c,$d,$a,$b,$_[15],16,0x6d9d6122,/* 35 */
HH,$b,$c,$d,$a,$_[18],23,0xfde5380c,/* 36 */
HH,$a,$b,$c,$d,$_[5],4,0xa4beea44,/* 37 */
HH,$d,$a,$b,$c,$_[8],11,0x4bdecfa9,/* 38 */
HH,$c,$d,$a,$b,$_[11],16,0xf6bb4b60,/* 39 */
HH,$b,$c,$d,$a,$_[14],23,0xbebfbc70,/* 40 */
HH,$a,$b,$c,$d,$_[17],4,0x289b7ec6,/* 41 */
HH,$d,$a,$b,$c,$_[4],11,0xeaa127fa,/* 42 */
HH,$c,$d,$a,$b,$_[7],16,0xd4ef3085,/* 43 */
HH,$b,$c,$d,$a,$_[10],23,0x4881d05,/* 44 */
HH,$a,$b,$c,$d,$_[13],4,0xd9d4d039,/* 45 */
HH,$d,$a,$b,$c,$_[16],11,0xe6db99e5,/* 46 */
HH,$c,$d,$a,$b,$_[19],16,0x1fa27cf8,/* 47 */
HH,$b,$c,$d,$a,$_[6],23,0xc4ac5665,/* 48 */
II,$a,$b,$c,$d,$_[4],6,0xf4292244,/* 49 */
II,$d,$a,$b,$c,$_[11],10,0x432aff97,/* 50 */
II,$c,$d,$a,$b,$_[18],15,0xab9423a7,/* 51 */
II,$b,$c,$d,$a,$_[9],21,0xfc93a039,/* 52 */
II,$a,$b,$c,$d,$_[16],6,0x655b59c3,/* 53 */
II,$d,$a,$b,$c,$_[7],10,0x8f0ccc92,/* 54 */
II,$c,$d,$a,$b,$_[14],15,0xffeff47d,/* 55 */
II,$b,$c,$d,$a,$_[5],21,0x85845dd1,/* 56 */
II,$a,$b,$c,$d,$_[12],6,0x6fa87e4f,/* 57 */
II,$d,$a,$b,$c,$_[19],10,0xfe2ce6e0,/* 58 */
II,$c,$d,$a,$b,$_[10],15,0xa3014314,/* 59 */
II,$b,$c,$d,$a,$_[17],21,0x4e0811a1,/* 60 */
II,$a,$b,$c,$d,$_[8],6,0xf7537e82,/* 61 */
II,$d,$a,$b,$c,$_[15],10,0xbd3af235,/* 62 */
II,$c,$d,$a,$b,$_[6],15,0x2ad7d2bb,/* 63 */
II,$b,$c,$d,$a,$_[13],21,0xeb86d391,/* 64 */

246
database/perl/vendor/lib/Digest/SHA1.pm vendored Normal file
View File

@@ -0,0 +1,246 @@
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

138
database/perl/vendor/lib/Digest/Whirlpool.pm vendored Normal file
View File

@@ -0,0 +1,138 @@
package Digest::Whirlpool;
use strict;
use warnings;
use base 'Digest::base';
use XSLoader ();
BEGIN {
our $VERSION = '2.04';
XSLoader::load __PACKAGE__, $VERSION;
# Pre-1.0.4 used base64digest, maintain API compatibility with it.
*base64digest = \&Digest::base::b64digest;
}
1;
__END__
=head1 NAME
Digest::Whirlpool - A 512-bit, collision-resistant, one-way hash function
=head1 ABSTRACT
WHIRLPOOL is a 512-bit, collision-resistant, one-way hash function
developed by Paulo S. L. M. Barreto and Vincent Rijmen. It has been
recommended by the NESSIE project (along with SHA-256/384/512) and
adopted as ISO/IEC 10118-3.
=head1 SYNOPSIS
In programs:
# Using L<Digest> (recommended)
use Digest;
my $whirlpool = Digest->new( 'Whirlpool' );
# Get a hash and reset the object
$whirlpool->add( "hash this" );
my $hexdigest = $whirlpool->hexdigest;
# Populate the object again, and clone it before getting the
# digest to avoid resetting
$whirlpool->add( "hash this" );
my $b64digest = $whirlpool->clone->b64digest;
$whirlpool->add( "add this to the hash" );
# Using this module directly (same interface)
use Digest::Whirlpool;
my $whirlpool = Digest->new( 'Whirlpool' );
$whirlpool->add( ... );
....
From the command line:
whirlpoolsum files
whirlpoolsum --help
=head1 DESCRIPTION
Provides an interface to the WHIRLPOOL hash algorithm. This module
subclasses L<Digest::base> and can be used either directly or through
the L<Digest> meta-module. Using the latter is recommended.
=head1 EXPORT
None.
=head1 METHODS
Since this module implements the standard L<Digest
interface|Digest/"OO INTERFACE"> and should be used through the
L<Digest> module you should look at that documentation for the general
interface, below is a description of methods that differ.
=head2 clone
Copy the internal state of the current object into a new object and
return it.
=head2 reset
Resets the object to the same internal state it was in when it was
constructed.
This works exactly like L</new> except it doesn't allocate new memory
for its internal state.
=head2 base64digest
An legacy alias for the B<b64digest> method which should be used
instead.
=head2 hashsize
Returns the size (in bits) of a WHIRLPOOL hash, i.e. 512.
=cut
=head1 SEE ALSO
=over 4
=item
NESSIE consortium, I<Portfolio of recommended cryptographic primitives>, February 27, 2003.
=item
L<http://paginas.terra.com.br/informatica/paulobarreto/WhirlpoolPage.html>
=back
=head1 AUTHORS & HISTORY
The original version of this package was written by Julius C. Duque in
2003. It was rewritten by E<AElig>var ArnfjE<ouml>rE<eth> Bjarmason
<avar@cpan.org> in January 2007 who added compatability with the
Digest interface, improved documentation and a L<whirlpoolsum(1)>
command-line utility amongst other things.
=head1 BUGS
Please report any bugs that aren't already listed at
L<http://rt.cpan.org/Dist/Display.html?Queue=Digest-Whirlpool> to
L<http://rt.cpan.org/Public/Bug/Report.html?Queue=Digest-Whirlpool>
=head1 LICENSE
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
Copyright 2003 Julius C. Duque and 2007 and 2009 E<AElig>var ArnfjE<ouml>rE<eth> Bjarmason.
=cut