File Coverage

blib/lib/Crypt/DH.pm

Criterion	Covered	Total	%
statement	53	57	92.9
branch	17	30	56.6
condition	3	8	37.5
subroutine	12	12	100.0
pod	2	3	66.6
total	87	110	79.0

package Crypt::DH;
use strict;

use Math::BigInt lib => "GMP,Pari";
our $VERSION = '0.07';

sub new {
    my $class = shift;
    my $dh = bless {}, $class;

    my %param = @_;
    for my $w (qw( p g priv_key )) {
        next unless exists $param{$w};
        $dh->$w(delete $param{$w});
    }
    die "Unknown parameters to constructor: " . join(", ", keys %param) if %param;

    $dh;
}

BEGIN {
    no strict 'refs';
    for my $meth (qw( p g pub_key priv_key )) {
        *$meth = sub {
            my $key = shift;
            if (@_) {
                $key->{$meth} = _any2bigint(shift);
            }
            my $ret = $key->{$meth} || "";
            $ret;
        };
    }
}

sub _any2bigint {
    my($value) = @_;
    if (ref $value eq 'Math::BigInt') {
        return $value;
    }
    elsif (ref $value eq 'Math::Pari') {
        return Math::BigInt->new(Math::Pari::pari2pv($value));
    }
    elsif (defined $value && !(ref $value)) {
        return Math::BigInt->new($value);
    }
    elsif (defined $value) {
        die "Unknown parameter type: $value\n";
    }
}

sub generate_keys {
    my $dh = shift;

    unless (defined $dh->{priv_key}) {
        my $i = _bitsize($dh->{p}) - 1;
        $dh->{priv_key} =
            $Crypt::Random::VERSION ?
            Crypt::Random::makerandom_itv(Strength => 0, Uniform => 1,
                                          Lower => 1, Upper => $dh->{p} - 1) :
            _makerandom_itv($i, 1, $dh->{p} - 1);
    }

    $dh->{pub_key} = $dh->{g}->copy->bmodpow($dh->{priv_key}, $dh->{p});
}

sub compute_key {
    my $dh = shift;
    my $pub_key = _any2bigint(shift);
    $pub_key->copy->bmodpow($dh->{priv_key}, $dh->{p});
}
*compute_secret = \&compute_key;

sub _bitsize {
    return length($_[0]->as_bin) - 2;
}

sub _makerandom_itv {
    my ($size, $min_inc, $max_exc) = @_;

    while (1) {
        my $r = _makerandom($size);
        return $r if $r >= $min_inc && $r < $max_exc;
    }
}

sub _makerandom {
    my $size = shift;

    my $bytes = int($size / 8) + ($size % 8 ? 1 : 0);

    my $rand;
    if (-e "/dev/urandom") {
        my $fh;
        open($fh, '/dev/urandom')
            or die "Couldn't open /dev/urandom";
        my $got = sysread $fh, $rand, $bytes;
        die "Didn't read all bytes from urandom" unless $got == $bytes;
        close $fh;
    } else {
        for (1..$bytes) {
            $rand .= chr(int(rand(256)));
        }
    }

    my $bits = unpack("b*", $rand);
    die unless length($bits) >= $size;

    Math::BigInt->new('0b' . substr($bits, 0, $size));
}

1;
__END__