File Coverage

blib/lib/Crypt/DSA/GMP.pm

Criterion	Covered	Total	%
statement	21	23	91.3
branch			n/a
condition			n/a
subroutine	8	8	100.0
pod			n/a
total	29	31	93.5

package Crypt::DSA::GMP;
use 5.006;
use strict;
use warnings;

BEGIN {
  $Crypt::DSA::GMP::AUTHORITY = 'cpan:DANAJ';
  $Crypt::DSA::GMP::VERSION = '0.02';
}

use Carp qw( croak );
use Math::BigInt lib => "GMP";
use Digest::SHA qw( sha1 sha256 sha512 );
use Crypt::DSA::GMP::KeyChain;
use Crypt::DSA::GMP::Key;
use Crypt::DSA::GMP::Signature;
use Crypt::DSA::GMP::Util qw( bitsize bin2mp mod_inverse mod_exp makerandomrange );

sub new {
    my $class = shift;
    my $dsa = bless { @_ }, $class;
    $dsa->{_keychain} = Crypt::DSA::GMP::KeyChain->new(@_);
    $dsa;
}

sub keygen {
    my ($dsa, %params) = @_;
    my $key = $dsa->{_keychain}->generate_params(%params);
    my $nonblock = $params{NonBlockingKeyGeneration};
    $dsa->{_keychain}->generate_keys($key, $nonblock);
    croak "Invalid key" unless $key->validate();
    $key;
}
sub keyset {
  my ($dsa, %param) = @_;
  my $key = Crypt::DSA::GMP::Key->new;
  croak "Key missing p" unless defined $param{p};  $key->p($param{p});
  croak "Key missing q" unless defined $param{q};  $key->q($param{q});
  croak "Key missing g" unless defined $param{g};  $key->g($param{g});
  $key->priv_key($param{priv_key}) if defined $param{priv_key};
  $key->priv_key($param{x}       ) if defined $param{x};
  $key->pub_key($param{pub_key}) if defined $param{pub_key};
  $key->pub_key($param{y}      ) if defined $param{y};
  $key->pub_key(mod_exp($key->g, $key->priv_key, $key->p))
    if !defined $key->pub_key && defined $key->priv_key;
  croak "Key missing both private and public keys"
    unless defined $key->pub_key || defined $key->priv_key;
  croak "Invalid key" unless $key->validate();
  $key;
}

sub sign {
    my ($dsa, %param) = @_;
    my ($key, $dgst) = ($param{Key}, $param{Digest});

    croak __PACKAGE__, "->sign: Need a Key" unless defined $key && ref($key);
    croak __PACKAGE__, "->sign: Invalid key" unless $key->validate();
    my ($p, $q, $g) = ($key->p, $key->q, $key->g);
    my $N = bitsize($q);

    if (!defined $dgst) {
        my $message = $param{Message};
        croak __PACKAGE__, "->sign: Need either Message or Digest"
            unless defined $message;
        # Determine which standard we're following.
        $param{Standard} = $dsa->{Standard}
          if defined $dsa->{Standard} && !defined $param{Standard};
        if (defined $param{Standard} && $param{Standard} =~ /186-[34]/) {
          # See NIST SP 800-57 revision 3, section 5.6.1
          $dgst = ($N > 256) ? sha512($message) : sha256($message);
        } else {
          $dgst = sha1($message);
        }
    }

    # FIPS 186-4, section 4.6 "DSA Signature Generation"

    # compute z as the leftmost MIN(N, outlen) bits of the digest
    my $z = bin2mp($dgst);
    $z->brsft(8*length($dgst) - $N) if $N < 8*length($dgst);

    # Generate r and s, ensuring neither are zero.
    my ($r, $s);
    do {
      my ($k, $kinv);
      do {
        # Using FIPS 186-4 B.2.2 approved method
        # k is per-message random number 0 < k < q
        $k = makerandomrange( Max => $q-2 ) + 1;
        $r = mod_exp($g, $k, $p)->bmod($q);
      } while $r == 0;
      $kinv = mod_inverse($k, $q);
      $s = ($kinv * ($z + $key->priv_key * $r)) % $q;
    } while $s == 0;
    croak "Internal error in signing" if $r == 0 || $s == 0;

    my $sig = Crypt::DSA::GMP::Signature->new;
    $sig->r($r);
    $sig->s($s);
    $sig;
}

sub verify {
    my ($dsa, %param) = @_;
    my ($key, $dgst, $sig) = ($param{Key}, $param{Digest}, $param{Signature});

    croak __PACKAGE__, "->verify: Need a Key"
        unless defined $key && ref($key);
    croak __PACKAGE__, "->verify: Need a Signature"
        unless defined $sig && ref($sig);
    croak __PACKAGE__, "->verify: Invalid key" unless $key->validate();
    my ($p, $q, $g, $r, $s) = ($key->p, $key->q, $key->g, $sig->r, $sig->s);
    return 0 unless $r > 0 && $r < $q  &&  $s > 0 && $s < $q;
    my $N = bitsize($q);

    if (!defined $dgst) {
        my $message = $param{Message};
        croak __PACKAGE__, "->verify: Need either Message or Digest"
            unless defined $message;
        # Determine which standard we're following.
        $param{Standard} = $dsa->{Standard}
          if defined $dsa->{Standard} && !defined $param{Standard};
        if (defined $param{Standard} && $param{Standard} =~ /186-[34]/) {
          # See NIST SP 800-57 revision 3, section 5.6.1
          $dgst = ($N > 256) ? sha512($message) : sha256($message);
        } else {
          $dgst = sha1($message);
        }
    }

    my $w = mod_inverse($s, $q);
    my $z = bin2mp($dgst);
    $z->brsft(8*length($dgst) - $N) if $N < 8*length($dgst);
    my $u1 = $w->copy->bmul($z)->bmod($q);
    my $u2 = $w->copy->bmul($r)->bmod($q);
    my $v =        mod_exp($g,            $u1, $p)
            ->bmul(mod_exp($key->pub_key, $u2, $p))
            ->bmod($p)
            ->bmod($q);
    $v == $r;
}

1;

__END__