view release on metacpan or  search on metacpan

lib/Crypt/RSA/Key/Private.pm  view on Meta::CPAN

    return $self->error ("Incomplete key.") unless
        ($self->n && $self->d) || ($self->n && $self->p && $self->q);

    if ($self->p && $self->q) {
        return $self->error ("n is not a number.") if $self->n =~ /\D/;
        return $self->error ("p is not a number.") if $self->p =~ /\D/;
        return $self->error ("q is not a number.") if $self->q =~ /\D/;
        return $self->error ("n is not p*q."  ) unless $self->n == $self->p * $self->q;
        return $self->error ("p is not prime.") unless is_prime( $self->p );
        return $self->error ("q is not prime.") unless is_prime( $self->q );
    }

    if ($self->e) {
        # d * e == 1 mod lcm(p-1, q-1)
        return $self->error ("e is not a number.") if $self->e =~ /\D/;
        my $k = Math::BigInt::blcm($self->p-1, $self->q-1);
        my $KI = ($self->e)->copy->bmul($self->d)->bmodinv($k);
        return $self->error ("Bad `d'.") unless $KI == 1;
    }

    if ($self->dp) {
        # dp == d mod (p-1)
        return $self->error ("Bad `dp'.") unless $self->dp == $self->d % ($self->p - 1);
    }

    if ($self->dq) {
        # dq == d mod (q-1)
        return $self->error ("Bad `dq'.") unless $self->dq == $self->d % ($self->q - 1);
    }

    if ($self->u && $self->q && $self->p) {
        my $m = ($self->p)->copy->bmodinv($self->q);
        return $self->error ("Bad `u'.") unless $self->u == $m;
    }

    $self->Checked(1);
    return 1;

}


sub DESTROY {

    my $self = shift;
    delete $$self{private_encrypted}{__password};
    delete $$self{private_encrypted};
    delete $$self{private};
    delete $$self{Password};
    undef $self;

}


sub write {

    my ($self, %params) = @_;
    $self->hide();
    my $string = $self->serialize (%params);
    open(my $disk, '>', $params{Filename}) or
        croak "Can't open $params{Filename} for writing.";
    binmode $disk;
    print $disk $string;
    close $disk;

}


sub read {
    my ($self, %params) = @_;
    open(my $disk, '<', $params{Filename}) or
        croak "Can't open $params{Filename} to read.";
    binmode $disk;
    my @key = <$disk>;
    close $disk;
    $self = $self->deserialize (String => \@key);
    $self->reveal(%params);
    return $self;
}


sub serialize {

    my ($self, %params) = @_;
    if ($$self{private}) {   # this is an unencrypted key
        for (keys %{$$self{private}}) {
            $$self{private}{$_} = ($$self{private}{$_})->bstr;
        }
    }
    return Dumper $self;

}


sub deserialize {

    my ($self, %params) = @_;
    my $string = join'', @{$params{String}};
    $string =~ s/\$VAR1 =//;
    $self = eval $string;
    if ($$self{private}) { # the key is unencrypted
        for (keys %{$$self{private}}) {
            $$self{private}{$_} = Math::BigInt->new("$$self{private}{$_}");
        }
        return $self;
    }
    my $private = new Tie::EncryptedHash;
    %$private = %{$$self{private_encrypted}};
    $self->{private_encrypted} = $private;
    return $self;

}


1;

=head1 NAME

Crypt::RSA::Key::Private -- RSA Private Key Management.

=head1 SYNOPSIS

    $key = new Crypt::RSA::Key::Private (
                Identity => 'Lord Banquo <banquo@lochaber.com>',
                Password => 'The earth hath bubbles',
           );

    $key->hide();

    $key->write( Filename => 'rsakeys/banquo.private'  );

    $akey = new Crypt::RSA::Key::Private (
                 Filename => 'rsakeys/banquo.private'