diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/Crypt/OpenPGP/Key.pm')
| -rwxr-xr-x | Master/tlpkg/tlperl/lib/Crypt/OpenPGP/Key.pm | 236 |
1 files changed, 236 insertions, 0 deletions
diff --git a/Master/tlpkg/tlperl/lib/Crypt/OpenPGP/Key.pm b/Master/tlpkg/tlperl/lib/Crypt/OpenPGP/Key.pm new file mode 100755 index 00000000000..0fd5edc4a65 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/Crypt/OpenPGP/Key.pm @@ -0,0 +1,236 @@ +package Crypt::OpenPGP::Key; +use strict; + +use Carp qw( confess ); +use Crypt::OpenPGP::ErrorHandler; +use base qw( Crypt::OpenPGP::ErrorHandler ); + +use vars qw( %ALG %ALG_BY_NAME ); +%ALG = ( + 1 => 'RSA', + 16 => 'ElGamal', + 17 => 'DSA', +); +%ALG_BY_NAME = map { $ALG{$_} => $_ } keys %ALG; + +sub new { + my $class = shift; + my $alg = shift; + $alg = $ALG{$alg} || $alg; + my $pkg = join '::', $class, $alg; + eval "use $pkg;"; + return $class->error("Unsupported algorithm '$alg': $@") if $@; + my @valid = $pkg->all_props; + my %valid = map { $_ => 1 } @valid; + my $key = bless { __valid => \%valid, __alg => $alg, + __alg_id => $ALG_BY_NAME{$alg} }, $pkg; + $key->init(@_); +} + +sub keygen { + my $class = shift; + my $alg = shift; + $alg = $ALG{$alg} || $alg; + my $pkg = join '::', __PACKAGE__, 'Public', $alg; + eval "use $pkg;"; + return $class->error("Unsupported algorithm '$alg': $@") if $@; + my($pub_data, $sec_data) = $pkg->keygen(@_); + return $class->error("Key generation failed: " . $class->errstr) + unless $pub_data && $sec_data; + my $pub_pkg = join '::', __PACKAGE__, 'Public'; + my $pub = $pub_pkg->new($alg, $pub_data); + my $sec_pkg = join '::', __PACKAGE__, 'Secret'; + my $sec = $sec_pkg->new($alg, $sec_data); + ($pub, $sec); +} + +sub init { $_[0] } + +sub check { 1 } + +sub alg { $_[0]->{__alg} } +sub alg_id { $_[0]->{__alg_id} } + +sub size { 0 } +sub bytesize { int(($_[0]->size + 7) / 8) } + +sub public_key { } +sub is_secret { 0 } + +sub can_encrypt { 0 } +sub can_sign { 0 } + +sub DESTROY { } + +use vars qw( $AUTOLOAD ); +sub AUTOLOAD { + my $key = shift; + (my $meth = $AUTOLOAD) =~ s/.*:://; + confess "Can't call method $meth on Key $key" + unless $key->{__valid}{$meth}; + $key->{key_data}->$meth(@_); +} + +1; +__END__ + +=head1 NAME + +Crypt::OpenPGP::Key - OpenPGP key factory + +=head1 SYNOPSIS + + use Crypt::OpenPGP::Key; + my($pub, $sec) = Crypt::OpenPGP::Key->keygen('DSA', Size => 1024); + + use Crypt::OpenPGP::Key::Public; + my $pubkey = Crypt::OpenPGP::Key::Public->new('DSA'); + + use Crypt::OpenPGP::Key::Secret; + my $seckey = Crypt::OpenPGP::Key::Secret->new('RSA'); + +=head1 DESCRIPTION + +I<Crypt::OpenPGP::Key> provides base class functionality for all +I<Crypt::OpenPGP> public and secret keys. It functions as a factory +class for key generation and key instantiation. + +The only time you will ever use I<Crypt::OpenPGP::Key> directly is +to generate a key-pair; in all other scenarios--for example, when +instantiating a new key object--you should use either +I<Crypt::OpenPGP::Key::Public> or I<Crypt::OpenPGP::Key::Secret>, +depending on whether the key is public or secret, respectively. + +=head1 KEY GENERATION + +=head2 Crypt::OpenPGP::Key->keygen( $type, %arg ) + +Generates a new key-pair of public key algorithm I<$type>. Returns +a public and a secret key, each blessed into the appropriate +implementation class. Returns an empty list on failure, in which case +you should call the class method I<errstr> to determine the error. + +Valid values for type are C<DSA>, C<RSA>, and C<ElGamal>. + +I<%arg> can contain: + +=over 4 + +=item * Size + +Bitsize of the key to be generated. This should be an even integer; +there is no low end currently set, but for the sake of security +I<Size> should be at least 1024 bits. + +This is a required argument. + +=item * Verbosity + +Set to a true value to enable a status display during key generation; +since key generation is a relatively length process, it is helpful +to have an indication that some action is occurring. + +I<Verbosity> is 0 by default. + +=back + +=head1 METHODS + +I<Crypt::OpenPGP::Key> is not meant to be used directly (unless you +are generating keys; see I<KEY GENERATION>, above); instead you should +use the subclasses of this module. There are, however, useful interface +methods that are shared by all subclasses. + +=head2 Key Data Access + +Each public-key algorithm has different key data associated with it. +For example, a public DSA key has 4 attributes: I<p>, I<q>, I<g>, and +I<y>. A secret DSA key has the same attributes as a public key, and +in addition it has an attribute I<x>. + +All of the key data attributes can be accessed by calling methods of +the same name on the I<Key> object. For example: + + my $q = $dsa_key->q; + +The attributes for each public-key algorithm are: + +=over 4 + +=item * RSA + +Public key: I<n>, I<e> + +Secret key: I<n>, I<e>, I<d>, I<p>, I<q>, I<u> + +=item * DSA + +Public key: I<p>, I<q>, I<g>, I<y> + +Secret key: I<p>, I<q>, I<g>, I<y>, I<x> + +=item * ElGamal + +Public key: I<p>, I<g>, I<y> + +Secret key: I<p>, I<g>, I<y>, I<x> + +=back + +=head2 $key->check + +Check the key data to determine if it is valid. For example, an RSA +secret key would multiply the values of I<p> and I<q> and verify that +the product is equal to the value of I<n>. Returns true if the key +is valid, false otherwise. + +Not all public key algorithm implementations implement a I<check> +method; for those that don't, I<check> will always return true. + +=head2 $key->size + +Returns the "size" of the key. The definition of "size" depends on +the public key algorithm; for example, DSA defines the size of a key +as the bitsize of the value of I<p>. + +=head2 $key->bytesize + +Whereas I<size> will return a bitsize of the key, I<bytesize> returns +the size in bytes. This value is defined as C<int((bitsize(key)+7)/8)>. + +=head2 $key->is_secret + +Returns true if the key I<$key> is a secret key, false otherwise. + +=head2 $key->public_key + +Returns the public part of the key I<$key>. If I<$key> is already a +public key, I<$key> is returned; otherwise a new public key object +(I<Crypt::OpenPGP::Key::Public>) is constructed, and the public values +from the secret key are copied into the public key. The new public +key is returned. + +=head2 $key->can_encrypt + +Returns true if the key algorithm has encryption/decryption +capabilities, false otherwise. + +=head2 $key->can_sign + +Returns true if the key algorithm has signing/verification +capabilities, false otherwise. + +=head2 $key->alg + +Returns the name of the public key algorithm. + +=head2 $key->alg_id + +Returns the number ID of the public key algorithm. + +=head1 AUTHOR & COPYRIGHTS + +Please see the Crypt::OpenPGP manpage for author, copyright, and +license information. + +=cut |