Initial Commit

database/perl/vendor/lib/Crypt/Digest/BLAKE2b_160.pm

@@ -0,0 +1,225 @@
+package Crypt::Digest::BLAKE2b_160;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( blake2b_160 blake2b_160_hex blake2b_160_b64 blake2b_160_b64u blake2b_160_file blake2b_160_file_hex blake2b_160_file_b64 blake2b_160_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('BLAKE2b_160')             }
+sub blake2b_160             { Crypt::Digest::digest_data('BLAKE2b_160', @_)      }
+sub blake2b_160_hex         { Crypt::Digest::digest_data_hex('BLAKE2b_160', @_)  }
+sub blake2b_160_b64         { Crypt::Digest::digest_data_b64('BLAKE2b_160', @_)  }
+sub blake2b_160_b64u        { Crypt::Digest::digest_data_b64u('BLAKE2b_160', @_) }
+sub blake2b_160_file        { Crypt::Digest::digest_file('BLAKE2b_160', @_)      }
+sub blake2b_160_file_hex    { Crypt::Digest::digest_file_hex('BLAKE2b_160', @_)  }
+sub blake2b_160_file_b64    { Crypt::Digest::digest_file_b64('BLAKE2b_160', @_)  }
+sub blake2b_160_file_b64u   { Crypt::Digest::digest_file_b64u('BLAKE2b_160', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::BLAKE2b_160 - Hash function BLAKE2b [size: 160 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::BLAKE2b_160 qw( blake2b_160 blake2b_160_hex blake2b_160_b64 blake2b_160_b64u
+                                blake2b_160_file blake2b_160_file_hex blake2b_160_file_b64 blake2b_160_file_b64u );
+
+   # calculate digest from string/buffer
+   $blake2b_160_raw  = blake2b_160('data string');
+   $blake2b_160_hex  = blake2b_160_hex('data string');
+   $blake2b_160_b64  = blake2b_160_b64('data string');
+   $blake2b_160_b64u = blake2b_160_b64u('data string');
+   # calculate digest from file
+   $blake2b_160_raw  = blake2b_160_file('filename.dat');
+   $blake2b_160_hex  = blake2b_160_file_hex('filename.dat');
+   $blake2b_160_b64  = blake2b_160_file_b64('filename.dat');
+   $blake2b_160_b64u = blake2b_160_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $blake2b_160_raw  = blake2b_160_file(*FILEHANDLE);
+   $blake2b_160_hex  = blake2b_160_file_hex(*FILEHANDLE);
+   $blake2b_160_b64  = blake2b_160_file_b64(*FILEHANDLE);
+   $blake2b_160_b64u = blake2b_160_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::BLAKE2b_160;
+
+   $d = Crypt::Digest::BLAKE2b_160->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the BLAKE2b_160 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::BLAKE2b_160 qw(blake2b_160 blake2b_160_hex blake2b_160_b64 blake2b_160_b64u
+                                      blake2b_160_file blake2b_160_file_hex blake2b_160_file_b64 blake2b_160_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::BLAKE2b_160 ':all';
+
+=head1 FUNCTIONS
+
+=head2 blake2b_160
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_160 digest encoded as a binary string.
+
+ $blake2b_160_raw = blake2b_160('data string');
+ #or
+ $blake2b_160_raw = blake2b_160('any data', 'more data', 'even more data');
+
+=head2 blake2b_160_hex
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_160 digest encoded as a hexadecimal string.
+
+ $blake2b_160_hex = blake2b_160_hex('data string');
+ #or
+ $blake2b_160_hex = blake2b_160_hex('any data', 'more data', 'even more data');
+
+=head2 blake2b_160_b64
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_160 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2b_160_b64 = blake2b_160_b64('data string');
+ #or
+ $blake2b_160_b64 = blake2b_160_b64('any data', 'more data', 'even more data');
+
+=head2 blake2b_160_b64u
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2b_160_b64url = blake2b_160_b64u('data string');
+ #or
+ $blake2b_160_b64url = blake2b_160_b64u('any data', 'more data', 'even more data');
+
+=head2 blake2b_160_file
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_160 digest encoded as a binary string.
+
+ $blake2b_160_raw = blake2b_160_file('filename.dat');
+ #or
+ $blake2b_160_raw = blake2b_160_file(*FILEHANDLE);
+
+=head2 blake2b_160_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_160 digest encoded as a hexadecimal string.
+
+ $blake2b_160_hex = blake2b_160_file_hex('filename.dat');
+ #or
+ $blake2b_160_hex = blake2b_160_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 blake2b_160_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_160 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2b_160_b64 = blake2b_160_file_b64('filename.dat');
+ #or
+ $blake2b_160_b64 = blake2b_160_file_b64(*FILEHANDLE);
+
+=head2 blake2b_160_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2b_160_b64url = blake2b_160_file_b64u('filename.dat');
+ #or
+ $blake2b_160_b64url = blake2b_160_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::BLAKE2b_160->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::BLAKE2b_160->hashsize();
+ #or
+ Crypt::Digest::BLAKE2b_160::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://blake2.net/>
+
+=item * L<https://tools.ietf.org/html/rfc7693>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/BLAKE2b_256.pm

@@ -0,0 +1,225 @@
+package Crypt::Digest::BLAKE2b_256;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( blake2b_256 blake2b_256_hex blake2b_256_b64 blake2b_256_b64u blake2b_256_file blake2b_256_file_hex blake2b_256_file_b64 blake2b_256_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('BLAKE2b_256')             }
+sub blake2b_256             { Crypt::Digest::digest_data('BLAKE2b_256', @_)      }
+sub blake2b_256_hex         { Crypt::Digest::digest_data_hex('BLAKE2b_256', @_)  }
+sub blake2b_256_b64         { Crypt::Digest::digest_data_b64('BLAKE2b_256', @_)  }
+sub blake2b_256_b64u        { Crypt::Digest::digest_data_b64u('BLAKE2b_256', @_) }
+sub blake2b_256_file        { Crypt::Digest::digest_file('BLAKE2b_256', @_)      }
+sub blake2b_256_file_hex    { Crypt::Digest::digest_file_hex('BLAKE2b_256', @_)  }
+sub blake2b_256_file_b64    { Crypt::Digest::digest_file_b64('BLAKE2b_256', @_)  }
+sub blake2b_256_file_b64u   { Crypt::Digest::digest_file_b64u('BLAKE2b_256', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::BLAKE2b_256 - Hash function BLAKE2b [size: 256 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::BLAKE2b_256 qw( blake2b_256 blake2b_256_hex blake2b_256_b64 blake2b_256_b64u
+                                blake2b_256_file blake2b_256_file_hex blake2b_256_file_b64 blake2b_256_file_b64u );
+
+   # calculate digest from string/buffer
+   $blake2b_256_raw  = blake2b_256('data string');
+   $blake2b_256_hex  = blake2b_256_hex('data string');
+   $blake2b_256_b64  = blake2b_256_b64('data string');
+   $blake2b_256_b64u = blake2b_256_b64u('data string');
+   # calculate digest from file
+   $blake2b_256_raw  = blake2b_256_file('filename.dat');
+   $blake2b_256_hex  = blake2b_256_file_hex('filename.dat');
+   $blake2b_256_b64  = blake2b_256_file_b64('filename.dat');
+   $blake2b_256_b64u = blake2b_256_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $blake2b_256_raw  = blake2b_256_file(*FILEHANDLE);
+   $blake2b_256_hex  = blake2b_256_file_hex(*FILEHANDLE);
+   $blake2b_256_b64  = blake2b_256_file_b64(*FILEHANDLE);
+   $blake2b_256_b64u = blake2b_256_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::BLAKE2b_256;
+
+   $d = Crypt::Digest::BLAKE2b_256->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the BLAKE2b_256 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::BLAKE2b_256 qw(blake2b_256 blake2b_256_hex blake2b_256_b64 blake2b_256_b64u
+                                      blake2b_256_file blake2b_256_file_hex blake2b_256_file_b64 blake2b_256_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::BLAKE2b_256 ':all';
+
+=head1 FUNCTIONS
+
+=head2 blake2b_256
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_256 digest encoded as a binary string.
+
+ $blake2b_256_raw = blake2b_256('data string');
+ #or
+ $blake2b_256_raw = blake2b_256('any data', 'more data', 'even more data');
+
+=head2 blake2b_256_hex
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_256 digest encoded as a hexadecimal string.
+
+ $blake2b_256_hex = blake2b_256_hex('data string');
+ #or
+ $blake2b_256_hex = blake2b_256_hex('any data', 'more data', 'even more data');
+
+=head2 blake2b_256_b64
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2b_256_b64 = blake2b_256_b64('data string');
+ #or
+ $blake2b_256_b64 = blake2b_256_b64('any data', 'more data', 'even more data');
+
+=head2 blake2b_256_b64u
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2b_256_b64url = blake2b_256_b64u('data string');
+ #or
+ $blake2b_256_b64url = blake2b_256_b64u('any data', 'more data', 'even more data');
+
+=head2 blake2b_256_file
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_256 digest encoded as a binary string.
+
+ $blake2b_256_raw = blake2b_256_file('filename.dat');
+ #or
+ $blake2b_256_raw = blake2b_256_file(*FILEHANDLE);
+
+=head2 blake2b_256_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_256 digest encoded as a hexadecimal string.
+
+ $blake2b_256_hex = blake2b_256_file_hex('filename.dat');
+ #or
+ $blake2b_256_hex = blake2b_256_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 blake2b_256_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2b_256_b64 = blake2b_256_file_b64('filename.dat');
+ #or
+ $blake2b_256_b64 = blake2b_256_file_b64(*FILEHANDLE);
+
+=head2 blake2b_256_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2b_256_b64url = blake2b_256_file_b64u('filename.dat');
+ #or
+ $blake2b_256_b64url = blake2b_256_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::BLAKE2b_256->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::BLAKE2b_256->hashsize();
+ #or
+ Crypt::Digest::BLAKE2b_256::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://blake2.net/>
+
+=item * L<https://tools.ietf.org/html/rfc7693>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/BLAKE2b_384.pm

@@ -0,0 +1,225 @@
+package Crypt::Digest::BLAKE2b_384;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( blake2b_384 blake2b_384_hex blake2b_384_b64 blake2b_384_b64u blake2b_384_file blake2b_384_file_hex blake2b_384_file_b64 blake2b_384_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('BLAKE2b_384')             }
+sub blake2b_384             { Crypt::Digest::digest_data('BLAKE2b_384', @_)      }
+sub blake2b_384_hex         { Crypt::Digest::digest_data_hex('BLAKE2b_384', @_)  }
+sub blake2b_384_b64         { Crypt::Digest::digest_data_b64('BLAKE2b_384', @_)  }
+sub blake2b_384_b64u        { Crypt::Digest::digest_data_b64u('BLAKE2b_384', @_) }
+sub blake2b_384_file        { Crypt::Digest::digest_file('BLAKE2b_384', @_)      }
+sub blake2b_384_file_hex    { Crypt::Digest::digest_file_hex('BLAKE2b_384', @_)  }
+sub blake2b_384_file_b64    { Crypt::Digest::digest_file_b64('BLAKE2b_384', @_)  }
+sub blake2b_384_file_b64u   { Crypt::Digest::digest_file_b64u('BLAKE2b_384', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::BLAKE2b_384 - Hash function BLAKE2b [size: 384 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::BLAKE2b_384 qw( blake2b_384 blake2b_384_hex blake2b_384_b64 blake2b_384_b64u
+                                blake2b_384_file blake2b_384_file_hex blake2b_384_file_b64 blake2b_384_file_b64u );
+
+   # calculate digest from string/buffer
+   $blake2b_384_raw  = blake2b_384('data string');
+   $blake2b_384_hex  = blake2b_384_hex('data string');
+   $blake2b_384_b64  = blake2b_384_b64('data string');
+   $blake2b_384_b64u = blake2b_384_b64u('data string');
+   # calculate digest from file
+   $blake2b_384_raw  = blake2b_384_file('filename.dat');
+   $blake2b_384_hex  = blake2b_384_file_hex('filename.dat');
+   $blake2b_384_b64  = blake2b_384_file_b64('filename.dat');
+   $blake2b_384_b64u = blake2b_384_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $blake2b_384_raw  = blake2b_384_file(*FILEHANDLE);
+   $blake2b_384_hex  = blake2b_384_file_hex(*FILEHANDLE);
+   $blake2b_384_b64  = blake2b_384_file_b64(*FILEHANDLE);
+   $blake2b_384_b64u = blake2b_384_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::BLAKE2b_384;
+
+   $d = Crypt::Digest::BLAKE2b_384->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the BLAKE2b_384 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::BLAKE2b_384 qw(blake2b_384 blake2b_384_hex blake2b_384_b64 blake2b_384_b64u
+                                      blake2b_384_file blake2b_384_file_hex blake2b_384_file_b64 blake2b_384_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::BLAKE2b_384 ':all';
+
+=head1 FUNCTIONS
+
+=head2 blake2b_384
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_384 digest encoded as a binary string.
+
+ $blake2b_384_raw = blake2b_384('data string');
+ #or
+ $blake2b_384_raw = blake2b_384('any data', 'more data', 'even more data');
+
+=head2 blake2b_384_hex
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_384 digest encoded as a hexadecimal string.
+
+ $blake2b_384_hex = blake2b_384_hex('data string');
+ #or
+ $blake2b_384_hex = blake2b_384_hex('any data', 'more data', 'even more data');
+
+=head2 blake2b_384_b64
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_384 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2b_384_b64 = blake2b_384_b64('data string');
+ #or
+ $blake2b_384_b64 = blake2b_384_b64('any data', 'more data', 'even more data');
+
+=head2 blake2b_384_b64u
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2b_384_b64url = blake2b_384_b64u('data string');
+ #or
+ $blake2b_384_b64url = blake2b_384_b64u('any data', 'more data', 'even more data');
+
+=head2 blake2b_384_file
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_384 digest encoded as a binary string.
+
+ $blake2b_384_raw = blake2b_384_file('filename.dat');
+ #or
+ $blake2b_384_raw = blake2b_384_file(*FILEHANDLE);
+
+=head2 blake2b_384_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_384 digest encoded as a hexadecimal string.
+
+ $blake2b_384_hex = blake2b_384_file_hex('filename.dat');
+ #or
+ $blake2b_384_hex = blake2b_384_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 blake2b_384_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_384 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2b_384_b64 = blake2b_384_file_b64('filename.dat');
+ #or
+ $blake2b_384_b64 = blake2b_384_file_b64(*FILEHANDLE);
+
+=head2 blake2b_384_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2b_384_b64url = blake2b_384_file_b64u('filename.dat');
+ #or
+ $blake2b_384_b64url = blake2b_384_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::BLAKE2b_384->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::BLAKE2b_384->hashsize();
+ #or
+ Crypt::Digest::BLAKE2b_384::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://blake2.net/>
+
+=item * L<https://tools.ietf.org/html/rfc7693>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/BLAKE2b_512.pm

@@ -0,0 +1,225 @@
+package Crypt::Digest::BLAKE2b_512;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( blake2b_512 blake2b_512_hex blake2b_512_b64 blake2b_512_b64u blake2b_512_file blake2b_512_file_hex blake2b_512_file_b64 blake2b_512_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('BLAKE2b_512')             }
+sub blake2b_512             { Crypt::Digest::digest_data('BLAKE2b_512', @_)      }
+sub blake2b_512_hex         { Crypt::Digest::digest_data_hex('BLAKE2b_512', @_)  }
+sub blake2b_512_b64         { Crypt::Digest::digest_data_b64('BLAKE2b_512', @_)  }
+sub blake2b_512_b64u        { Crypt::Digest::digest_data_b64u('BLAKE2b_512', @_) }
+sub blake2b_512_file        { Crypt::Digest::digest_file('BLAKE2b_512', @_)      }
+sub blake2b_512_file_hex    { Crypt::Digest::digest_file_hex('BLAKE2b_512', @_)  }
+sub blake2b_512_file_b64    { Crypt::Digest::digest_file_b64('BLAKE2b_512', @_)  }
+sub blake2b_512_file_b64u   { Crypt::Digest::digest_file_b64u('BLAKE2b_512', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::BLAKE2b_512 - Hash function BLAKE2b [size: 512 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::BLAKE2b_512 qw( blake2b_512 blake2b_512_hex blake2b_512_b64 blake2b_512_b64u
+                                blake2b_512_file blake2b_512_file_hex blake2b_512_file_b64 blake2b_512_file_b64u );
+
+   # calculate digest from string/buffer
+   $blake2b_512_raw  = blake2b_512('data string');
+   $blake2b_512_hex  = blake2b_512_hex('data string');
+   $blake2b_512_b64  = blake2b_512_b64('data string');
+   $blake2b_512_b64u = blake2b_512_b64u('data string');
+   # calculate digest from file
+   $blake2b_512_raw  = blake2b_512_file('filename.dat');
+   $blake2b_512_hex  = blake2b_512_file_hex('filename.dat');
+   $blake2b_512_b64  = blake2b_512_file_b64('filename.dat');
+   $blake2b_512_b64u = blake2b_512_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $blake2b_512_raw  = blake2b_512_file(*FILEHANDLE);
+   $blake2b_512_hex  = blake2b_512_file_hex(*FILEHANDLE);
+   $blake2b_512_b64  = blake2b_512_file_b64(*FILEHANDLE);
+   $blake2b_512_b64u = blake2b_512_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::BLAKE2b_512;
+
+   $d = Crypt::Digest::BLAKE2b_512->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the BLAKE2b_512 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::BLAKE2b_512 qw(blake2b_512 blake2b_512_hex blake2b_512_b64 blake2b_512_b64u
+                                      blake2b_512_file blake2b_512_file_hex blake2b_512_file_b64 blake2b_512_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::BLAKE2b_512 ':all';
+
+=head1 FUNCTIONS
+
+=head2 blake2b_512
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_512 digest encoded as a binary string.
+
+ $blake2b_512_raw = blake2b_512('data string');
+ #or
+ $blake2b_512_raw = blake2b_512('any data', 'more data', 'even more data');
+
+=head2 blake2b_512_hex
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_512 digest encoded as a hexadecimal string.
+
+ $blake2b_512_hex = blake2b_512_hex('data string');
+ #or
+ $blake2b_512_hex = blake2b_512_hex('any data', 'more data', 'even more data');
+
+=head2 blake2b_512_b64
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_512 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2b_512_b64 = blake2b_512_b64('data string');
+ #or
+ $blake2b_512_b64 = blake2b_512_b64('any data', 'more data', 'even more data');
+
+=head2 blake2b_512_b64u
+
+Logically joins all arguments into a single string, and returns its BLAKE2b_512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2b_512_b64url = blake2b_512_b64u('data string');
+ #or
+ $blake2b_512_b64url = blake2b_512_b64u('any data', 'more data', 'even more data');
+
+=head2 blake2b_512_file
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_512 digest encoded as a binary string.
+
+ $blake2b_512_raw = blake2b_512_file('filename.dat');
+ #or
+ $blake2b_512_raw = blake2b_512_file(*FILEHANDLE);
+
+=head2 blake2b_512_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_512 digest encoded as a hexadecimal string.
+
+ $blake2b_512_hex = blake2b_512_file_hex('filename.dat');
+ #or
+ $blake2b_512_hex = blake2b_512_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 blake2b_512_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_512 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2b_512_b64 = blake2b_512_file_b64('filename.dat');
+ #or
+ $blake2b_512_b64 = blake2b_512_file_b64(*FILEHANDLE);
+
+=head2 blake2b_512_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2b_512_b64url = blake2b_512_file_b64u('filename.dat');
+ #or
+ $blake2b_512_b64url = blake2b_512_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::BLAKE2b_512->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::BLAKE2b_512->hashsize();
+ #or
+ Crypt::Digest::BLAKE2b_512::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://blake2.net/>
+
+=item * L<https://tools.ietf.org/html/rfc7693>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/BLAKE2s_128.pm

@@ -0,0 +1,225 @@
+package Crypt::Digest::BLAKE2s_128;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( blake2s_128 blake2s_128_hex blake2s_128_b64 blake2s_128_b64u blake2s_128_file blake2s_128_file_hex blake2s_128_file_b64 blake2s_128_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('BLAKE2s_128')             }
+sub blake2s_128             { Crypt::Digest::digest_data('BLAKE2s_128', @_)      }
+sub blake2s_128_hex         { Crypt::Digest::digest_data_hex('BLAKE2s_128', @_)  }
+sub blake2s_128_b64         { Crypt::Digest::digest_data_b64('BLAKE2s_128', @_)  }
+sub blake2s_128_b64u        { Crypt::Digest::digest_data_b64u('BLAKE2s_128', @_) }
+sub blake2s_128_file        { Crypt::Digest::digest_file('BLAKE2s_128', @_)      }
+sub blake2s_128_file_hex    { Crypt::Digest::digest_file_hex('BLAKE2s_128', @_)  }
+sub blake2s_128_file_b64    { Crypt::Digest::digest_file_b64('BLAKE2s_128', @_)  }
+sub blake2s_128_file_b64u   { Crypt::Digest::digest_file_b64u('BLAKE2s_128', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::BLAKE2s_128 - Hash function BLAKE2s [size: 128 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::BLAKE2s_128 qw( blake2s_128 blake2s_128_hex blake2s_128_b64 blake2s_128_b64u
+                                blake2s_128_file blake2s_128_file_hex blake2s_128_file_b64 blake2s_128_file_b64u );
+
+   # calculate digest from string/buffer
+   $blake2s_128_raw  = blake2s_128('data string');
+   $blake2s_128_hex  = blake2s_128_hex('data string');
+   $blake2s_128_b64  = blake2s_128_b64('data string');
+   $blake2s_128_b64u = blake2s_128_b64u('data string');
+   # calculate digest from file
+   $blake2s_128_raw  = blake2s_128_file('filename.dat');
+   $blake2s_128_hex  = blake2s_128_file_hex('filename.dat');
+   $blake2s_128_b64  = blake2s_128_file_b64('filename.dat');
+   $blake2s_128_b64u = blake2s_128_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $blake2s_128_raw  = blake2s_128_file(*FILEHANDLE);
+   $blake2s_128_hex  = blake2s_128_file_hex(*FILEHANDLE);
+   $blake2s_128_b64  = blake2s_128_file_b64(*FILEHANDLE);
+   $blake2s_128_b64u = blake2s_128_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::BLAKE2s_128;
+
+   $d = Crypt::Digest::BLAKE2s_128->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the BLAKE2s_128 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::BLAKE2s_128 qw(blake2s_128 blake2s_128_hex blake2s_128_b64 blake2s_128_b64u
+                                      blake2s_128_file blake2s_128_file_hex blake2s_128_file_b64 blake2s_128_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::BLAKE2s_128 ':all';
+
+=head1 FUNCTIONS
+
+=head2 blake2s_128
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_128 digest encoded as a binary string.
+
+ $blake2s_128_raw = blake2s_128('data string');
+ #or
+ $blake2s_128_raw = blake2s_128('any data', 'more data', 'even more data');
+
+=head2 blake2s_128_hex
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_128 digest encoded as a hexadecimal string.
+
+ $blake2s_128_hex = blake2s_128_hex('data string');
+ #or
+ $blake2s_128_hex = blake2s_128_hex('any data', 'more data', 'even more data');
+
+=head2 blake2s_128_b64
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_128 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2s_128_b64 = blake2s_128_b64('data string');
+ #or
+ $blake2s_128_b64 = blake2s_128_b64('any data', 'more data', 'even more data');
+
+=head2 blake2s_128_b64u
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_128 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2s_128_b64url = blake2s_128_b64u('data string');
+ #or
+ $blake2s_128_b64url = blake2s_128_b64u('any data', 'more data', 'even more data');
+
+=head2 blake2s_128_file
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_128 digest encoded as a binary string.
+
+ $blake2s_128_raw = blake2s_128_file('filename.dat');
+ #or
+ $blake2s_128_raw = blake2s_128_file(*FILEHANDLE);
+
+=head2 blake2s_128_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_128 digest encoded as a hexadecimal string.
+
+ $blake2s_128_hex = blake2s_128_file_hex('filename.dat');
+ #or
+ $blake2s_128_hex = blake2s_128_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 blake2s_128_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_128 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2s_128_b64 = blake2s_128_file_b64('filename.dat');
+ #or
+ $blake2s_128_b64 = blake2s_128_file_b64(*FILEHANDLE);
+
+=head2 blake2s_128_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_128 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2s_128_b64url = blake2s_128_file_b64u('filename.dat');
+ #or
+ $blake2s_128_b64url = blake2s_128_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::BLAKE2s_128->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::BLAKE2s_128->hashsize();
+ #or
+ Crypt::Digest::BLAKE2s_128::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://blake2.net/>
+
+=item * L<https://tools.ietf.org/html/rfc7693>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/BLAKE2s_160.pm

@@ -0,0 +1,225 @@
+package Crypt::Digest::BLAKE2s_160;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( blake2s_160 blake2s_160_hex blake2s_160_b64 blake2s_160_b64u blake2s_160_file blake2s_160_file_hex blake2s_160_file_b64 blake2s_160_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('BLAKE2s_160')             }
+sub blake2s_160             { Crypt::Digest::digest_data('BLAKE2s_160', @_)      }
+sub blake2s_160_hex         { Crypt::Digest::digest_data_hex('BLAKE2s_160', @_)  }
+sub blake2s_160_b64         { Crypt::Digest::digest_data_b64('BLAKE2s_160', @_)  }
+sub blake2s_160_b64u        { Crypt::Digest::digest_data_b64u('BLAKE2s_160', @_) }
+sub blake2s_160_file        { Crypt::Digest::digest_file('BLAKE2s_160', @_)      }
+sub blake2s_160_file_hex    { Crypt::Digest::digest_file_hex('BLAKE2s_160', @_)  }
+sub blake2s_160_file_b64    { Crypt::Digest::digest_file_b64('BLAKE2s_160', @_)  }
+sub blake2s_160_file_b64u   { Crypt::Digest::digest_file_b64u('BLAKE2s_160', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::BLAKE2s_160 - Hash function BLAKE2s [size: 160 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::BLAKE2s_160 qw( blake2s_160 blake2s_160_hex blake2s_160_b64 blake2s_160_b64u
+                                blake2s_160_file blake2s_160_file_hex blake2s_160_file_b64 blake2s_160_file_b64u );
+
+   # calculate digest from string/buffer
+   $blake2s_160_raw  = blake2s_160('data string');
+   $blake2s_160_hex  = blake2s_160_hex('data string');
+   $blake2s_160_b64  = blake2s_160_b64('data string');
+   $blake2s_160_b64u = blake2s_160_b64u('data string');
+   # calculate digest from file
+   $blake2s_160_raw  = blake2s_160_file('filename.dat');
+   $blake2s_160_hex  = blake2s_160_file_hex('filename.dat');
+   $blake2s_160_b64  = blake2s_160_file_b64('filename.dat');
+   $blake2s_160_b64u = blake2s_160_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $blake2s_160_raw  = blake2s_160_file(*FILEHANDLE);
+   $blake2s_160_hex  = blake2s_160_file_hex(*FILEHANDLE);
+   $blake2s_160_b64  = blake2s_160_file_b64(*FILEHANDLE);
+   $blake2s_160_b64u = blake2s_160_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::BLAKE2s_160;
+
+   $d = Crypt::Digest::BLAKE2s_160->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the BLAKE2s_160 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::BLAKE2s_160 qw(blake2s_160 blake2s_160_hex blake2s_160_b64 blake2s_160_b64u
+                                      blake2s_160_file blake2s_160_file_hex blake2s_160_file_b64 blake2s_160_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::BLAKE2s_160 ':all';
+
+=head1 FUNCTIONS
+
+=head2 blake2s_160
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_160 digest encoded as a binary string.
+
+ $blake2s_160_raw = blake2s_160('data string');
+ #or
+ $blake2s_160_raw = blake2s_160('any data', 'more data', 'even more data');
+
+=head2 blake2s_160_hex
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_160 digest encoded as a hexadecimal string.
+
+ $blake2s_160_hex = blake2s_160_hex('data string');
+ #or
+ $blake2s_160_hex = blake2s_160_hex('any data', 'more data', 'even more data');
+
+=head2 blake2s_160_b64
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_160 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2s_160_b64 = blake2s_160_b64('data string');
+ #or
+ $blake2s_160_b64 = blake2s_160_b64('any data', 'more data', 'even more data');
+
+=head2 blake2s_160_b64u
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2s_160_b64url = blake2s_160_b64u('data string');
+ #or
+ $blake2s_160_b64url = blake2s_160_b64u('any data', 'more data', 'even more data');
+
+=head2 blake2s_160_file
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_160 digest encoded as a binary string.
+
+ $blake2s_160_raw = blake2s_160_file('filename.dat');
+ #or
+ $blake2s_160_raw = blake2s_160_file(*FILEHANDLE);
+
+=head2 blake2s_160_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_160 digest encoded as a hexadecimal string.
+
+ $blake2s_160_hex = blake2s_160_file_hex('filename.dat');
+ #or
+ $blake2s_160_hex = blake2s_160_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 blake2s_160_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_160 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2s_160_b64 = blake2s_160_file_b64('filename.dat');
+ #or
+ $blake2s_160_b64 = blake2s_160_file_b64(*FILEHANDLE);
+
+=head2 blake2s_160_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2s_160_b64url = blake2s_160_file_b64u('filename.dat');
+ #or
+ $blake2s_160_b64url = blake2s_160_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::BLAKE2s_160->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::BLAKE2s_160->hashsize();
+ #or
+ Crypt::Digest::BLAKE2s_160::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://blake2.net/>
+
+=item * L<https://tools.ietf.org/html/rfc7693>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/BLAKE2s_224.pm

@@ -0,0 +1,225 @@
+package Crypt::Digest::BLAKE2s_224;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( blake2s_224 blake2s_224_hex blake2s_224_b64 blake2s_224_b64u blake2s_224_file blake2s_224_file_hex blake2s_224_file_b64 blake2s_224_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('BLAKE2s_224')             }
+sub blake2s_224             { Crypt::Digest::digest_data('BLAKE2s_224', @_)      }
+sub blake2s_224_hex         { Crypt::Digest::digest_data_hex('BLAKE2s_224', @_)  }
+sub blake2s_224_b64         { Crypt::Digest::digest_data_b64('BLAKE2s_224', @_)  }
+sub blake2s_224_b64u        { Crypt::Digest::digest_data_b64u('BLAKE2s_224', @_) }
+sub blake2s_224_file        { Crypt::Digest::digest_file('BLAKE2s_224', @_)      }
+sub blake2s_224_file_hex    { Crypt::Digest::digest_file_hex('BLAKE2s_224', @_)  }
+sub blake2s_224_file_b64    { Crypt::Digest::digest_file_b64('BLAKE2s_224', @_)  }
+sub blake2s_224_file_b64u   { Crypt::Digest::digest_file_b64u('BLAKE2s_224', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::BLAKE2s_224 - Hash function BLAKE2s [size: 224 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::BLAKE2s_224 qw( blake2s_224 blake2s_224_hex blake2s_224_b64 blake2s_224_b64u
+                                blake2s_224_file blake2s_224_file_hex blake2s_224_file_b64 blake2s_224_file_b64u );
+
+   # calculate digest from string/buffer
+   $blake2s_224_raw  = blake2s_224('data string');
+   $blake2s_224_hex  = blake2s_224_hex('data string');
+   $blake2s_224_b64  = blake2s_224_b64('data string');
+   $blake2s_224_b64u = blake2s_224_b64u('data string');
+   # calculate digest from file
+   $blake2s_224_raw  = blake2s_224_file('filename.dat');
+   $blake2s_224_hex  = blake2s_224_file_hex('filename.dat');
+   $blake2s_224_b64  = blake2s_224_file_b64('filename.dat');
+   $blake2s_224_b64u = blake2s_224_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $blake2s_224_raw  = blake2s_224_file(*FILEHANDLE);
+   $blake2s_224_hex  = blake2s_224_file_hex(*FILEHANDLE);
+   $blake2s_224_b64  = blake2s_224_file_b64(*FILEHANDLE);
+   $blake2s_224_b64u = blake2s_224_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::BLAKE2s_224;
+
+   $d = Crypt::Digest::BLAKE2s_224->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the BLAKE2s_224 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::BLAKE2s_224 qw(blake2s_224 blake2s_224_hex blake2s_224_b64 blake2s_224_b64u
+                                      blake2s_224_file blake2s_224_file_hex blake2s_224_file_b64 blake2s_224_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::BLAKE2s_224 ':all';
+
+=head1 FUNCTIONS
+
+=head2 blake2s_224
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_224 digest encoded as a binary string.
+
+ $blake2s_224_raw = blake2s_224('data string');
+ #or
+ $blake2s_224_raw = blake2s_224('any data', 'more data', 'even more data');
+
+=head2 blake2s_224_hex
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_224 digest encoded as a hexadecimal string.
+
+ $blake2s_224_hex = blake2s_224_hex('data string');
+ #or
+ $blake2s_224_hex = blake2s_224_hex('any data', 'more data', 'even more data');
+
+=head2 blake2s_224_b64
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2s_224_b64 = blake2s_224_b64('data string');
+ #or
+ $blake2s_224_b64 = blake2s_224_b64('any data', 'more data', 'even more data');
+
+=head2 blake2s_224_b64u
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2s_224_b64url = blake2s_224_b64u('data string');
+ #or
+ $blake2s_224_b64url = blake2s_224_b64u('any data', 'more data', 'even more data');
+
+=head2 blake2s_224_file
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_224 digest encoded as a binary string.
+
+ $blake2s_224_raw = blake2s_224_file('filename.dat');
+ #or
+ $blake2s_224_raw = blake2s_224_file(*FILEHANDLE);
+
+=head2 blake2s_224_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_224 digest encoded as a hexadecimal string.
+
+ $blake2s_224_hex = blake2s_224_file_hex('filename.dat');
+ #or
+ $blake2s_224_hex = blake2s_224_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 blake2s_224_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2s_224_b64 = blake2s_224_file_b64('filename.dat');
+ #or
+ $blake2s_224_b64 = blake2s_224_file_b64(*FILEHANDLE);
+
+=head2 blake2s_224_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2s_224_b64url = blake2s_224_file_b64u('filename.dat');
+ #or
+ $blake2s_224_b64url = blake2s_224_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::BLAKE2s_224->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::BLAKE2s_224->hashsize();
+ #or
+ Crypt::Digest::BLAKE2s_224::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://blake2.net/>
+
+=item * L<https://tools.ietf.org/html/rfc7693>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/BLAKE2s_256.pm

@@ -0,0 +1,225 @@
+package Crypt::Digest::BLAKE2s_256;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( blake2s_256 blake2s_256_hex blake2s_256_b64 blake2s_256_b64u blake2s_256_file blake2s_256_file_hex blake2s_256_file_b64 blake2s_256_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('BLAKE2s_256')             }
+sub blake2s_256             { Crypt::Digest::digest_data('BLAKE2s_256', @_)      }
+sub blake2s_256_hex         { Crypt::Digest::digest_data_hex('BLAKE2s_256', @_)  }
+sub blake2s_256_b64         { Crypt::Digest::digest_data_b64('BLAKE2s_256', @_)  }
+sub blake2s_256_b64u        { Crypt::Digest::digest_data_b64u('BLAKE2s_256', @_) }
+sub blake2s_256_file        { Crypt::Digest::digest_file('BLAKE2s_256', @_)      }
+sub blake2s_256_file_hex    { Crypt::Digest::digest_file_hex('BLAKE2s_256', @_)  }
+sub blake2s_256_file_b64    { Crypt::Digest::digest_file_b64('BLAKE2s_256', @_)  }
+sub blake2s_256_file_b64u   { Crypt::Digest::digest_file_b64u('BLAKE2s_256', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::BLAKE2s_256 - Hash function BLAKE2s [size: 256 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::BLAKE2s_256 qw( blake2s_256 blake2s_256_hex blake2s_256_b64 blake2s_256_b64u
+                                blake2s_256_file blake2s_256_file_hex blake2s_256_file_b64 blake2s_256_file_b64u );
+
+   # calculate digest from string/buffer
+   $blake2s_256_raw  = blake2s_256('data string');
+   $blake2s_256_hex  = blake2s_256_hex('data string');
+   $blake2s_256_b64  = blake2s_256_b64('data string');
+   $blake2s_256_b64u = blake2s_256_b64u('data string');
+   # calculate digest from file
+   $blake2s_256_raw  = blake2s_256_file('filename.dat');
+   $blake2s_256_hex  = blake2s_256_file_hex('filename.dat');
+   $blake2s_256_b64  = blake2s_256_file_b64('filename.dat');
+   $blake2s_256_b64u = blake2s_256_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $blake2s_256_raw  = blake2s_256_file(*FILEHANDLE);
+   $blake2s_256_hex  = blake2s_256_file_hex(*FILEHANDLE);
+   $blake2s_256_b64  = blake2s_256_file_b64(*FILEHANDLE);
+   $blake2s_256_b64u = blake2s_256_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::BLAKE2s_256;
+
+   $d = Crypt::Digest::BLAKE2s_256->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the BLAKE2s_256 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::BLAKE2s_256 qw(blake2s_256 blake2s_256_hex blake2s_256_b64 blake2s_256_b64u
+                                      blake2s_256_file blake2s_256_file_hex blake2s_256_file_b64 blake2s_256_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::BLAKE2s_256 ':all';
+
+=head1 FUNCTIONS
+
+=head2 blake2s_256
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_256 digest encoded as a binary string.
+
+ $blake2s_256_raw = blake2s_256('data string');
+ #or
+ $blake2s_256_raw = blake2s_256('any data', 'more data', 'even more data');
+
+=head2 blake2s_256_hex
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_256 digest encoded as a hexadecimal string.
+
+ $blake2s_256_hex = blake2s_256_hex('data string');
+ #or
+ $blake2s_256_hex = blake2s_256_hex('any data', 'more data', 'even more data');
+
+=head2 blake2s_256_b64
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2s_256_b64 = blake2s_256_b64('data string');
+ #or
+ $blake2s_256_b64 = blake2s_256_b64('any data', 'more data', 'even more data');
+
+=head2 blake2s_256_b64u
+
+Logically joins all arguments into a single string, and returns its BLAKE2s_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2s_256_b64url = blake2s_256_b64u('data string');
+ #or
+ $blake2s_256_b64url = blake2s_256_b64u('any data', 'more data', 'even more data');
+
+=head2 blake2s_256_file
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_256 digest encoded as a binary string.
+
+ $blake2s_256_raw = blake2s_256_file('filename.dat');
+ #or
+ $blake2s_256_raw = blake2s_256_file(*FILEHANDLE);
+
+=head2 blake2s_256_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_256 digest encoded as a hexadecimal string.
+
+ $blake2s_256_hex = blake2s_256_file_hex('filename.dat');
+ #or
+ $blake2s_256_hex = blake2s_256_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 blake2s_256_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $blake2s_256_b64 = blake2s_256_file_b64('filename.dat');
+ #or
+ $blake2s_256_b64 = blake2s_256_file_b64(*FILEHANDLE);
+
+=head2 blake2s_256_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $blake2s_256_b64url = blake2s_256_file_b64u('filename.dat');
+ #or
+ $blake2s_256_b64url = blake2s_256_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::BLAKE2s_256->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::BLAKE2s_256->hashsize();
+ #or
+ Crypt::Digest::BLAKE2s_256::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://blake2.net/>
+
+=item * L<https://tools.ietf.org/html/rfc7693>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/CHAES.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::CHAES;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( chaes chaes_hex chaes_b64 chaes_b64u chaes_file chaes_file_hex chaes_file_b64 chaes_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('CHAES')             }
+sub chaes             { Crypt::Digest::digest_data('CHAES', @_)      }
+sub chaes_hex         { Crypt::Digest::digest_data_hex('CHAES', @_)  }
+sub chaes_b64         { Crypt::Digest::digest_data_b64('CHAES', @_)  }
+sub chaes_b64u        { Crypt::Digest::digest_data_b64u('CHAES', @_) }
+sub chaes_file        { Crypt::Digest::digest_file('CHAES', @_)      }
+sub chaes_file_hex    { Crypt::Digest::digest_file_hex('CHAES', @_)  }
+sub chaes_file_b64    { Crypt::Digest::digest_file_b64('CHAES', @_)  }
+sub chaes_file_b64u   { Crypt::Digest::digest_file_b64u('CHAES', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::CHAES - Hash function - CipherHash based on AES [size: 128 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::CHAES qw( chaes chaes_hex chaes_b64 chaes_b64u
+                                chaes_file chaes_file_hex chaes_file_b64 chaes_file_b64u );
+
+   # calculate digest from string/buffer
+   $chaes_raw  = chaes('data string');
+   $chaes_hex  = chaes_hex('data string');
+   $chaes_b64  = chaes_b64('data string');
+   $chaes_b64u = chaes_b64u('data string');
+   # calculate digest from file
+   $chaes_raw  = chaes_file('filename.dat');
+   $chaes_hex  = chaes_file_hex('filename.dat');
+   $chaes_b64  = chaes_file_b64('filename.dat');
+   $chaes_b64u = chaes_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $chaes_raw  = chaes_file(*FILEHANDLE);
+   $chaes_hex  = chaes_file_hex(*FILEHANDLE);
+   $chaes_b64  = chaes_file_b64(*FILEHANDLE);
+   $chaes_b64u = chaes_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::CHAES;
+
+   $d = Crypt::Digest::CHAES->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the CHAES digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::CHAES qw(chaes chaes_hex chaes_b64 chaes_b64u
+                                      chaes_file chaes_file_hex chaes_file_b64 chaes_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::CHAES ':all';
+
+=head1 FUNCTIONS
+
+=head2 chaes
+
+Logically joins all arguments into a single string, and returns its CHAES digest encoded as a binary string.
+
+ $chaes_raw = chaes('data string');
+ #or
+ $chaes_raw = chaes('any data', 'more data', 'even more data');
+
+=head2 chaes_hex
+
+Logically joins all arguments into a single string, and returns its CHAES digest encoded as a hexadecimal string.
+
+ $chaes_hex = chaes_hex('data string');
+ #or
+ $chaes_hex = chaes_hex('any data', 'more data', 'even more data');
+
+=head2 chaes_b64
+
+Logically joins all arguments into a single string, and returns its CHAES digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $chaes_b64 = chaes_b64('data string');
+ #or
+ $chaes_b64 = chaes_b64('any data', 'more data', 'even more data');
+
+=head2 chaes_b64u
+
+Logically joins all arguments into a single string, and returns its CHAES digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $chaes_b64url = chaes_b64u('data string');
+ #or
+ $chaes_b64url = chaes_b64u('any data', 'more data', 'even more data');
+
+=head2 chaes_file
+
+Reads file (defined by filename or filehandle) content, and returns its CHAES digest encoded as a binary string.
+
+ $chaes_raw = chaes_file('filename.dat');
+ #or
+ $chaes_raw = chaes_file(*FILEHANDLE);
+
+=head2 chaes_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its CHAES digest encoded as a hexadecimal string.
+
+ $chaes_hex = chaes_file_hex('filename.dat');
+ #or
+ $chaes_hex = chaes_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 chaes_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its CHAES digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $chaes_b64 = chaes_file_b64('filename.dat');
+ #or
+ $chaes_b64 = chaes_file_b64(*FILEHANDLE);
+
+=head2 chaes_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its CHAES digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $chaes_b64url = chaes_file_b64u('filename.dat');
+ #or
+ $chaes_b64url = chaes_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::CHAES->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::CHAES->hashsize();
+ #or
+ Crypt::Digest::CHAES::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/Cryptographic_hash_function#Hash_functions_based_on_block_ciphers>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/Keccak224.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::Keccak224;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( keccak224 keccak224_hex keccak224_b64 keccak224_b64u keccak224_file keccak224_file_hex keccak224_file_b64 keccak224_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('Keccak224')             }
+sub keccak224             { Crypt::Digest::digest_data('Keccak224', @_)      }
+sub keccak224_hex         { Crypt::Digest::digest_data_hex('Keccak224', @_)  }
+sub keccak224_b64         { Crypt::Digest::digest_data_b64('Keccak224', @_)  }
+sub keccak224_b64u        { Crypt::Digest::digest_data_b64u('Keccak224', @_) }
+sub keccak224_file        { Crypt::Digest::digest_file('Keccak224', @_)      }
+sub keccak224_file_hex    { Crypt::Digest::digest_file_hex('Keccak224', @_)  }
+sub keccak224_file_b64    { Crypt::Digest::digest_file_b64('Keccak224', @_)  }
+sub keccak224_file_b64u   { Crypt::Digest::digest_file_b64u('Keccak224', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::Keccak224 - Hash function Keccak-224 [size: 224 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::Keccak224 qw( keccak224 keccak224_hex keccak224_b64 keccak224_b64u
+                                keccak224_file keccak224_file_hex keccak224_file_b64 keccak224_file_b64u );
+
+   # calculate digest from string/buffer
+   $keccak224_raw  = keccak224('data string');
+   $keccak224_hex  = keccak224_hex('data string');
+   $keccak224_b64  = keccak224_b64('data string');
+   $keccak224_b64u = keccak224_b64u('data string');
+   # calculate digest from file
+   $keccak224_raw  = keccak224_file('filename.dat');
+   $keccak224_hex  = keccak224_file_hex('filename.dat');
+   $keccak224_b64  = keccak224_file_b64('filename.dat');
+   $keccak224_b64u = keccak224_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $keccak224_raw  = keccak224_file(*FILEHANDLE);
+   $keccak224_hex  = keccak224_file_hex(*FILEHANDLE);
+   $keccak224_b64  = keccak224_file_b64(*FILEHANDLE);
+   $keccak224_b64u = keccak224_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::Keccak224;
+
+   $d = Crypt::Digest::Keccak224->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the Keccak224 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::Keccak224 qw(keccak224 keccak224_hex keccak224_b64 keccak224_b64u
+                                      keccak224_file keccak224_file_hex keccak224_file_b64 keccak224_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::Keccak224 ':all';
+
+=head1 FUNCTIONS
+
+=head2 keccak224
+
+Logically joins all arguments into a single string, and returns its Keccak224 digest encoded as a binary string.
+
+ $keccak224_raw = keccak224('data string');
+ #or
+ $keccak224_raw = keccak224('any data', 'more data', 'even more data');
+
+=head2 keccak224_hex
+
+Logically joins all arguments into a single string, and returns its Keccak224 digest encoded as a hexadecimal string.
+
+ $keccak224_hex = keccak224_hex('data string');
+ #or
+ $keccak224_hex = keccak224_hex('any data', 'more data', 'even more data');
+
+=head2 keccak224_b64
+
+Logically joins all arguments into a single string, and returns its Keccak224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $keccak224_b64 = keccak224_b64('data string');
+ #or
+ $keccak224_b64 = keccak224_b64('any data', 'more data', 'even more data');
+
+=head2 keccak224_b64u
+
+Logically joins all arguments into a single string, and returns its Keccak224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $keccak224_b64url = keccak224_b64u('data string');
+ #or
+ $keccak224_b64url = keccak224_b64u('any data', 'more data', 'even more data');
+
+=head2 keccak224_file
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak224 digest encoded as a binary string.
+
+ $keccak224_raw = keccak224_file('filename.dat');
+ #or
+ $keccak224_raw = keccak224_file(*FILEHANDLE);
+
+=head2 keccak224_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak224 digest encoded as a hexadecimal string.
+
+ $keccak224_hex = keccak224_file_hex('filename.dat');
+ #or
+ $keccak224_hex = keccak224_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 keccak224_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $keccak224_b64 = keccak224_file_b64('filename.dat');
+ #or
+ $keccak224_b64 = keccak224_file_b64(*FILEHANDLE);
+
+=head2 keccak224_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $keccak224_b64url = keccak224_file_b64u('filename.dat');
+ #or
+ $keccak224_b64url = keccak224_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::Keccak224->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::Keccak224->hashsize();
+ #or
+ Crypt::Digest::Keccak224::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://keccak.team/index.html>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/Keccak256.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::Keccak256;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( keccak256 keccak256_hex keccak256_b64 keccak256_b64u keccak256_file keccak256_file_hex keccak256_file_b64 keccak256_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('Keccak256')             }
+sub keccak256             { Crypt::Digest::digest_data('Keccak256', @_)      }
+sub keccak256_hex         { Crypt::Digest::digest_data_hex('Keccak256', @_)  }
+sub keccak256_b64         { Crypt::Digest::digest_data_b64('Keccak256', @_)  }
+sub keccak256_b64u        { Crypt::Digest::digest_data_b64u('Keccak256', @_) }
+sub keccak256_file        { Crypt::Digest::digest_file('Keccak256', @_)      }
+sub keccak256_file_hex    { Crypt::Digest::digest_file_hex('Keccak256', @_)  }
+sub keccak256_file_b64    { Crypt::Digest::digest_file_b64('Keccak256', @_)  }
+sub keccak256_file_b64u   { Crypt::Digest::digest_file_b64u('Keccak256', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::Keccak256 - Hash function Keccak-256 [size: 256 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::Keccak256 qw( keccak256 keccak256_hex keccak256_b64 keccak256_b64u
+                                keccak256_file keccak256_file_hex keccak256_file_b64 keccak256_file_b64u );
+
+   # calculate digest from string/buffer
+   $keccak256_raw  = keccak256('data string');
+   $keccak256_hex  = keccak256_hex('data string');
+   $keccak256_b64  = keccak256_b64('data string');
+   $keccak256_b64u = keccak256_b64u('data string');
+   # calculate digest from file
+   $keccak256_raw  = keccak256_file('filename.dat');
+   $keccak256_hex  = keccak256_file_hex('filename.dat');
+   $keccak256_b64  = keccak256_file_b64('filename.dat');
+   $keccak256_b64u = keccak256_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $keccak256_raw  = keccak256_file(*FILEHANDLE);
+   $keccak256_hex  = keccak256_file_hex(*FILEHANDLE);
+   $keccak256_b64  = keccak256_file_b64(*FILEHANDLE);
+   $keccak256_b64u = keccak256_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::Keccak256;
+
+   $d = Crypt::Digest::Keccak256->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the Keccak256 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::Keccak256 qw(keccak256 keccak256_hex keccak256_b64 keccak256_b64u
+                                      keccak256_file keccak256_file_hex keccak256_file_b64 keccak256_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::Keccak256 ':all';
+
+=head1 FUNCTIONS
+
+=head2 keccak256
+
+Logically joins all arguments into a single string, and returns its Keccak256 digest encoded as a binary string.
+
+ $keccak256_raw = keccak256('data string');
+ #or
+ $keccak256_raw = keccak256('any data', 'more data', 'even more data');
+
+=head2 keccak256_hex
+
+Logically joins all arguments into a single string, and returns its Keccak256 digest encoded as a hexadecimal string.
+
+ $keccak256_hex = keccak256_hex('data string');
+ #or
+ $keccak256_hex = keccak256_hex('any data', 'more data', 'even more data');
+
+=head2 keccak256_b64
+
+Logically joins all arguments into a single string, and returns its Keccak256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $keccak256_b64 = keccak256_b64('data string');
+ #or
+ $keccak256_b64 = keccak256_b64('any data', 'more data', 'even more data');
+
+=head2 keccak256_b64u
+
+Logically joins all arguments into a single string, and returns its Keccak256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $keccak256_b64url = keccak256_b64u('data string');
+ #or
+ $keccak256_b64url = keccak256_b64u('any data', 'more data', 'even more data');
+
+=head2 keccak256_file
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak256 digest encoded as a binary string.
+
+ $keccak256_raw = keccak256_file('filename.dat');
+ #or
+ $keccak256_raw = keccak256_file(*FILEHANDLE);
+
+=head2 keccak256_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak256 digest encoded as a hexadecimal string.
+
+ $keccak256_hex = keccak256_file_hex('filename.dat');
+ #or
+ $keccak256_hex = keccak256_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 keccak256_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $keccak256_b64 = keccak256_file_b64('filename.dat');
+ #or
+ $keccak256_b64 = keccak256_file_b64(*FILEHANDLE);
+
+=head2 keccak256_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $keccak256_b64url = keccak256_file_b64u('filename.dat');
+ #or
+ $keccak256_b64url = keccak256_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::Keccak256->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::Keccak256->hashsize();
+ #or
+ Crypt::Digest::Keccak256::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://keccak.team/index.html>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/Keccak384.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::Keccak384;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( keccak384 keccak384_hex keccak384_b64 keccak384_b64u keccak384_file keccak384_file_hex keccak384_file_b64 keccak384_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('Keccak384')             }
+sub keccak384             { Crypt::Digest::digest_data('Keccak384', @_)      }
+sub keccak384_hex         { Crypt::Digest::digest_data_hex('Keccak384', @_)  }
+sub keccak384_b64         { Crypt::Digest::digest_data_b64('Keccak384', @_)  }
+sub keccak384_b64u        { Crypt::Digest::digest_data_b64u('Keccak384', @_) }
+sub keccak384_file        { Crypt::Digest::digest_file('Keccak384', @_)      }
+sub keccak384_file_hex    { Crypt::Digest::digest_file_hex('Keccak384', @_)  }
+sub keccak384_file_b64    { Crypt::Digest::digest_file_b64('Keccak384', @_)  }
+sub keccak384_file_b64u   { Crypt::Digest::digest_file_b64u('Keccak384', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::Keccak384 - Hash function Keccak-384 [size: 384 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::Keccak384 qw( keccak384 keccak384_hex keccak384_b64 keccak384_b64u
+                                keccak384_file keccak384_file_hex keccak384_file_b64 keccak384_file_b64u );
+
+   # calculate digest from string/buffer
+   $keccak384_raw  = keccak384('data string');
+   $keccak384_hex  = keccak384_hex('data string');
+   $keccak384_b64  = keccak384_b64('data string');
+   $keccak384_b64u = keccak384_b64u('data string');
+   # calculate digest from file
+   $keccak384_raw  = keccak384_file('filename.dat');
+   $keccak384_hex  = keccak384_file_hex('filename.dat');
+   $keccak384_b64  = keccak384_file_b64('filename.dat');
+   $keccak384_b64u = keccak384_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $keccak384_raw  = keccak384_file(*FILEHANDLE);
+   $keccak384_hex  = keccak384_file_hex(*FILEHANDLE);
+   $keccak384_b64  = keccak384_file_b64(*FILEHANDLE);
+   $keccak384_b64u = keccak384_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::Keccak384;
+
+   $d = Crypt::Digest::Keccak384->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the Keccak384 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::Keccak384 qw(keccak384 keccak384_hex keccak384_b64 keccak384_b64u
+                                      keccak384_file keccak384_file_hex keccak384_file_b64 keccak384_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::Keccak384 ':all';
+
+=head1 FUNCTIONS
+
+=head2 keccak384
+
+Logically joins all arguments into a single string, and returns its Keccak384 digest encoded as a binary string.
+
+ $keccak384_raw = keccak384('data string');
+ #or
+ $keccak384_raw = keccak384('any data', 'more data', 'even more data');
+
+=head2 keccak384_hex
+
+Logically joins all arguments into a single string, and returns its Keccak384 digest encoded as a hexadecimal string.
+
+ $keccak384_hex = keccak384_hex('data string');
+ #or
+ $keccak384_hex = keccak384_hex('any data', 'more data', 'even more data');
+
+=head2 keccak384_b64
+
+Logically joins all arguments into a single string, and returns its Keccak384 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $keccak384_b64 = keccak384_b64('data string');
+ #or
+ $keccak384_b64 = keccak384_b64('any data', 'more data', 'even more data');
+
+=head2 keccak384_b64u
+
+Logically joins all arguments into a single string, and returns its Keccak384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $keccak384_b64url = keccak384_b64u('data string');
+ #or
+ $keccak384_b64url = keccak384_b64u('any data', 'more data', 'even more data');
+
+=head2 keccak384_file
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak384 digest encoded as a binary string.
+
+ $keccak384_raw = keccak384_file('filename.dat');
+ #or
+ $keccak384_raw = keccak384_file(*FILEHANDLE);
+
+=head2 keccak384_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak384 digest encoded as a hexadecimal string.
+
+ $keccak384_hex = keccak384_file_hex('filename.dat');
+ #or
+ $keccak384_hex = keccak384_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 keccak384_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak384 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $keccak384_b64 = keccak384_file_b64('filename.dat');
+ #or
+ $keccak384_b64 = keccak384_file_b64(*FILEHANDLE);
+
+=head2 keccak384_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $keccak384_b64url = keccak384_file_b64u('filename.dat');
+ #or
+ $keccak384_b64url = keccak384_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::Keccak384->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::Keccak384->hashsize();
+ #or
+ Crypt::Digest::Keccak384::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://keccak.team/index.html>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/Keccak512.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::Keccak512;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( keccak512 keccak512_hex keccak512_b64 keccak512_b64u keccak512_file keccak512_file_hex keccak512_file_b64 keccak512_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('Keccak512')             }
+sub keccak512             { Crypt::Digest::digest_data('Keccak512', @_)      }
+sub keccak512_hex         { Crypt::Digest::digest_data_hex('Keccak512', @_)  }
+sub keccak512_b64         { Crypt::Digest::digest_data_b64('Keccak512', @_)  }
+sub keccak512_b64u        { Crypt::Digest::digest_data_b64u('Keccak512', @_) }
+sub keccak512_file        { Crypt::Digest::digest_file('Keccak512', @_)      }
+sub keccak512_file_hex    { Crypt::Digest::digest_file_hex('Keccak512', @_)  }
+sub keccak512_file_b64    { Crypt::Digest::digest_file_b64('Keccak512', @_)  }
+sub keccak512_file_b64u   { Crypt::Digest::digest_file_b64u('Keccak512', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::Keccak512 - Hash function Keccak-512 [size: 512 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::Keccak512 qw( keccak512 keccak512_hex keccak512_b64 keccak512_b64u
+                                keccak512_file keccak512_file_hex keccak512_file_b64 keccak512_file_b64u );
+
+   # calculate digest from string/buffer
+   $keccak512_raw  = keccak512('data string');
+   $keccak512_hex  = keccak512_hex('data string');
+   $keccak512_b64  = keccak512_b64('data string');
+   $keccak512_b64u = keccak512_b64u('data string');
+   # calculate digest from file
+   $keccak512_raw  = keccak512_file('filename.dat');
+   $keccak512_hex  = keccak512_file_hex('filename.dat');
+   $keccak512_b64  = keccak512_file_b64('filename.dat');
+   $keccak512_b64u = keccak512_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $keccak512_raw  = keccak512_file(*FILEHANDLE);
+   $keccak512_hex  = keccak512_file_hex(*FILEHANDLE);
+   $keccak512_b64  = keccak512_file_b64(*FILEHANDLE);
+   $keccak512_b64u = keccak512_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::Keccak512;
+
+   $d = Crypt::Digest::Keccak512->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the Keccak512 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::Keccak512 qw(keccak512 keccak512_hex keccak512_b64 keccak512_b64u
+                                      keccak512_file keccak512_file_hex keccak512_file_b64 keccak512_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::Keccak512 ':all';
+
+=head1 FUNCTIONS
+
+=head2 keccak512
+
+Logically joins all arguments into a single string, and returns its Keccak512 digest encoded as a binary string.
+
+ $keccak512_raw = keccak512('data string');
+ #or
+ $keccak512_raw = keccak512('any data', 'more data', 'even more data');
+
+=head2 keccak512_hex
+
+Logically joins all arguments into a single string, and returns its Keccak512 digest encoded as a hexadecimal string.
+
+ $keccak512_hex = keccak512_hex('data string');
+ #or
+ $keccak512_hex = keccak512_hex('any data', 'more data', 'even more data');
+
+=head2 keccak512_b64
+
+Logically joins all arguments into a single string, and returns its Keccak512 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $keccak512_b64 = keccak512_b64('data string');
+ #or
+ $keccak512_b64 = keccak512_b64('any data', 'more data', 'even more data');
+
+=head2 keccak512_b64u
+
+Logically joins all arguments into a single string, and returns its Keccak512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $keccak512_b64url = keccak512_b64u('data string');
+ #or
+ $keccak512_b64url = keccak512_b64u('any data', 'more data', 'even more data');
+
+=head2 keccak512_file
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak512 digest encoded as a binary string.
+
+ $keccak512_raw = keccak512_file('filename.dat');
+ #or
+ $keccak512_raw = keccak512_file(*FILEHANDLE);
+
+=head2 keccak512_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak512 digest encoded as a hexadecimal string.
+
+ $keccak512_hex = keccak512_file_hex('filename.dat');
+ #or
+ $keccak512_hex = keccak512_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 keccak512_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak512 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $keccak512_b64 = keccak512_file_b64('filename.dat');
+ #or
+ $keccak512_b64 = keccak512_file_b64(*FILEHANDLE);
+
+=head2 keccak512_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its Keccak512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $keccak512_b64url = keccak512_file_b64u('filename.dat');
+ #or
+ $keccak512_b64url = keccak512_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::Keccak512->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::Keccak512->hashsize();
+ #or
+ Crypt::Digest::Keccak512::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://keccak.team/index.html>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/MD2.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::MD2;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( md2 md2_hex md2_b64 md2_b64u md2_file md2_file_hex md2_file_b64 md2_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('MD2')             }
+sub md2             { Crypt::Digest::digest_data('MD2', @_)      }
+sub md2_hex         { Crypt::Digest::digest_data_hex('MD2', @_)  }
+sub md2_b64         { Crypt::Digest::digest_data_b64('MD2', @_)  }
+sub md2_b64u        { Crypt::Digest::digest_data_b64u('MD2', @_) }
+sub md2_file        { Crypt::Digest::digest_file('MD2', @_)      }
+sub md2_file_hex    { Crypt::Digest::digest_file_hex('MD2', @_)  }
+sub md2_file_b64    { Crypt::Digest::digest_file_b64('MD2', @_)  }
+sub md2_file_b64u   { Crypt::Digest::digest_file_b64u('MD2', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::MD2 - Hash function MD2 [size: 128 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::MD2 qw( md2 md2_hex md2_b64 md2_b64u
+                                md2_file md2_file_hex md2_file_b64 md2_file_b64u );
+
+   # calculate digest from string/buffer
+   $md2_raw  = md2('data string');
+   $md2_hex  = md2_hex('data string');
+   $md2_b64  = md2_b64('data string');
+   $md2_b64u = md2_b64u('data string');
+   # calculate digest from file
+   $md2_raw  = md2_file('filename.dat');
+   $md2_hex  = md2_file_hex('filename.dat');
+   $md2_b64  = md2_file_b64('filename.dat');
+   $md2_b64u = md2_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $md2_raw  = md2_file(*FILEHANDLE);
+   $md2_hex  = md2_file_hex(*FILEHANDLE);
+   $md2_b64  = md2_file_b64(*FILEHANDLE);
+   $md2_b64u = md2_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::MD2;
+
+   $d = Crypt::Digest::MD2->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the MD2 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::MD2 qw(md2 md2_hex md2_b64 md2_b64u
+                                      md2_file md2_file_hex md2_file_b64 md2_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::MD2 ':all';
+
+=head1 FUNCTIONS
+
+=head2 md2
+
+Logically joins all arguments into a single string, and returns its MD2 digest encoded as a binary string.
+
+ $md2_raw = md2('data string');
+ #or
+ $md2_raw = md2('any data', 'more data', 'even more data');
+
+=head2 md2_hex
+
+Logically joins all arguments into a single string, and returns its MD2 digest encoded as a hexadecimal string.
+
+ $md2_hex = md2_hex('data string');
+ #or
+ $md2_hex = md2_hex('any data', 'more data', 'even more data');
+
+=head2 md2_b64
+
+Logically joins all arguments into a single string, and returns its MD2 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $md2_b64 = md2_b64('data string');
+ #or
+ $md2_b64 = md2_b64('any data', 'more data', 'even more data');
+
+=head2 md2_b64u
+
+Logically joins all arguments into a single string, and returns its MD2 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $md2_b64url = md2_b64u('data string');
+ #or
+ $md2_b64url = md2_b64u('any data', 'more data', 'even more data');
+
+=head2 md2_file
+
+Reads file (defined by filename or filehandle) content, and returns its MD2 digest encoded as a binary string.
+
+ $md2_raw = md2_file('filename.dat');
+ #or
+ $md2_raw = md2_file(*FILEHANDLE);
+
+=head2 md2_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its MD2 digest encoded as a hexadecimal string.
+
+ $md2_hex = md2_file_hex('filename.dat');
+ #or
+ $md2_hex = md2_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 md2_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its MD2 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $md2_b64 = md2_file_b64('filename.dat');
+ #or
+ $md2_b64 = md2_file_b64(*FILEHANDLE);
+
+=head2 md2_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its MD2 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $md2_b64url = md2_file_b64u('filename.dat');
+ #or
+ $md2_b64url = md2_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::MD2->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::MD2->hashsize();
+ #or
+ Crypt::Digest::MD2::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/MD2_(cryptography)>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/MD4.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::MD4;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( md4 md4_hex md4_b64 md4_b64u md4_file md4_file_hex md4_file_b64 md4_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('MD4')             }
+sub md4             { Crypt::Digest::digest_data('MD4', @_)      }
+sub md4_hex         { Crypt::Digest::digest_data_hex('MD4', @_)  }
+sub md4_b64         { Crypt::Digest::digest_data_b64('MD4', @_)  }
+sub md4_b64u        { Crypt::Digest::digest_data_b64u('MD4', @_) }
+sub md4_file        { Crypt::Digest::digest_file('MD4', @_)      }
+sub md4_file_hex    { Crypt::Digest::digest_file_hex('MD4', @_)  }
+sub md4_file_b64    { Crypt::Digest::digest_file_b64('MD4', @_)  }
+sub md4_file_b64u   { Crypt::Digest::digest_file_b64u('MD4', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::MD4 - Hash function MD4 [size: 128 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::MD4 qw( md4 md4_hex md4_b64 md4_b64u
+                                md4_file md4_file_hex md4_file_b64 md4_file_b64u );
+
+   # calculate digest from string/buffer
+   $md4_raw  = md4('data string');
+   $md4_hex  = md4_hex('data string');
+   $md4_b64  = md4_b64('data string');
+   $md4_b64u = md4_b64u('data string');
+   # calculate digest from file
+   $md4_raw  = md4_file('filename.dat');
+   $md4_hex  = md4_file_hex('filename.dat');
+   $md4_b64  = md4_file_b64('filename.dat');
+   $md4_b64u = md4_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $md4_raw  = md4_file(*FILEHANDLE);
+   $md4_hex  = md4_file_hex(*FILEHANDLE);
+   $md4_b64  = md4_file_b64(*FILEHANDLE);
+   $md4_b64u = md4_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::MD4;
+
+   $d = Crypt::Digest::MD4->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the MD4 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::MD4 qw(md4 md4_hex md4_b64 md4_b64u
+                                      md4_file md4_file_hex md4_file_b64 md4_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::MD4 ':all';
+
+=head1 FUNCTIONS
+
+=head2 md4
+
+Logically joins all arguments into a single string, and returns its MD4 digest encoded as a binary string.
+
+ $md4_raw = md4('data string');
+ #or
+ $md4_raw = md4('any data', 'more data', 'even more data');
+
+=head2 md4_hex
+
+Logically joins all arguments into a single string, and returns its MD4 digest encoded as a hexadecimal string.
+
+ $md4_hex = md4_hex('data string');
+ #or
+ $md4_hex = md4_hex('any data', 'more data', 'even more data');
+
+=head2 md4_b64
+
+Logically joins all arguments into a single string, and returns its MD4 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $md4_b64 = md4_b64('data string');
+ #or
+ $md4_b64 = md4_b64('any data', 'more data', 'even more data');
+
+=head2 md4_b64u
+
+Logically joins all arguments into a single string, and returns its MD4 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $md4_b64url = md4_b64u('data string');
+ #or
+ $md4_b64url = md4_b64u('any data', 'more data', 'even more data');
+
+=head2 md4_file
+
+Reads file (defined by filename or filehandle) content, and returns its MD4 digest encoded as a binary string.
+
+ $md4_raw = md4_file('filename.dat');
+ #or
+ $md4_raw = md4_file(*FILEHANDLE);
+
+=head2 md4_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its MD4 digest encoded as a hexadecimal string.
+
+ $md4_hex = md4_file_hex('filename.dat');
+ #or
+ $md4_hex = md4_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 md4_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its MD4 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $md4_b64 = md4_file_b64('filename.dat');
+ #or
+ $md4_b64 = md4_file_b64(*FILEHANDLE);
+
+=head2 md4_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its MD4 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $md4_b64url = md4_file_b64u('filename.dat');
+ #or
+ $md4_b64url = md4_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::MD4->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::MD4->hashsize();
+ #or
+ Crypt::Digest::MD4::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/MD4>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/MD5.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::MD5;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( md5 md5_hex md5_b64 md5_b64u md5_file md5_file_hex md5_file_b64 md5_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('MD5')             }
+sub md5             { Crypt::Digest::digest_data('MD5', @_)      }
+sub md5_hex         { Crypt::Digest::digest_data_hex('MD5', @_)  }
+sub md5_b64         { Crypt::Digest::digest_data_b64('MD5', @_)  }
+sub md5_b64u        { Crypt::Digest::digest_data_b64u('MD5', @_) }
+sub md5_file        { Crypt::Digest::digest_file('MD5', @_)      }
+sub md5_file_hex    { Crypt::Digest::digest_file_hex('MD5', @_)  }
+sub md5_file_b64    { Crypt::Digest::digest_file_b64('MD5', @_)  }
+sub md5_file_b64u   { Crypt::Digest::digest_file_b64u('MD5', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::MD5 - Hash function MD5 [size: 128 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::MD5 qw( md5 md5_hex md5_b64 md5_b64u
+                                md5_file md5_file_hex md5_file_b64 md5_file_b64u );
+
+   # calculate digest from string/buffer
+   $md5_raw  = md5('data string');
+   $md5_hex  = md5_hex('data string');
+   $md5_b64  = md5_b64('data string');
+   $md5_b64u = md5_b64u('data string');
+   # calculate digest from file
+   $md5_raw  = md5_file('filename.dat');
+   $md5_hex  = md5_file_hex('filename.dat');
+   $md5_b64  = md5_file_b64('filename.dat');
+   $md5_b64u = md5_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $md5_raw  = md5_file(*FILEHANDLE);
+   $md5_hex  = md5_file_hex(*FILEHANDLE);
+   $md5_b64  = md5_file_b64(*FILEHANDLE);
+   $md5_b64u = md5_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::MD5;
+
+   $d = Crypt::Digest::MD5->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the MD5 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::MD5 qw(md5 md5_hex md5_b64 md5_b64u
+                                      md5_file md5_file_hex md5_file_b64 md5_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::MD5 ':all';
+
+=head1 FUNCTIONS
+
+=head2 md5
+
+Logically joins all arguments into a single string, and returns its MD5 digest encoded as a binary string.
+
+ $md5_raw = md5('data string');
+ #or
+ $md5_raw = md5('any data', 'more data', 'even more data');
+
+=head2 md5_hex
+
+Logically joins all arguments into a single string, and returns its MD5 digest encoded as a hexadecimal string.
+
+ $md5_hex = md5_hex('data string');
+ #or
+ $md5_hex = md5_hex('any data', 'more data', 'even more data');
+
+=head2 md5_b64
+
+Logically joins all arguments into a single string, and returns its MD5 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $md5_b64 = md5_b64('data string');
+ #or
+ $md5_b64 = md5_b64('any data', 'more data', 'even more data');
+
+=head2 md5_b64u
+
+Logically joins all arguments into a single string, and returns its MD5 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $md5_b64url = md5_b64u('data string');
+ #or
+ $md5_b64url = md5_b64u('any data', 'more data', 'even more data');
+
+=head2 md5_file
+
+Reads file (defined by filename or filehandle) content, and returns its MD5 digest encoded as a binary string.
+
+ $md5_raw = md5_file('filename.dat');
+ #or
+ $md5_raw = md5_file(*FILEHANDLE);
+
+=head2 md5_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its MD5 digest encoded as a hexadecimal string.
+
+ $md5_hex = md5_file_hex('filename.dat');
+ #or
+ $md5_hex = md5_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 md5_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its MD5 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $md5_b64 = md5_file_b64('filename.dat');
+ #or
+ $md5_b64 = md5_file_b64(*FILEHANDLE);
+
+=head2 md5_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its MD5 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $md5_b64url = md5_file_b64u('filename.dat');
+ #or
+ $md5_b64url = md5_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::MD5->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::MD5->hashsize();
+ #or
+ Crypt::Digest::MD5::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/MD5>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/RIPEMD128.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::RIPEMD128;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( ripemd128 ripemd128_hex ripemd128_b64 ripemd128_b64u ripemd128_file ripemd128_file_hex ripemd128_file_b64 ripemd128_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('RIPEMD128')             }
+sub ripemd128             { Crypt::Digest::digest_data('RIPEMD128', @_)      }
+sub ripemd128_hex         { Crypt::Digest::digest_data_hex('RIPEMD128', @_)  }
+sub ripemd128_b64         { Crypt::Digest::digest_data_b64('RIPEMD128', @_)  }
+sub ripemd128_b64u        { Crypt::Digest::digest_data_b64u('RIPEMD128', @_) }
+sub ripemd128_file        { Crypt::Digest::digest_file('RIPEMD128', @_)      }
+sub ripemd128_file_hex    { Crypt::Digest::digest_file_hex('RIPEMD128', @_)  }
+sub ripemd128_file_b64    { Crypt::Digest::digest_file_b64('RIPEMD128', @_)  }
+sub ripemd128_file_b64u   { Crypt::Digest::digest_file_b64u('RIPEMD128', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::RIPEMD128 - Hash function RIPEMD-128 [size: 128 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::RIPEMD128 qw( ripemd128 ripemd128_hex ripemd128_b64 ripemd128_b64u
+                                ripemd128_file ripemd128_file_hex ripemd128_file_b64 ripemd128_file_b64u );
+
+   # calculate digest from string/buffer
+   $ripemd128_raw  = ripemd128('data string');
+   $ripemd128_hex  = ripemd128_hex('data string');
+   $ripemd128_b64  = ripemd128_b64('data string');
+   $ripemd128_b64u = ripemd128_b64u('data string');
+   # calculate digest from file
+   $ripemd128_raw  = ripemd128_file('filename.dat');
+   $ripemd128_hex  = ripemd128_file_hex('filename.dat');
+   $ripemd128_b64  = ripemd128_file_b64('filename.dat');
+   $ripemd128_b64u = ripemd128_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $ripemd128_raw  = ripemd128_file(*FILEHANDLE);
+   $ripemd128_hex  = ripemd128_file_hex(*FILEHANDLE);
+   $ripemd128_b64  = ripemd128_file_b64(*FILEHANDLE);
+   $ripemd128_b64u = ripemd128_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::RIPEMD128;
+
+   $d = Crypt::Digest::RIPEMD128->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the RIPEMD128 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::RIPEMD128 qw(ripemd128 ripemd128_hex ripemd128_b64 ripemd128_b64u
+                                      ripemd128_file ripemd128_file_hex ripemd128_file_b64 ripemd128_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::RIPEMD128 ':all';
+
+=head1 FUNCTIONS
+
+=head2 ripemd128
+
+Logically joins all arguments into a single string, and returns its RIPEMD128 digest encoded as a binary string.
+
+ $ripemd128_raw = ripemd128('data string');
+ #or
+ $ripemd128_raw = ripemd128('any data', 'more data', 'even more data');
+
+=head2 ripemd128_hex
+
+Logically joins all arguments into a single string, and returns its RIPEMD128 digest encoded as a hexadecimal string.
+
+ $ripemd128_hex = ripemd128_hex('data string');
+ #or
+ $ripemd128_hex = ripemd128_hex('any data', 'more data', 'even more data');
+
+=head2 ripemd128_b64
+
+Logically joins all arguments into a single string, and returns its RIPEMD128 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $ripemd128_b64 = ripemd128_b64('data string');
+ #or
+ $ripemd128_b64 = ripemd128_b64('any data', 'more data', 'even more data');
+
+=head2 ripemd128_b64u
+
+Logically joins all arguments into a single string, and returns its RIPEMD128 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $ripemd128_b64url = ripemd128_b64u('data string');
+ #or
+ $ripemd128_b64url = ripemd128_b64u('any data', 'more data', 'even more data');
+
+=head2 ripemd128_file
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD128 digest encoded as a binary string.
+
+ $ripemd128_raw = ripemd128_file('filename.dat');
+ #or
+ $ripemd128_raw = ripemd128_file(*FILEHANDLE);
+
+=head2 ripemd128_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD128 digest encoded as a hexadecimal string.
+
+ $ripemd128_hex = ripemd128_file_hex('filename.dat');
+ #or
+ $ripemd128_hex = ripemd128_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 ripemd128_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD128 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $ripemd128_b64 = ripemd128_file_b64('filename.dat');
+ #or
+ $ripemd128_b64 = ripemd128_file_b64(*FILEHANDLE);
+
+=head2 ripemd128_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD128 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $ripemd128_b64url = ripemd128_file_b64u('filename.dat');
+ #or
+ $ripemd128_b64url = ripemd128_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::RIPEMD128->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::RIPEMD128->hashsize();
+ #or
+ Crypt::Digest::RIPEMD128::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/RIPEMD>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/RIPEMD160.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::RIPEMD160;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( ripemd160 ripemd160_hex ripemd160_b64 ripemd160_b64u ripemd160_file ripemd160_file_hex ripemd160_file_b64 ripemd160_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('RIPEMD160')             }
+sub ripemd160             { Crypt::Digest::digest_data('RIPEMD160', @_)      }
+sub ripemd160_hex         { Crypt::Digest::digest_data_hex('RIPEMD160', @_)  }
+sub ripemd160_b64         { Crypt::Digest::digest_data_b64('RIPEMD160', @_)  }
+sub ripemd160_b64u        { Crypt::Digest::digest_data_b64u('RIPEMD160', @_) }
+sub ripemd160_file        { Crypt::Digest::digest_file('RIPEMD160', @_)      }
+sub ripemd160_file_hex    { Crypt::Digest::digest_file_hex('RIPEMD160', @_)  }
+sub ripemd160_file_b64    { Crypt::Digest::digest_file_b64('RIPEMD160', @_)  }
+sub ripemd160_file_b64u   { Crypt::Digest::digest_file_b64u('RIPEMD160', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::RIPEMD160 - Hash function RIPEMD-160 [size: 160 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::RIPEMD160 qw( ripemd160 ripemd160_hex ripemd160_b64 ripemd160_b64u
+                                ripemd160_file ripemd160_file_hex ripemd160_file_b64 ripemd160_file_b64u );
+
+   # calculate digest from string/buffer
+   $ripemd160_raw  = ripemd160('data string');
+   $ripemd160_hex  = ripemd160_hex('data string');
+   $ripemd160_b64  = ripemd160_b64('data string');
+   $ripemd160_b64u = ripemd160_b64u('data string');
+   # calculate digest from file
+   $ripemd160_raw  = ripemd160_file('filename.dat');
+   $ripemd160_hex  = ripemd160_file_hex('filename.dat');
+   $ripemd160_b64  = ripemd160_file_b64('filename.dat');
+   $ripemd160_b64u = ripemd160_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $ripemd160_raw  = ripemd160_file(*FILEHANDLE);
+   $ripemd160_hex  = ripemd160_file_hex(*FILEHANDLE);
+   $ripemd160_b64  = ripemd160_file_b64(*FILEHANDLE);
+   $ripemd160_b64u = ripemd160_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::RIPEMD160;
+
+   $d = Crypt::Digest::RIPEMD160->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the RIPEMD160 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::RIPEMD160 qw(ripemd160 ripemd160_hex ripemd160_b64 ripemd160_b64u
+                                      ripemd160_file ripemd160_file_hex ripemd160_file_b64 ripemd160_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::RIPEMD160 ':all';
+
+=head1 FUNCTIONS
+
+=head2 ripemd160
+
+Logically joins all arguments into a single string, and returns its RIPEMD160 digest encoded as a binary string.
+
+ $ripemd160_raw = ripemd160('data string');
+ #or
+ $ripemd160_raw = ripemd160('any data', 'more data', 'even more data');
+
+=head2 ripemd160_hex
+
+Logically joins all arguments into a single string, and returns its RIPEMD160 digest encoded as a hexadecimal string.
+
+ $ripemd160_hex = ripemd160_hex('data string');
+ #or
+ $ripemd160_hex = ripemd160_hex('any data', 'more data', 'even more data');
+
+=head2 ripemd160_b64
+
+Logically joins all arguments into a single string, and returns its RIPEMD160 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $ripemd160_b64 = ripemd160_b64('data string');
+ #or
+ $ripemd160_b64 = ripemd160_b64('any data', 'more data', 'even more data');
+
+=head2 ripemd160_b64u
+
+Logically joins all arguments into a single string, and returns its RIPEMD160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $ripemd160_b64url = ripemd160_b64u('data string');
+ #or
+ $ripemd160_b64url = ripemd160_b64u('any data', 'more data', 'even more data');
+
+=head2 ripemd160_file
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD160 digest encoded as a binary string.
+
+ $ripemd160_raw = ripemd160_file('filename.dat');
+ #or
+ $ripemd160_raw = ripemd160_file(*FILEHANDLE);
+
+=head2 ripemd160_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD160 digest encoded as a hexadecimal string.
+
+ $ripemd160_hex = ripemd160_file_hex('filename.dat');
+ #or
+ $ripemd160_hex = ripemd160_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 ripemd160_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD160 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $ripemd160_b64 = ripemd160_file_b64('filename.dat');
+ #or
+ $ripemd160_b64 = ripemd160_file_b64(*FILEHANDLE);
+
+=head2 ripemd160_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $ripemd160_b64url = ripemd160_file_b64u('filename.dat');
+ #or
+ $ripemd160_b64url = ripemd160_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::RIPEMD160->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::RIPEMD160->hashsize();
+ #or
+ Crypt::Digest::RIPEMD160::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/RIPEMD>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/RIPEMD256.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::RIPEMD256;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( ripemd256 ripemd256_hex ripemd256_b64 ripemd256_b64u ripemd256_file ripemd256_file_hex ripemd256_file_b64 ripemd256_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('RIPEMD256')             }
+sub ripemd256             { Crypt::Digest::digest_data('RIPEMD256', @_)      }
+sub ripemd256_hex         { Crypt::Digest::digest_data_hex('RIPEMD256', @_)  }
+sub ripemd256_b64         { Crypt::Digest::digest_data_b64('RIPEMD256', @_)  }
+sub ripemd256_b64u        { Crypt::Digest::digest_data_b64u('RIPEMD256', @_) }
+sub ripemd256_file        { Crypt::Digest::digest_file('RIPEMD256', @_)      }
+sub ripemd256_file_hex    { Crypt::Digest::digest_file_hex('RIPEMD256', @_)  }
+sub ripemd256_file_b64    { Crypt::Digest::digest_file_b64('RIPEMD256', @_)  }
+sub ripemd256_file_b64u   { Crypt::Digest::digest_file_b64u('RIPEMD256', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::RIPEMD256 - Hash function RIPEMD-256 [size: 256 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::RIPEMD256 qw( ripemd256 ripemd256_hex ripemd256_b64 ripemd256_b64u
+                                ripemd256_file ripemd256_file_hex ripemd256_file_b64 ripemd256_file_b64u );
+
+   # calculate digest from string/buffer
+   $ripemd256_raw  = ripemd256('data string');
+   $ripemd256_hex  = ripemd256_hex('data string');
+   $ripemd256_b64  = ripemd256_b64('data string');
+   $ripemd256_b64u = ripemd256_b64u('data string');
+   # calculate digest from file
+   $ripemd256_raw  = ripemd256_file('filename.dat');
+   $ripemd256_hex  = ripemd256_file_hex('filename.dat');
+   $ripemd256_b64  = ripemd256_file_b64('filename.dat');
+   $ripemd256_b64u = ripemd256_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $ripemd256_raw  = ripemd256_file(*FILEHANDLE);
+   $ripemd256_hex  = ripemd256_file_hex(*FILEHANDLE);
+   $ripemd256_b64  = ripemd256_file_b64(*FILEHANDLE);
+   $ripemd256_b64u = ripemd256_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::RIPEMD256;
+
+   $d = Crypt::Digest::RIPEMD256->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the RIPEMD256 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::RIPEMD256 qw(ripemd256 ripemd256_hex ripemd256_b64 ripemd256_b64u
+                                      ripemd256_file ripemd256_file_hex ripemd256_file_b64 ripemd256_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::RIPEMD256 ':all';
+
+=head1 FUNCTIONS
+
+=head2 ripemd256
+
+Logically joins all arguments into a single string, and returns its RIPEMD256 digest encoded as a binary string.
+
+ $ripemd256_raw = ripemd256('data string');
+ #or
+ $ripemd256_raw = ripemd256('any data', 'more data', 'even more data');
+
+=head2 ripemd256_hex
+
+Logically joins all arguments into a single string, and returns its RIPEMD256 digest encoded as a hexadecimal string.
+
+ $ripemd256_hex = ripemd256_hex('data string');
+ #or
+ $ripemd256_hex = ripemd256_hex('any data', 'more data', 'even more data');
+
+=head2 ripemd256_b64
+
+Logically joins all arguments into a single string, and returns its RIPEMD256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $ripemd256_b64 = ripemd256_b64('data string');
+ #or
+ $ripemd256_b64 = ripemd256_b64('any data', 'more data', 'even more data');
+
+=head2 ripemd256_b64u
+
+Logically joins all arguments into a single string, and returns its RIPEMD256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $ripemd256_b64url = ripemd256_b64u('data string');
+ #or
+ $ripemd256_b64url = ripemd256_b64u('any data', 'more data', 'even more data');
+
+=head2 ripemd256_file
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD256 digest encoded as a binary string.
+
+ $ripemd256_raw = ripemd256_file('filename.dat');
+ #or
+ $ripemd256_raw = ripemd256_file(*FILEHANDLE);
+
+=head2 ripemd256_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD256 digest encoded as a hexadecimal string.
+
+ $ripemd256_hex = ripemd256_file_hex('filename.dat');
+ #or
+ $ripemd256_hex = ripemd256_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 ripemd256_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $ripemd256_b64 = ripemd256_file_b64('filename.dat');
+ #or
+ $ripemd256_b64 = ripemd256_file_b64(*FILEHANDLE);
+
+=head2 ripemd256_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $ripemd256_b64url = ripemd256_file_b64u('filename.dat');
+ #or
+ $ripemd256_b64url = ripemd256_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::RIPEMD256->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::RIPEMD256->hashsize();
+ #or
+ Crypt::Digest::RIPEMD256::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/RIPEMD>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/RIPEMD320.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::RIPEMD320;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( ripemd320 ripemd320_hex ripemd320_b64 ripemd320_b64u ripemd320_file ripemd320_file_hex ripemd320_file_b64 ripemd320_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('RIPEMD320')             }
+sub ripemd320             { Crypt::Digest::digest_data('RIPEMD320', @_)      }
+sub ripemd320_hex         { Crypt::Digest::digest_data_hex('RIPEMD320', @_)  }
+sub ripemd320_b64         { Crypt::Digest::digest_data_b64('RIPEMD320', @_)  }
+sub ripemd320_b64u        { Crypt::Digest::digest_data_b64u('RIPEMD320', @_) }
+sub ripemd320_file        { Crypt::Digest::digest_file('RIPEMD320', @_)      }
+sub ripemd320_file_hex    { Crypt::Digest::digest_file_hex('RIPEMD320', @_)  }
+sub ripemd320_file_b64    { Crypt::Digest::digest_file_b64('RIPEMD320', @_)  }
+sub ripemd320_file_b64u   { Crypt::Digest::digest_file_b64u('RIPEMD320', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::RIPEMD320 - Hash function RIPEMD-320 [size: 320 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::RIPEMD320 qw( ripemd320 ripemd320_hex ripemd320_b64 ripemd320_b64u
+                                ripemd320_file ripemd320_file_hex ripemd320_file_b64 ripemd320_file_b64u );
+
+   # calculate digest from string/buffer
+   $ripemd320_raw  = ripemd320('data string');
+   $ripemd320_hex  = ripemd320_hex('data string');
+   $ripemd320_b64  = ripemd320_b64('data string');
+   $ripemd320_b64u = ripemd320_b64u('data string');
+   # calculate digest from file
+   $ripemd320_raw  = ripemd320_file('filename.dat');
+   $ripemd320_hex  = ripemd320_file_hex('filename.dat');
+   $ripemd320_b64  = ripemd320_file_b64('filename.dat');
+   $ripemd320_b64u = ripemd320_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $ripemd320_raw  = ripemd320_file(*FILEHANDLE);
+   $ripemd320_hex  = ripemd320_file_hex(*FILEHANDLE);
+   $ripemd320_b64  = ripemd320_file_b64(*FILEHANDLE);
+   $ripemd320_b64u = ripemd320_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::RIPEMD320;
+
+   $d = Crypt::Digest::RIPEMD320->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the RIPEMD320 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::RIPEMD320 qw(ripemd320 ripemd320_hex ripemd320_b64 ripemd320_b64u
+                                      ripemd320_file ripemd320_file_hex ripemd320_file_b64 ripemd320_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::RIPEMD320 ':all';
+
+=head1 FUNCTIONS
+
+=head2 ripemd320
+
+Logically joins all arguments into a single string, and returns its RIPEMD320 digest encoded as a binary string.
+
+ $ripemd320_raw = ripemd320('data string');
+ #or
+ $ripemd320_raw = ripemd320('any data', 'more data', 'even more data');
+
+=head2 ripemd320_hex
+
+Logically joins all arguments into a single string, and returns its RIPEMD320 digest encoded as a hexadecimal string.
+
+ $ripemd320_hex = ripemd320_hex('data string');
+ #or
+ $ripemd320_hex = ripemd320_hex('any data', 'more data', 'even more data');
+
+=head2 ripemd320_b64
+
+Logically joins all arguments into a single string, and returns its RIPEMD320 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $ripemd320_b64 = ripemd320_b64('data string');
+ #or
+ $ripemd320_b64 = ripemd320_b64('any data', 'more data', 'even more data');
+
+=head2 ripemd320_b64u
+
+Logically joins all arguments into a single string, and returns its RIPEMD320 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $ripemd320_b64url = ripemd320_b64u('data string');
+ #or
+ $ripemd320_b64url = ripemd320_b64u('any data', 'more data', 'even more data');
+
+=head2 ripemd320_file
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD320 digest encoded as a binary string.
+
+ $ripemd320_raw = ripemd320_file('filename.dat');
+ #or
+ $ripemd320_raw = ripemd320_file(*FILEHANDLE);
+
+=head2 ripemd320_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD320 digest encoded as a hexadecimal string.
+
+ $ripemd320_hex = ripemd320_file_hex('filename.dat');
+ #or
+ $ripemd320_hex = ripemd320_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 ripemd320_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD320 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $ripemd320_b64 = ripemd320_file_b64('filename.dat');
+ #or
+ $ripemd320_b64 = ripemd320_file_b64(*FILEHANDLE);
+
+=head2 ripemd320_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its RIPEMD320 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $ripemd320_b64url = ripemd320_file_b64u('filename.dat');
+ #or
+ $ripemd320_b64url = ripemd320_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::RIPEMD320->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::RIPEMD320->hashsize();
+ #or
+ Crypt::Digest::RIPEMD320::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/RIPEMD>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA1.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA1;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha1 sha1_hex sha1_b64 sha1_b64u sha1_file sha1_file_hex sha1_file_b64 sha1_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA1')             }
+sub sha1             { Crypt::Digest::digest_data('SHA1', @_)      }
+sub sha1_hex         { Crypt::Digest::digest_data_hex('SHA1', @_)  }
+sub sha1_b64         { Crypt::Digest::digest_data_b64('SHA1', @_)  }
+sub sha1_b64u        { Crypt::Digest::digest_data_b64u('SHA1', @_) }
+sub sha1_file        { Crypt::Digest::digest_file('SHA1', @_)      }
+sub sha1_file_hex    { Crypt::Digest::digest_file_hex('SHA1', @_)  }
+sub sha1_file_b64    { Crypt::Digest::digest_file_b64('SHA1', @_)  }
+sub sha1_file_b64u   { Crypt::Digest::digest_file_b64u('SHA1', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA1 - Hash function SHA-1 [size: 160 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA1 qw( sha1 sha1_hex sha1_b64 sha1_b64u
+                                sha1_file sha1_file_hex sha1_file_b64 sha1_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha1_raw  = sha1('data string');
+   $sha1_hex  = sha1_hex('data string');
+   $sha1_b64  = sha1_b64('data string');
+   $sha1_b64u = sha1_b64u('data string');
+   # calculate digest from file
+   $sha1_raw  = sha1_file('filename.dat');
+   $sha1_hex  = sha1_file_hex('filename.dat');
+   $sha1_b64  = sha1_file_b64('filename.dat');
+   $sha1_b64u = sha1_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha1_raw  = sha1_file(*FILEHANDLE);
+   $sha1_hex  = sha1_file_hex(*FILEHANDLE);
+   $sha1_b64  = sha1_file_b64(*FILEHANDLE);
+   $sha1_b64u = sha1_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA1;
+
+   $d = Crypt::Digest::SHA1->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA1 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA1 qw(sha1 sha1_hex sha1_b64 sha1_b64u
+                                      sha1_file sha1_file_hex sha1_file_b64 sha1_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA1 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha1
+
+Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a binary string.
+
+ $sha1_raw = sha1('data string');
+ #or
+ $sha1_raw = sha1('any data', 'more data', 'even more data');
+
+=head2 sha1_hex
+
+Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a hexadecimal string.
+
+ $sha1_hex = sha1_hex('data string');
+ #or
+ $sha1_hex = sha1_hex('any data', 'more data', 'even more data');
+
+=head2 sha1_b64
+
+Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha1_b64 = sha1_b64('data string');
+ #or
+ $sha1_b64 = sha1_b64('any data', 'more data', 'even more data');
+
+=head2 sha1_b64u
+
+Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha1_b64url = sha1_b64u('data string');
+ #or
+ $sha1_b64url = sha1_b64u('any data', 'more data', 'even more data');
+
+=head2 sha1_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA1 digest encoded as a binary string.
+
+ $sha1_raw = sha1_file('filename.dat');
+ #or
+ $sha1_raw = sha1_file(*FILEHANDLE);
+
+=head2 sha1_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA1 digest encoded as a hexadecimal string.
+
+ $sha1_hex = sha1_file_hex('filename.dat');
+ #or
+ $sha1_hex = sha1_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha1_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA1 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha1_b64 = sha1_file_b64('filename.dat');
+ #or
+ $sha1_b64 = sha1_file_b64(*FILEHANDLE);
+
+=head2 sha1_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA1 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha1_b64url = sha1_file_b64u('filename.dat');
+ #or
+ $sha1_b64url = sha1_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA1->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA1->hashsize();
+ #or
+ Crypt::Digest::SHA1::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-1>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA224.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA224;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha224 sha224_hex sha224_b64 sha224_b64u sha224_file sha224_file_hex sha224_file_b64 sha224_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA224')             }
+sub sha224             { Crypt::Digest::digest_data('SHA224', @_)      }
+sub sha224_hex         { Crypt::Digest::digest_data_hex('SHA224', @_)  }
+sub sha224_b64         { Crypt::Digest::digest_data_b64('SHA224', @_)  }
+sub sha224_b64u        { Crypt::Digest::digest_data_b64u('SHA224', @_) }
+sub sha224_file        { Crypt::Digest::digest_file('SHA224', @_)      }
+sub sha224_file_hex    { Crypt::Digest::digest_file_hex('SHA224', @_)  }
+sub sha224_file_b64    { Crypt::Digest::digest_file_b64('SHA224', @_)  }
+sub sha224_file_b64u   { Crypt::Digest::digest_file_b64u('SHA224', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA224 - Hash function SHA-224 [size: 224 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA224 qw( sha224 sha224_hex sha224_b64 sha224_b64u
+                                sha224_file sha224_file_hex sha224_file_b64 sha224_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha224_raw  = sha224('data string');
+   $sha224_hex  = sha224_hex('data string');
+   $sha224_b64  = sha224_b64('data string');
+   $sha224_b64u = sha224_b64u('data string');
+   # calculate digest from file
+   $sha224_raw  = sha224_file('filename.dat');
+   $sha224_hex  = sha224_file_hex('filename.dat');
+   $sha224_b64  = sha224_file_b64('filename.dat');
+   $sha224_b64u = sha224_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha224_raw  = sha224_file(*FILEHANDLE);
+   $sha224_hex  = sha224_file_hex(*FILEHANDLE);
+   $sha224_b64  = sha224_file_b64(*FILEHANDLE);
+   $sha224_b64u = sha224_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA224;
+
+   $d = Crypt::Digest::SHA224->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA224 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA224 qw(sha224 sha224_hex sha224_b64 sha224_b64u
+                                      sha224_file sha224_file_hex sha224_file_b64 sha224_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA224 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha224
+
+Logically joins all arguments into a single string, and returns its SHA224 digest encoded as a binary string.
+
+ $sha224_raw = sha224('data string');
+ #or
+ $sha224_raw = sha224('any data', 'more data', 'even more data');
+
+=head2 sha224_hex
+
+Logically joins all arguments into a single string, and returns its SHA224 digest encoded as a hexadecimal string.
+
+ $sha224_hex = sha224_hex('data string');
+ #or
+ $sha224_hex = sha224_hex('any data', 'more data', 'even more data');
+
+=head2 sha224_b64
+
+Logically joins all arguments into a single string, and returns its SHA224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha224_b64 = sha224_b64('data string');
+ #or
+ $sha224_b64 = sha224_b64('any data', 'more data', 'even more data');
+
+=head2 sha224_b64u
+
+Logically joins all arguments into a single string, and returns its SHA224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha224_b64url = sha224_b64u('data string');
+ #or
+ $sha224_b64url = sha224_b64u('any data', 'more data', 'even more data');
+
+=head2 sha224_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA224 digest encoded as a binary string.
+
+ $sha224_raw = sha224_file('filename.dat');
+ #or
+ $sha224_raw = sha224_file(*FILEHANDLE);
+
+=head2 sha224_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA224 digest encoded as a hexadecimal string.
+
+ $sha224_hex = sha224_file_hex('filename.dat');
+ #or
+ $sha224_hex = sha224_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha224_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha224_b64 = sha224_file_b64('filename.dat');
+ #or
+ $sha224_b64 = sha224_file_b64(*FILEHANDLE);
+
+=head2 sha224_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha224_b64url = sha224_file_b64u('filename.dat');
+ #or
+ $sha224_b64url = sha224_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA224->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA224->hashsize();
+ #or
+ Crypt::Digest::SHA224::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-2>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA256.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA256;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha256 sha256_hex sha256_b64 sha256_b64u sha256_file sha256_file_hex sha256_file_b64 sha256_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA256')             }
+sub sha256             { Crypt::Digest::digest_data('SHA256', @_)      }
+sub sha256_hex         { Crypt::Digest::digest_data_hex('SHA256', @_)  }
+sub sha256_b64         { Crypt::Digest::digest_data_b64('SHA256', @_)  }
+sub sha256_b64u        { Crypt::Digest::digest_data_b64u('SHA256', @_) }
+sub sha256_file        { Crypt::Digest::digest_file('SHA256', @_)      }
+sub sha256_file_hex    { Crypt::Digest::digest_file_hex('SHA256', @_)  }
+sub sha256_file_b64    { Crypt::Digest::digest_file_b64('SHA256', @_)  }
+sub sha256_file_b64u   { Crypt::Digest::digest_file_b64u('SHA256', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA256 - Hash function SHA-256 [size: 256 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA256 qw( sha256 sha256_hex sha256_b64 sha256_b64u
+                                sha256_file sha256_file_hex sha256_file_b64 sha256_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha256_raw  = sha256('data string');
+   $sha256_hex  = sha256_hex('data string');
+   $sha256_b64  = sha256_b64('data string');
+   $sha256_b64u = sha256_b64u('data string');
+   # calculate digest from file
+   $sha256_raw  = sha256_file('filename.dat');
+   $sha256_hex  = sha256_file_hex('filename.dat');
+   $sha256_b64  = sha256_file_b64('filename.dat');
+   $sha256_b64u = sha256_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha256_raw  = sha256_file(*FILEHANDLE);
+   $sha256_hex  = sha256_file_hex(*FILEHANDLE);
+   $sha256_b64  = sha256_file_b64(*FILEHANDLE);
+   $sha256_b64u = sha256_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA256;
+
+   $d = Crypt::Digest::SHA256->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA256 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA256 qw(sha256 sha256_hex sha256_b64 sha256_b64u
+                                      sha256_file sha256_file_hex sha256_file_b64 sha256_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA256 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha256
+
+Logically joins all arguments into a single string, and returns its SHA256 digest encoded as a binary string.
+
+ $sha256_raw = sha256('data string');
+ #or
+ $sha256_raw = sha256('any data', 'more data', 'even more data');
+
+=head2 sha256_hex
+
+Logically joins all arguments into a single string, and returns its SHA256 digest encoded as a hexadecimal string.
+
+ $sha256_hex = sha256_hex('data string');
+ #or
+ $sha256_hex = sha256_hex('any data', 'more data', 'even more data');
+
+=head2 sha256_b64
+
+Logically joins all arguments into a single string, and returns its SHA256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha256_b64 = sha256_b64('data string');
+ #or
+ $sha256_b64 = sha256_b64('any data', 'more data', 'even more data');
+
+=head2 sha256_b64u
+
+Logically joins all arguments into a single string, and returns its SHA256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha256_b64url = sha256_b64u('data string');
+ #or
+ $sha256_b64url = sha256_b64u('any data', 'more data', 'even more data');
+
+=head2 sha256_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA256 digest encoded as a binary string.
+
+ $sha256_raw = sha256_file('filename.dat');
+ #or
+ $sha256_raw = sha256_file(*FILEHANDLE);
+
+=head2 sha256_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA256 digest encoded as a hexadecimal string.
+
+ $sha256_hex = sha256_file_hex('filename.dat');
+ #or
+ $sha256_hex = sha256_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha256_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha256_b64 = sha256_file_b64('filename.dat');
+ #or
+ $sha256_b64 = sha256_file_b64(*FILEHANDLE);
+
+=head2 sha256_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha256_b64url = sha256_file_b64u('filename.dat');
+ #or
+ $sha256_b64url = sha256_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA256->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA256->hashsize();
+ #or
+ Crypt::Digest::SHA256::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-2>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA384.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA384;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha384 sha384_hex sha384_b64 sha384_b64u sha384_file sha384_file_hex sha384_file_b64 sha384_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA384')             }
+sub sha384             { Crypt::Digest::digest_data('SHA384', @_)      }
+sub sha384_hex         { Crypt::Digest::digest_data_hex('SHA384', @_)  }
+sub sha384_b64         { Crypt::Digest::digest_data_b64('SHA384', @_)  }
+sub sha384_b64u        { Crypt::Digest::digest_data_b64u('SHA384', @_) }
+sub sha384_file        { Crypt::Digest::digest_file('SHA384', @_)      }
+sub sha384_file_hex    { Crypt::Digest::digest_file_hex('SHA384', @_)  }
+sub sha384_file_b64    { Crypt::Digest::digest_file_b64('SHA384', @_)  }
+sub sha384_file_b64u   { Crypt::Digest::digest_file_b64u('SHA384', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA384 - Hash function SHA-384 [size: 384 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA384 qw( sha384 sha384_hex sha384_b64 sha384_b64u
+                                sha384_file sha384_file_hex sha384_file_b64 sha384_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha384_raw  = sha384('data string');
+   $sha384_hex  = sha384_hex('data string');
+   $sha384_b64  = sha384_b64('data string');
+   $sha384_b64u = sha384_b64u('data string');
+   # calculate digest from file
+   $sha384_raw  = sha384_file('filename.dat');
+   $sha384_hex  = sha384_file_hex('filename.dat');
+   $sha384_b64  = sha384_file_b64('filename.dat');
+   $sha384_b64u = sha384_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha384_raw  = sha384_file(*FILEHANDLE);
+   $sha384_hex  = sha384_file_hex(*FILEHANDLE);
+   $sha384_b64  = sha384_file_b64(*FILEHANDLE);
+   $sha384_b64u = sha384_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA384;
+
+   $d = Crypt::Digest::SHA384->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA384 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA384 qw(sha384 sha384_hex sha384_b64 sha384_b64u
+                                      sha384_file sha384_file_hex sha384_file_b64 sha384_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA384 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha384
+
+Logically joins all arguments into a single string, and returns its SHA384 digest encoded as a binary string.
+
+ $sha384_raw = sha384('data string');
+ #or
+ $sha384_raw = sha384('any data', 'more data', 'even more data');
+
+=head2 sha384_hex
+
+Logically joins all arguments into a single string, and returns its SHA384 digest encoded as a hexadecimal string.
+
+ $sha384_hex = sha384_hex('data string');
+ #or
+ $sha384_hex = sha384_hex('any data', 'more data', 'even more data');
+
+=head2 sha384_b64
+
+Logically joins all arguments into a single string, and returns its SHA384 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha384_b64 = sha384_b64('data string');
+ #or
+ $sha384_b64 = sha384_b64('any data', 'more data', 'even more data');
+
+=head2 sha384_b64u
+
+Logically joins all arguments into a single string, and returns its SHA384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha384_b64url = sha384_b64u('data string');
+ #or
+ $sha384_b64url = sha384_b64u('any data', 'more data', 'even more data');
+
+=head2 sha384_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA384 digest encoded as a binary string.
+
+ $sha384_raw = sha384_file('filename.dat');
+ #or
+ $sha384_raw = sha384_file(*FILEHANDLE);
+
+=head2 sha384_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA384 digest encoded as a hexadecimal string.
+
+ $sha384_hex = sha384_file_hex('filename.dat');
+ #or
+ $sha384_hex = sha384_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha384_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA384 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha384_b64 = sha384_file_b64('filename.dat');
+ #or
+ $sha384_b64 = sha384_file_b64(*FILEHANDLE);
+
+=head2 sha384_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha384_b64url = sha384_file_b64u('filename.dat');
+ #or
+ $sha384_b64url = sha384_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA384->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA384->hashsize();
+ #or
+ Crypt::Digest::SHA384::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-2>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA3_224.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA3_224;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha3_224 sha3_224_hex sha3_224_b64 sha3_224_b64u sha3_224_file sha3_224_file_hex sha3_224_file_b64 sha3_224_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA3_224')             }
+sub sha3_224             { Crypt::Digest::digest_data('SHA3_224', @_)      }
+sub sha3_224_hex         { Crypt::Digest::digest_data_hex('SHA3_224', @_)  }
+sub sha3_224_b64         { Crypt::Digest::digest_data_b64('SHA3_224', @_)  }
+sub sha3_224_b64u        { Crypt::Digest::digest_data_b64u('SHA3_224', @_) }
+sub sha3_224_file        { Crypt::Digest::digest_file('SHA3_224', @_)      }
+sub sha3_224_file_hex    { Crypt::Digest::digest_file_hex('SHA3_224', @_)  }
+sub sha3_224_file_b64    { Crypt::Digest::digest_file_b64('SHA3_224', @_)  }
+sub sha3_224_file_b64u   { Crypt::Digest::digest_file_b64u('SHA3_224', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA3_224 - Hash function SHA3-224 [size: 224 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA3_224 qw( sha3_224 sha3_224_hex sha3_224_b64 sha3_224_b64u
+                                sha3_224_file sha3_224_file_hex sha3_224_file_b64 sha3_224_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha3_224_raw  = sha3_224('data string');
+   $sha3_224_hex  = sha3_224_hex('data string');
+   $sha3_224_b64  = sha3_224_b64('data string');
+   $sha3_224_b64u = sha3_224_b64u('data string');
+   # calculate digest from file
+   $sha3_224_raw  = sha3_224_file('filename.dat');
+   $sha3_224_hex  = sha3_224_file_hex('filename.dat');
+   $sha3_224_b64  = sha3_224_file_b64('filename.dat');
+   $sha3_224_b64u = sha3_224_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha3_224_raw  = sha3_224_file(*FILEHANDLE);
+   $sha3_224_hex  = sha3_224_file_hex(*FILEHANDLE);
+   $sha3_224_b64  = sha3_224_file_b64(*FILEHANDLE);
+   $sha3_224_b64u = sha3_224_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA3_224;
+
+   $d = Crypt::Digest::SHA3_224->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA3_224 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA3_224 qw(sha3_224 sha3_224_hex sha3_224_b64 sha3_224_b64u
+                                      sha3_224_file sha3_224_file_hex sha3_224_file_b64 sha3_224_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA3_224 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha3_224
+
+Logically joins all arguments into a single string, and returns its SHA3_224 digest encoded as a binary string.
+
+ $sha3_224_raw = sha3_224('data string');
+ #or
+ $sha3_224_raw = sha3_224('any data', 'more data', 'even more data');
+
+=head2 sha3_224_hex
+
+Logically joins all arguments into a single string, and returns its SHA3_224 digest encoded as a hexadecimal string.
+
+ $sha3_224_hex = sha3_224_hex('data string');
+ #or
+ $sha3_224_hex = sha3_224_hex('any data', 'more data', 'even more data');
+
+=head2 sha3_224_b64
+
+Logically joins all arguments into a single string, and returns its SHA3_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha3_224_b64 = sha3_224_b64('data string');
+ #or
+ $sha3_224_b64 = sha3_224_b64('any data', 'more data', 'even more data');
+
+=head2 sha3_224_b64u
+
+Logically joins all arguments into a single string, and returns its SHA3_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha3_224_b64url = sha3_224_b64u('data string');
+ #or
+ $sha3_224_b64url = sha3_224_b64u('any data', 'more data', 'even more data');
+
+=head2 sha3_224_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_224 digest encoded as a binary string.
+
+ $sha3_224_raw = sha3_224_file('filename.dat');
+ #or
+ $sha3_224_raw = sha3_224_file(*FILEHANDLE);
+
+=head2 sha3_224_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_224 digest encoded as a hexadecimal string.
+
+ $sha3_224_hex = sha3_224_file_hex('filename.dat');
+ #or
+ $sha3_224_hex = sha3_224_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha3_224_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha3_224_b64 = sha3_224_file_b64('filename.dat');
+ #or
+ $sha3_224_b64 = sha3_224_file_b64(*FILEHANDLE);
+
+=head2 sha3_224_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha3_224_b64url = sha3_224_file_b64u('filename.dat');
+ #or
+ $sha3_224_b64url = sha3_224_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA3_224->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA3_224->hashsize();
+ #or
+ Crypt::Digest::SHA3_224::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-3>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA3_256.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA3_256;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha3_256 sha3_256_hex sha3_256_b64 sha3_256_b64u sha3_256_file sha3_256_file_hex sha3_256_file_b64 sha3_256_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA3_256')             }
+sub sha3_256             { Crypt::Digest::digest_data('SHA3_256', @_)      }
+sub sha3_256_hex         { Crypt::Digest::digest_data_hex('SHA3_256', @_)  }
+sub sha3_256_b64         { Crypt::Digest::digest_data_b64('SHA3_256', @_)  }
+sub sha3_256_b64u        { Crypt::Digest::digest_data_b64u('SHA3_256', @_) }
+sub sha3_256_file        { Crypt::Digest::digest_file('SHA3_256', @_)      }
+sub sha3_256_file_hex    { Crypt::Digest::digest_file_hex('SHA3_256', @_)  }
+sub sha3_256_file_b64    { Crypt::Digest::digest_file_b64('SHA3_256', @_)  }
+sub sha3_256_file_b64u   { Crypt::Digest::digest_file_b64u('SHA3_256', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA3_256 - Hash function SHA3-256 [size: 256 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA3_256 qw( sha3_256 sha3_256_hex sha3_256_b64 sha3_256_b64u
+                                sha3_256_file sha3_256_file_hex sha3_256_file_b64 sha3_256_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha3_256_raw  = sha3_256('data string');
+   $sha3_256_hex  = sha3_256_hex('data string');
+   $sha3_256_b64  = sha3_256_b64('data string');
+   $sha3_256_b64u = sha3_256_b64u('data string');
+   # calculate digest from file
+   $sha3_256_raw  = sha3_256_file('filename.dat');
+   $sha3_256_hex  = sha3_256_file_hex('filename.dat');
+   $sha3_256_b64  = sha3_256_file_b64('filename.dat');
+   $sha3_256_b64u = sha3_256_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha3_256_raw  = sha3_256_file(*FILEHANDLE);
+   $sha3_256_hex  = sha3_256_file_hex(*FILEHANDLE);
+   $sha3_256_b64  = sha3_256_file_b64(*FILEHANDLE);
+   $sha3_256_b64u = sha3_256_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA3_256;
+
+   $d = Crypt::Digest::SHA3_256->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA3_256 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA3_256 qw(sha3_256 sha3_256_hex sha3_256_b64 sha3_256_b64u
+                                      sha3_256_file sha3_256_file_hex sha3_256_file_b64 sha3_256_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA3_256 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha3_256
+
+Logically joins all arguments into a single string, and returns its SHA3_256 digest encoded as a binary string.
+
+ $sha3_256_raw = sha3_256('data string');
+ #or
+ $sha3_256_raw = sha3_256('any data', 'more data', 'even more data');
+
+=head2 sha3_256_hex
+
+Logically joins all arguments into a single string, and returns its SHA3_256 digest encoded as a hexadecimal string.
+
+ $sha3_256_hex = sha3_256_hex('data string');
+ #or
+ $sha3_256_hex = sha3_256_hex('any data', 'more data', 'even more data');
+
+=head2 sha3_256_b64
+
+Logically joins all arguments into a single string, and returns its SHA3_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha3_256_b64 = sha3_256_b64('data string');
+ #or
+ $sha3_256_b64 = sha3_256_b64('any data', 'more data', 'even more data');
+
+=head2 sha3_256_b64u
+
+Logically joins all arguments into a single string, and returns its SHA3_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha3_256_b64url = sha3_256_b64u('data string');
+ #or
+ $sha3_256_b64url = sha3_256_b64u('any data', 'more data', 'even more data');
+
+=head2 sha3_256_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_256 digest encoded as a binary string.
+
+ $sha3_256_raw = sha3_256_file('filename.dat');
+ #or
+ $sha3_256_raw = sha3_256_file(*FILEHANDLE);
+
+=head2 sha3_256_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_256 digest encoded as a hexadecimal string.
+
+ $sha3_256_hex = sha3_256_file_hex('filename.dat');
+ #or
+ $sha3_256_hex = sha3_256_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha3_256_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha3_256_b64 = sha3_256_file_b64('filename.dat');
+ #or
+ $sha3_256_b64 = sha3_256_file_b64(*FILEHANDLE);
+
+=head2 sha3_256_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha3_256_b64url = sha3_256_file_b64u('filename.dat');
+ #or
+ $sha3_256_b64url = sha3_256_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA3_256->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA3_256->hashsize();
+ #or
+ Crypt::Digest::SHA3_256::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-3>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA3_384.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA3_384;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha3_384 sha3_384_hex sha3_384_b64 sha3_384_b64u sha3_384_file sha3_384_file_hex sha3_384_file_b64 sha3_384_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA3_384')             }
+sub sha3_384             { Crypt::Digest::digest_data('SHA3_384', @_)      }
+sub sha3_384_hex         { Crypt::Digest::digest_data_hex('SHA3_384', @_)  }
+sub sha3_384_b64         { Crypt::Digest::digest_data_b64('SHA3_384', @_)  }
+sub sha3_384_b64u        { Crypt::Digest::digest_data_b64u('SHA3_384', @_) }
+sub sha3_384_file        { Crypt::Digest::digest_file('SHA3_384', @_)      }
+sub sha3_384_file_hex    { Crypt::Digest::digest_file_hex('SHA3_384', @_)  }
+sub sha3_384_file_b64    { Crypt::Digest::digest_file_b64('SHA3_384', @_)  }
+sub sha3_384_file_b64u   { Crypt::Digest::digest_file_b64u('SHA3_384', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA3_384 - Hash function SHA3-384 [size: 384 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA3_384 qw( sha3_384 sha3_384_hex sha3_384_b64 sha3_384_b64u
+                                sha3_384_file sha3_384_file_hex sha3_384_file_b64 sha3_384_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha3_384_raw  = sha3_384('data string');
+   $sha3_384_hex  = sha3_384_hex('data string');
+   $sha3_384_b64  = sha3_384_b64('data string');
+   $sha3_384_b64u = sha3_384_b64u('data string');
+   # calculate digest from file
+   $sha3_384_raw  = sha3_384_file('filename.dat');
+   $sha3_384_hex  = sha3_384_file_hex('filename.dat');
+   $sha3_384_b64  = sha3_384_file_b64('filename.dat');
+   $sha3_384_b64u = sha3_384_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha3_384_raw  = sha3_384_file(*FILEHANDLE);
+   $sha3_384_hex  = sha3_384_file_hex(*FILEHANDLE);
+   $sha3_384_b64  = sha3_384_file_b64(*FILEHANDLE);
+   $sha3_384_b64u = sha3_384_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA3_384;
+
+   $d = Crypt::Digest::SHA3_384->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA3_384 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA3_384 qw(sha3_384 sha3_384_hex sha3_384_b64 sha3_384_b64u
+                                      sha3_384_file sha3_384_file_hex sha3_384_file_b64 sha3_384_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA3_384 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha3_384
+
+Logically joins all arguments into a single string, and returns its SHA3_384 digest encoded as a binary string.
+
+ $sha3_384_raw = sha3_384('data string');
+ #or
+ $sha3_384_raw = sha3_384('any data', 'more data', 'even more data');
+
+=head2 sha3_384_hex
+
+Logically joins all arguments into a single string, and returns its SHA3_384 digest encoded as a hexadecimal string.
+
+ $sha3_384_hex = sha3_384_hex('data string');
+ #or
+ $sha3_384_hex = sha3_384_hex('any data', 'more data', 'even more data');
+
+=head2 sha3_384_b64
+
+Logically joins all arguments into a single string, and returns its SHA3_384 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha3_384_b64 = sha3_384_b64('data string');
+ #or
+ $sha3_384_b64 = sha3_384_b64('any data', 'more data', 'even more data');
+
+=head2 sha3_384_b64u
+
+Logically joins all arguments into a single string, and returns its SHA3_384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha3_384_b64url = sha3_384_b64u('data string');
+ #or
+ $sha3_384_b64url = sha3_384_b64u('any data', 'more data', 'even more data');
+
+=head2 sha3_384_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_384 digest encoded as a binary string.
+
+ $sha3_384_raw = sha3_384_file('filename.dat');
+ #or
+ $sha3_384_raw = sha3_384_file(*FILEHANDLE);
+
+=head2 sha3_384_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_384 digest encoded as a hexadecimal string.
+
+ $sha3_384_hex = sha3_384_file_hex('filename.dat');
+ #or
+ $sha3_384_hex = sha3_384_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha3_384_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_384 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha3_384_b64 = sha3_384_file_b64('filename.dat');
+ #or
+ $sha3_384_b64 = sha3_384_file_b64(*FILEHANDLE);
+
+=head2 sha3_384_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha3_384_b64url = sha3_384_file_b64u('filename.dat');
+ #or
+ $sha3_384_b64url = sha3_384_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA3_384->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA3_384->hashsize();
+ #or
+ Crypt::Digest::SHA3_384::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-3>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA3_512.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA3_512;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha3_512 sha3_512_hex sha3_512_b64 sha3_512_b64u sha3_512_file sha3_512_file_hex sha3_512_file_b64 sha3_512_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA3_512')             }
+sub sha3_512             { Crypt::Digest::digest_data('SHA3_512', @_)      }
+sub sha3_512_hex         { Crypt::Digest::digest_data_hex('SHA3_512', @_)  }
+sub sha3_512_b64         { Crypt::Digest::digest_data_b64('SHA3_512', @_)  }
+sub sha3_512_b64u        { Crypt::Digest::digest_data_b64u('SHA3_512', @_) }
+sub sha3_512_file        { Crypt::Digest::digest_file('SHA3_512', @_)      }
+sub sha3_512_file_hex    { Crypt::Digest::digest_file_hex('SHA3_512', @_)  }
+sub sha3_512_file_b64    { Crypt::Digest::digest_file_b64('SHA3_512', @_)  }
+sub sha3_512_file_b64u   { Crypt::Digest::digest_file_b64u('SHA3_512', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA3_512 - Hash function SHA3-512 [size: 512 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA3_512 qw( sha3_512 sha3_512_hex sha3_512_b64 sha3_512_b64u
+                                sha3_512_file sha3_512_file_hex sha3_512_file_b64 sha3_512_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha3_512_raw  = sha3_512('data string');
+   $sha3_512_hex  = sha3_512_hex('data string');
+   $sha3_512_b64  = sha3_512_b64('data string');
+   $sha3_512_b64u = sha3_512_b64u('data string');
+   # calculate digest from file
+   $sha3_512_raw  = sha3_512_file('filename.dat');
+   $sha3_512_hex  = sha3_512_file_hex('filename.dat');
+   $sha3_512_b64  = sha3_512_file_b64('filename.dat');
+   $sha3_512_b64u = sha3_512_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha3_512_raw  = sha3_512_file(*FILEHANDLE);
+   $sha3_512_hex  = sha3_512_file_hex(*FILEHANDLE);
+   $sha3_512_b64  = sha3_512_file_b64(*FILEHANDLE);
+   $sha3_512_b64u = sha3_512_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA3_512;
+
+   $d = Crypt::Digest::SHA3_512->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA3_512 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA3_512 qw(sha3_512 sha3_512_hex sha3_512_b64 sha3_512_b64u
+                                      sha3_512_file sha3_512_file_hex sha3_512_file_b64 sha3_512_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA3_512 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha3_512
+
+Logically joins all arguments into a single string, and returns its SHA3_512 digest encoded as a binary string.
+
+ $sha3_512_raw = sha3_512('data string');
+ #or
+ $sha3_512_raw = sha3_512('any data', 'more data', 'even more data');
+
+=head2 sha3_512_hex
+
+Logically joins all arguments into a single string, and returns its SHA3_512 digest encoded as a hexadecimal string.
+
+ $sha3_512_hex = sha3_512_hex('data string');
+ #or
+ $sha3_512_hex = sha3_512_hex('any data', 'more data', 'even more data');
+
+=head2 sha3_512_b64
+
+Logically joins all arguments into a single string, and returns its SHA3_512 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha3_512_b64 = sha3_512_b64('data string');
+ #or
+ $sha3_512_b64 = sha3_512_b64('any data', 'more data', 'even more data');
+
+=head2 sha3_512_b64u
+
+Logically joins all arguments into a single string, and returns its SHA3_512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha3_512_b64url = sha3_512_b64u('data string');
+ #or
+ $sha3_512_b64url = sha3_512_b64u('any data', 'more data', 'even more data');
+
+=head2 sha3_512_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_512 digest encoded as a binary string.
+
+ $sha3_512_raw = sha3_512_file('filename.dat');
+ #or
+ $sha3_512_raw = sha3_512_file(*FILEHANDLE);
+
+=head2 sha3_512_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_512 digest encoded as a hexadecimal string.
+
+ $sha3_512_hex = sha3_512_file_hex('filename.dat');
+ #or
+ $sha3_512_hex = sha3_512_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha3_512_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_512 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha3_512_b64 = sha3_512_file_b64('filename.dat');
+ #or
+ $sha3_512_b64 = sha3_512_file_b64(*FILEHANDLE);
+
+=head2 sha3_512_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA3_512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha3_512_b64url = sha3_512_file_b64u('filename.dat');
+ #or
+ $sha3_512_b64url = sha3_512_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA3_512->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA3_512->hashsize();
+ #or
+ Crypt::Digest::SHA3_512::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-3>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA512.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA512;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha512 sha512_hex sha512_b64 sha512_b64u sha512_file sha512_file_hex sha512_file_b64 sha512_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA512')             }
+sub sha512             { Crypt::Digest::digest_data('SHA512', @_)      }
+sub sha512_hex         { Crypt::Digest::digest_data_hex('SHA512', @_)  }
+sub sha512_b64         { Crypt::Digest::digest_data_b64('SHA512', @_)  }
+sub sha512_b64u        { Crypt::Digest::digest_data_b64u('SHA512', @_) }
+sub sha512_file        { Crypt::Digest::digest_file('SHA512', @_)      }
+sub sha512_file_hex    { Crypt::Digest::digest_file_hex('SHA512', @_)  }
+sub sha512_file_b64    { Crypt::Digest::digest_file_b64('SHA512', @_)  }
+sub sha512_file_b64u   { Crypt::Digest::digest_file_b64u('SHA512', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA512 - Hash function SHA-512 [size: 512 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA512 qw( sha512 sha512_hex sha512_b64 sha512_b64u
+                                sha512_file sha512_file_hex sha512_file_b64 sha512_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha512_raw  = sha512('data string');
+   $sha512_hex  = sha512_hex('data string');
+   $sha512_b64  = sha512_b64('data string');
+   $sha512_b64u = sha512_b64u('data string');
+   # calculate digest from file
+   $sha512_raw  = sha512_file('filename.dat');
+   $sha512_hex  = sha512_file_hex('filename.dat');
+   $sha512_b64  = sha512_file_b64('filename.dat');
+   $sha512_b64u = sha512_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha512_raw  = sha512_file(*FILEHANDLE);
+   $sha512_hex  = sha512_file_hex(*FILEHANDLE);
+   $sha512_b64  = sha512_file_b64(*FILEHANDLE);
+   $sha512_b64u = sha512_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA512;
+
+   $d = Crypt::Digest::SHA512->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA512 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA512 qw(sha512 sha512_hex sha512_b64 sha512_b64u
+                                      sha512_file sha512_file_hex sha512_file_b64 sha512_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA512 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha512
+
+Logically joins all arguments into a single string, and returns its SHA512 digest encoded as a binary string.
+
+ $sha512_raw = sha512('data string');
+ #or
+ $sha512_raw = sha512('any data', 'more data', 'even more data');
+
+=head2 sha512_hex
+
+Logically joins all arguments into a single string, and returns its SHA512 digest encoded as a hexadecimal string.
+
+ $sha512_hex = sha512_hex('data string');
+ #or
+ $sha512_hex = sha512_hex('any data', 'more data', 'even more data');
+
+=head2 sha512_b64
+
+Logically joins all arguments into a single string, and returns its SHA512 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha512_b64 = sha512_b64('data string');
+ #or
+ $sha512_b64 = sha512_b64('any data', 'more data', 'even more data');
+
+=head2 sha512_b64u
+
+Logically joins all arguments into a single string, and returns its SHA512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha512_b64url = sha512_b64u('data string');
+ #or
+ $sha512_b64url = sha512_b64u('any data', 'more data', 'even more data');
+
+=head2 sha512_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512 digest encoded as a binary string.
+
+ $sha512_raw = sha512_file('filename.dat');
+ #or
+ $sha512_raw = sha512_file(*FILEHANDLE);
+
+=head2 sha512_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512 digest encoded as a hexadecimal string.
+
+ $sha512_hex = sha512_file_hex('filename.dat');
+ #or
+ $sha512_hex = sha512_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha512_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha512_b64 = sha512_file_b64('filename.dat');
+ #or
+ $sha512_b64 = sha512_file_b64(*FILEHANDLE);
+
+=head2 sha512_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha512_b64url = sha512_file_b64u('filename.dat');
+ #or
+ $sha512_b64url = sha512_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA512->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA512->hashsize();
+ #or
+ Crypt::Digest::SHA512::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-2>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA512_224.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA512_224;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha512_224 sha512_224_hex sha512_224_b64 sha512_224_b64u sha512_224_file sha512_224_file_hex sha512_224_file_b64 sha512_224_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA512_224')             }
+sub sha512_224             { Crypt::Digest::digest_data('SHA512_224', @_)      }
+sub sha512_224_hex         { Crypt::Digest::digest_data_hex('SHA512_224', @_)  }
+sub sha512_224_b64         { Crypt::Digest::digest_data_b64('SHA512_224', @_)  }
+sub sha512_224_b64u        { Crypt::Digest::digest_data_b64u('SHA512_224', @_) }
+sub sha512_224_file        { Crypt::Digest::digest_file('SHA512_224', @_)      }
+sub sha512_224_file_hex    { Crypt::Digest::digest_file_hex('SHA512_224', @_)  }
+sub sha512_224_file_b64    { Crypt::Digest::digest_file_b64('SHA512_224', @_)  }
+sub sha512_224_file_b64u   { Crypt::Digest::digest_file_b64u('SHA512_224', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA512_224 - Hash function SHA-512/224 [size: 224 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA512_224 qw( sha512_224 sha512_224_hex sha512_224_b64 sha512_224_b64u
+                                sha512_224_file sha512_224_file_hex sha512_224_file_b64 sha512_224_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha512_224_raw  = sha512_224('data string');
+   $sha512_224_hex  = sha512_224_hex('data string');
+   $sha512_224_b64  = sha512_224_b64('data string');
+   $sha512_224_b64u = sha512_224_b64u('data string');
+   # calculate digest from file
+   $sha512_224_raw  = sha512_224_file('filename.dat');
+   $sha512_224_hex  = sha512_224_file_hex('filename.dat');
+   $sha512_224_b64  = sha512_224_file_b64('filename.dat');
+   $sha512_224_b64u = sha512_224_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha512_224_raw  = sha512_224_file(*FILEHANDLE);
+   $sha512_224_hex  = sha512_224_file_hex(*FILEHANDLE);
+   $sha512_224_b64  = sha512_224_file_b64(*FILEHANDLE);
+   $sha512_224_b64u = sha512_224_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA512_224;
+
+   $d = Crypt::Digest::SHA512_224->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA512_224 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA512_224 qw(sha512_224 sha512_224_hex sha512_224_b64 sha512_224_b64u
+                                      sha512_224_file sha512_224_file_hex sha512_224_file_b64 sha512_224_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA512_224 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha512_224
+
+Logically joins all arguments into a single string, and returns its SHA512_224 digest encoded as a binary string.
+
+ $sha512_224_raw = sha512_224('data string');
+ #or
+ $sha512_224_raw = sha512_224('any data', 'more data', 'even more data');
+
+=head2 sha512_224_hex
+
+Logically joins all arguments into a single string, and returns its SHA512_224 digest encoded as a hexadecimal string.
+
+ $sha512_224_hex = sha512_224_hex('data string');
+ #or
+ $sha512_224_hex = sha512_224_hex('any data', 'more data', 'even more data');
+
+=head2 sha512_224_b64
+
+Logically joins all arguments into a single string, and returns its SHA512_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha512_224_b64 = sha512_224_b64('data string');
+ #or
+ $sha512_224_b64 = sha512_224_b64('any data', 'more data', 'even more data');
+
+=head2 sha512_224_b64u
+
+Logically joins all arguments into a single string, and returns its SHA512_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha512_224_b64url = sha512_224_b64u('data string');
+ #or
+ $sha512_224_b64url = sha512_224_b64u('any data', 'more data', 'even more data');
+
+=head2 sha512_224_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512_224 digest encoded as a binary string.
+
+ $sha512_224_raw = sha512_224_file('filename.dat');
+ #or
+ $sha512_224_raw = sha512_224_file(*FILEHANDLE);
+
+=head2 sha512_224_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512_224 digest encoded as a hexadecimal string.
+
+ $sha512_224_hex = sha512_224_file_hex('filename.dat');
+ #or
+ $sha512_224_hex = sha512_224_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha512_224_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha512_224_b64 = sha512_224_file_b64('filename.dat');
+ #or
+ $sha512_224_b64 = sha512_224_file_b64(*FILEHANDLE);
+
+=head2 sha512_224_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha512_224_b64url = sha512_224_file_b64u('filename.dat');
+ #or
+ $sha512_224_b64url = sha512_224_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA512_224->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA512_224->hashsize();
+ #or
+ Crypt::Digest::SHA512_224::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-2>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHA512_256.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::SHA512_256;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( sha512_256 sha512_256_hex sha512_256_b64 sha512_256_b64u sha512_256_file sha512_256_file_hex sha512_256_file_b64 sha512_256_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('SHA512_256')             }
+sub sha512_256             { Crypt::Digest::digest_data('SHA512_256', @_)      }
+sub sha512_256_hex         { Crypt::Digest::digest_data_hex('SHA512_256', @_)  }
+sub sha512_256_b64         { Crypt::Digest::digest_data_b64('SHA512_256', @_)  }
+sub sha512_256_b64u        { Crypt::Digest::digest_data_b64u('SHA512_256', @_) }
+sub sha512_256_file        { Crypt::Digest::digest_file('SHA512_256', @_)      }
+sub sha512_256_file_hex    { Crypt::Digest::digest_file_hex('SHA512_256', @_)  }
+sub sha512_256_file_b64    { Crypt::Digest::digest_file_b64('SHA512_256', @_)  }
+sub sha512_256_file_b64u   { Crypt::Digest::digest_file_b64u('SHA512_256', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHA512_256 - Hash function SHA-512/256 [size: 256 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::SHA512_256 qw( sha512_256 sha512_256_hex sha512_256_b64 sha512_256_b64u
+                                sha512_256_file sha512_256_file_hex sha512_256_file_b64 sha512_256_file_b64u );
+
+   # calculate digest from string/buffer
+   $sha512_256_raw  = sha512_256('data string');
+   $sha512_256_hex  = sha512_256_hex('data string');
+   $sha512_256_b64  = sha512_256_b64('data string');
+   $sha512_256_b64u = sha512_256_b64u('data string');
+   # calculate digest from file
+   $sha512_256_raw  = sha512_256_file('filename.dat');
+   $sha512_256_hex  = sha512_256_file_hex('filename.dat');
+   $sha512_256_b64  = sha512_256_file_b64('filename.dat');
+   $sha512_256_b64u = sha512_256_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $sha512_256_raw  = sha512_256_file(*FILEHANDLE);
+   $sha512_256_hex  = sha512_256_file_hex(*FILEHANDLE);
+   $sha512_256_b64  = sha512_256_file_b64(*FILEHANDLE);
+   $sha512_256_b64u = sha512_256_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::SHA512_256;
+
+   $d = Crypt::Digest::SHA512_256->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA512_256 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::SHA512_256 qw(sha512_256 sha512_256_hex sha512_256_b64 sha512_256_b64u
+                                      sha512_256_file sha512_256_file_hex sha512_256_file_b64 sha512_256_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::SHA512_256 ':all';
+
+=head1 FUNCTIONS
+
+=head2 sha512_256
+
+Logically joins all arguments into a single string, and returns its SHA512_256 digest encoded as a binary string.
+
+ $sha512_256_raw = sha512_256('data string');
+ #or
+ $sha512_256_raw = sha512_256('any data', 'more data', 'even more data');
+
+=head2 sha512_256_hex
+
+Logically joins all arguments into a single string, and returns its SHA512_256 digest encoded as a hexadecimal string.
+
+ $sha512_256_hex = sha512_256_hex('data string');
+ #or
+ $sha512_256_hex = sha512_256_hex('any data', 'more data', 'even more data');
+
+=head2 sha512_256_b64
+
+Logically joins all arguments into a single string, and returns its SHA512_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha512_256_b64 = sha512_256_b64('data string');
+ #or
+ $sha512_256_b64 = sha512_256_b64('any data', 'more data', 'even more data');
+
+=head2 sha512_256_b64u
+
+Logically joins all arguments into a single string, and returns its SHA512_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha512_256_b64url = sha512_256_b64u('data string');
+ #or
+ $sha512_256_b64url = sha512_256_b64u('any data', 'more data', 'even more data');
+
+=head2 sha512_256_file
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512_256 digest encoded as a binary string.
+
+ $sha512_256_raw = sha512_256_file('filename.dat');
+ #or
+ $sha512_256_raw = sha512_256_file(*FILEHANDLE);
+
+=head2 sha512_256_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512_256 digest encoded as a hexadecimal string.
+
+ $sha512_256_hex = sha512_256_file_hex('filename.dat');
+ #or
+ $sha512_256_hex = sha512_256_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 sha512_256_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $sha512_256_b64 = sha512_256_file_b64('filename.dat');
+ #or
+ $sha512_256_b64 = sha512_256_file_b64(*FILEHANDLE);
+
+=head2 sha512_256_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its SHA512_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $sha512_256_b64url = sha512_256_file_b64u('filename.dat');
+ #or
+ $sha512_256_b64url = sha512_256_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::SHA512_256->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::SHA512_256->hashsize();
+ #or
+ Crypt::Digest::SHA512_256::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/SHA-2>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/SHAKE.pm

@@ -0,0 +1,102 @@
+package Crypt::Digest::SHAKE;
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use CryptX;
+
+sub addfile {
+  my ($self, $file) = @_;
+
+  my $handle;
+  if (ref(\$file) eq 'SCALAR') {        #filename
+    open($handle, "<", $file) || croak "FATAL: cannot open '$file': $!";
+    binmode($handle);
+  }
+  else {                                #handle
+    $handle = $file
+  }
+  croak "FATAL: invalid handle" unless defined $handle;
+
+  my $n;
+  my $buf = "";
+  while (($n = read($handle, $buf, 32*1024))) {
+    $self->add($buf)
+  }
+  croak "FATAL: read failed: $!" unless defined $n;
+
+  return $self;
+}
+
+sub CLONE_SKIP { 1 } # prevent cloning
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::SHAKE - Hash functions SHAKE128, SHAKE256 from SHA3 family
+
+=head1 SYNOPSIS
+
+   use Crypt::Digest::SHAKE
+
+   $d = Crypt::Digest::SHAKE->new(128);
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $part1 = $d->done(100); # 100 raw bytes
+   $part2 = $d->done(100); # another 100 raw bytes
+   #...
+
+=head1 DESCRIPTION
+
+Provides an interface to the SHA3's sponge function SHAKE.
+
+=head1 METHODS
+
+=head2 new
+
+ $d = Crypt::Digest::SHA3-SHAKE->new($num);
+ # $num ... 128 or 256
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 done
+
+ $result_raw = $d->done($len);
+ # can be called multiple times
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
+
+=item * L<http://en.wikipedia.org/wiki/SHA-3|http://en.wikipedia.org/wiki/SHA-3>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/Tiger192.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::Tiger192;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( tiger192 tiger192_hex tiger192_b64 tiger192_b64u tiger192_file tiger192_file_hex tiger192_file_b64 tiger192_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('Tiger192')             }
+sub tiger192             { Crypt::Digest::digest_data('Tiger192', @_)      }
+sub tiger192_hex         { Crypt::Digest::digest_data_hex('Tiger192', @_)  }
+sub tiger192_b64         { Crypt::Digest::digest_data_b64('Tiger192', @_)  }
+sub tiger192_b64u        { Crypt::Digest::digest_data_b64u('Tiger192', @_) }
+sub tiger192_file        { Crypt::Digest::digest_file('Tiger192', @_)      }
+sub tiger192_file_hex    { Crypt::Digest::digest_file_hex('Tiger192', @_)  }
+sub tiger192_file_b64    { Crypt::Digest::digest_file_b64('Tiger192', @_)  }
+sub tiger192_file_b64u   { Crypt::Digest::digest_file_b64u('Tiger192', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::Tiger192 - Hash function Tiger-192 [size: 192 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::Tiger192 qw( tiger192 tiger192_hex tiger192_b64 tiger192_b64u
+                                tiger192_file tiger192_file_hex tiger192_file_b64 tiger192_file_b64u );
+
+   # calculate digest from string/buffer
+   $tiger192_raw  = tiger192('data string');
+   $tiger192_hex  = tiger192_hex('data string');
+   $tiger192_b64  = tiger192_b64('data string');
+   $tiger192_b64u = tiger192_b64u('data string');
+   # calculate digest from file
+   $tiger192_raw  = tiger192_file('filename.dat');
+   $tiger192_hex  = tiger192_file_hex('filename.dat');
+   $tiger192_b64  = tiger192_file_b64('filename.dat');
+   $tiger192_b64u = tiger192_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $tiger192_raw  = tiger192_file(*FILEHANDLE);
+   $tiger192_hex  = tiger192_file_hex(*FILEHANDLE);
+   $tiger192_b64  = tiger192_file_b64(*FILEHANDLE);
+   $tiger192_b64u = tiger192_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::Tiger192;
+
+   $d = Crypt::Digest::Tiger192->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the Tiger192 digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::Tiger192 qw(tiger192 tiger192_hex tiger192_b64 tiger192_b64u
+                                      tiger192_file tiger192_file_hex tiger192_file_b64 tiger192_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::Tiger192 ':all';
+
+=head1 FUNCTIONS
+
+=head2 tiger192
+
+Logically joins all arguments into a single string, and returns its Tiger192 digest encoded as a binary string.
+
+ $tiger192_raw = tiger192('data string');
+ #or
+ $tiger192_raw = tiger192('any data', 'more data', 'even more data');
+
+=head2 tiger192_hex
+
+Logically joins all arguments into a single string, and returns its Tiger192 digest encoded as a hexadecimal string.
+
+ $tiger192_hex = tiger192_hex('data string');
+ #or
+ $tiger192_hex = tiger192_hex('any data', 'more data', 'even more data');
+
+=head2 tiger192_b64
+
+Logically joins all arguments into a single string, and returns its Tiger192 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $tiger192_b64 = tiger192_b64('data string');
+ #or
+ $tiger192_b64 = tiger192_b64('any data', 'more data', 'even more data');
+
+=head2 tiger192_b64u
+
+Logically joins all arguments into a single string, and returns its Tiger192 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $tiger192_b64url = tiger192_b64u('data string');
+ #or
+ $tiger192_b64url = tiger192_b64u('any data', 'more data', 'even more data');
+
+=head2 tiger192_file
+
+Reads file (defined by filename or filehandle) content, and returns its Tiger192 digest encoded as a binary string.
+
+ $tiger192_raw = tiger192_file('filename.dat');
+ #or
+ $tiger192_raw = tiger192_file(*FILEHANDLE);
+
+=head2 tiger192_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its Tiger192 digest encoded as a hexadecimal string.
+
+ $tiger192_hex = tiger192_file_hex('filename.dat');
+ #or
+ $tiger192_hex = tiger192_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 tiger192_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its Tiger192 digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $tiger192_b64 = tiger192_file_b64('filename.dat');
+ #or
+ $tiger192_b64 = tiger192_file_b64(*FILEHANDLE);
+
+=head2 tiger192_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its Tiger192 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $tiger192_b64url = tiger192_file_b64u('filename.dat');
+ #or
+ $tiger192_b64url = tiger192_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::Tiger192->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::Tiger192->hashsize();
+ #or
+ Crypt::Digest::Tiger192::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/Tiger_(cryptography)>
+
+=back
+
+=cut

database/perl/vendor/lib/Crypt/Digest/Whirlpool.pm

@@ -0,0 +1,223 @@
+package Crypt::Digest::Whirlpool;
+
+### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
+
+use strict;
+use warnings;
+our $VERSION = '0.069';
+
+use base qw(Crypt::Digest Exporter);
+our %EXPORT_TAGS = ( all => [qw( whirlpool whirlpool_hex whirlpool_b64 whirlpool_b64u whirlpool_file whirlpool_file_hex whirlpool_file_b64 whirlpool_file_b64u )] );
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+our @EXPORT = qw();
+
+use Carp;
+$Carp::Internal{(__PACKAGE__)}++;
+use Crypt::Digest;
+
+sub hashsize                { Crypt::Digest::hashsize('Whirlpool')             }
+sub whirlpool             { Crypt::Digest::digest_data('Whirlpool', @_)      }
+sub whirlpool_hex         { Crypt::Digest::digest_data_hex('Whirlpool', @_)  }
+sub whirlpool_b64         { Crypt::Digest::digest_data_b64('Whirlpool', @_)  }
+sub whirlpool_b64u        { Crypt::Digest::digest_data_b64u('Whirlpool', @_) }
+sub whirlpool_file        { Crypt::Digest::digest_file('Whirlpool', @_)      }
+sub whirlpool_file_hex    { Crypt::Digest::digest_file_hex('Whirlpool', @_)  }
+sub whirlpool_file_b64    { Crypt::Digest::digest_file_b64('Whirlpool', @_)  }
+sub whirlpool_file_b64u   { Crypt::Digest::digest_file_b64u('Whirlpool', @_) }
+
+1;
+
+=pod
+
+=head1 NAME
+
+Crypt::Digest::Whirlpool - Hash function Whirlpool [size: 512 bits]
+
+=head1 SYNOPSIS
+
+   ### Functional interface:
+   use Crypt::Digest::Whirlpool qw( whirlpool whirlpool_hex whirlpool_b64 whirlpool_b64u
+                                whirlpool_file whirlpool_file_hex whirlpool_file_b64 whirlpool_file_b64u );
+
+   # calculate digest from string/buffer
+   $whirlpool_raw  = whirlpool('data string');
+   $whirlpool_hex  = whirlpool_hex('data string');
+   $whirlpool_b64  = whirlpool_b64('data string');
+   $whirlpool_b64u = whirlpool_b64u('data string');
+   # calculate digest from file
+   $whirlpool_raw  = whirlpool_file('filename.dat');
+   $whirlpool_hex  = whirlpool_file_hex('filename.dat');
+   $whirlpool_b64  = whirlpool_file_b64('filename.dat');
+   $whirlpool_b64u = whirlpool_file_b64u('filename.dat');
+   # calculate digest from filehandle
+   $whirlpool_raw  = whirlpool_file(*FILEHANDLE);
+   $whirlpool_hex  = whirlpool_file_hex(*FILEHANDLE);
+   $whirlpool_b64  = whirlpool_file_b64(*FILEHANDLE);
+   $whirlpool_b64u = whirlpool_file_b64u(*FILEHANDLE);
+
+   ### OO interface:
+   use Crypt::Digest::Whirlpool;
+
+   $d = Crypt::Digest::Whirlpool->new;
+   $d->add('any data');
+   $d->addfile('filename.dat');
+   $d->addfile(*FILEHANDLE);
+   $result_raw  = $d->digest;     # raw bytes
+   $result_hex  = $d->hexdigest;  # hexadecimal form
+   $result_b64  = $d->b64digest;  # Base64 form
+   $result_b64u = $d->b64udigest; # Base64 URL Safe form
+
+=head1 DESCRIPTION
+
+Provides an interface to the Whirlpool digest algorithm.
+
+=head1 EXPORT
+
+Nothing is exported by default.
+
+You can export selected functions:
+
+  use Crypt::Digest::Whirlpool qw(whirlpool whirlpool_hex whirlpool_b64 whirlpool_b64u
+                                      whirlpool_file whirlpool_file_hex whirlpool_file_b64 whirlpool_file_b64u);
+
+Or all of them at once:
+
+  use Crypt::Digest::Whirlpool ':all';
+
+=head1 FUNCTIONS
+
+=head2 whirlpool
+
+Logically joins all arguments into a single string, and returns its Whirlpool digest encoded as a binary string.
+
+ $whirlpool_raw = whirlpool('data string');
+ #or
+ $whirlpool_raw = whirlpool('any data', 'more data', 'even more data');
+
+=head2 whirlpool_hex
+
+Logically joins all arguments into a single string, and returns its Whirlpool digest encoded as a hexadecimal string.
+
+ $whirlpool_hex = whirlpool_hex('data string');
+ #or
+ $whirlpool_hex = whirlpool_hex('any data', 'more data', 'even more data');
+
+=head2 whirlpool_b64
+
+Logically joins all arguments into a single string, and returns its Whirlpool digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $whirlpool_b64 = whirlpool_b64('data string');
+ #or
+ $whirlpool_b64 = whirlpool_b64('any data', 'more data', 'even more data');
+
+=head2 whirlpool_b64u
+
+Logically joins all arguments into a single string, and returns its Whirlpool digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $whirlpool_b64url = whirlpool_b64u('data string');
+ #or
+ $whirlpool_b64url = whirlpool_b64u('any data', 'more data', 'even more data');
+
+=head2 whirlpool_file
+
+Reads file (defined by filename or filehandle) content, and returns its Whirlpool digest encoded as a binary string.
+
+ $whirlpool_raw = whirlpool_file('filename.dat');
+ #or
+ $whirlpool_raw = whirlpool_file(*FILEHANDLE);
+
+=head2 whirlpool_file_hex
+
+Reads file (defined by filename or filehandle) content, and returns its Whirlpool digest encoded as a hexadecimal string.
+
+ $whirlpool_hex = whirlpool_file_hex('filename.dat');
+ #or
+ $whirlpool_hex = whirlpool_file_hex(*FILEHANDLE);
+
+B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
+
+=head2 whirlpool_file_b64
+
+Reads file (defined by filename or filehandle) content, and returns its Whirlpool digest encoded as a Base64 string, B<with> trailing '=' padding.
+
+ $whirlpool_b64 = whirlpool_file_b64('filename.dat');
+ #or
+ $whirlpool_b64 = whirlpool_file_b64(*FILEHANDLE);
+
+=head2 whirlpool_file_b64u
+
+Reads file (defined by filename or filehandle) content, and returns its Whirlpool digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
+
+ $whirlpool_b64url = whirlpool_file_b64u('filename.dat');
+ #or
+ $whirlpool_b64url = whirlpool_file_b64u(*FILEHANDLE);
+
+=head1 METHODS
+
+The OO interface provides the same set of functions as L<Crypt::Digest>.
+
+=head2 new
+
+ $d = Crypt::Digest::Whirlpool->new();
+
+=head2 clone
+
+ $d->clone();
+
+=head2 reset
+
+ $d->reset();
+
+=head2 add
+
+ $d->add('any data');
+ #or
+ $d->add('any data', 'more data', 'even more data');
+
+=head2 addfile
+
+ $d->addfile('filename.dat');
+ #or
+ $d->addfile(*FILEHANDLE);
+
+=head2 add_bits
+
+ $d->add_bits($bit_string);   # e.g. $d->add_bits("111100001010");
+ #or
+ $d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
+
+=head2 hashsize
+
+ $d->hashsize;
+ #or
+ Crypt::Digest::Whirlpool->hashsize();
+ #or
+ Crypt::Digest::Whirlpool::hashsize();
+
+=head2 digest
+
+ $result_raw = $d->digest();
+
+=head2 hexdigest
+
+ $result_hex = $d->hexdigest();
+
+=head2 b64digest
+
+ $result_b64 = $d->b64digest();
+
+=head2 b64udigest
+
+ $result_b64url = $d->b64udigest();
+
+=head1 SEE ALSO
+
+=over
+
+=item * L<CryptX|CryptX>, L<Crypt::Digest>
+
+=item * L<https://en.wikipedia.org/wiki/Whirlpool_(cryptography)>
+
+=back
+
+=cut