File Coverage

blib/lib/Crypt/DSA/GMP/Util.pm

Criterion	Covered	Total	%
statement	70	70	100.0
branch	16	24	66.6
condition	6	12	50.0
subroutine	16	16	100.0
pod	8	8	100.0
total	116	130	89.2

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

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

use Carp qw( croak );
use Math::BigInt lib => "GMP";
use Crypt::Random::Seed;

use base qw( Exporter );
our @EXPORT_OK = qw( bitsize bin2mp mp2bin mod_inverse mod_exp randombytes makerandom makerandomrange );
our %EXPORT_TAGS = (all => [ @EXPORT_OK ]);

sub bitsize {
  my $n = shift;
  $n = Math::BigInt->new("$n") unless ref($n) eq 'Math::BigInt';
  length($n->as_bin) - 2;
}

# This is the os2ip function
sub bin2mp {
    my $s = shift;
    return Math::BigInt->new(0) if !defined $s || $s eq '';
    return Math::BigInt->from_hex('0x' . unpack("H*", $s));
}

# This is the i2osp function
sub mp2bin {
    my $p = shift;
    my $res = '';
    if (ref($p) ne 'Math::BigInt' && $p <= ~0) {
      do {
        $res = chr($p & 0xFF) . $res;
        $p >>= 8;
      } while $p;
    } else {
      $p = Math::BigInt->new("$p") unless ref($p) eq 'Math::BigInt';
      my $hex = $p->as_hex;
      $hex =~ s/^0x0*//;
      substr($hex, 0, 0, '0') if length($hex) % 2;
      $res = pack("H*", $hex);
    }
    $res;
}

sub mod_exp {
    my($a, $exp, $n) = @_;
    $a->copy->bmodpow($exp, $n);
}

sub mod_inverse {
    my($a, $n) = @_;
    $a->copy->bmodinv($n);
}

{
  my ($crs, $crs_best);
  sub _setup_rng {
    $crs_best = Crypt::Random::Seed->new();
    $crs = ($crs_best->is_blocking())
           ? Crypt::Random::Seed->new(NonBlocking=>1)
           : $crs_best;
  }
  sub randombytes {
    my($bytes, $keygen) = @_;
    _setup_rng() unless defined $crs;
    my $src = ($keygen) ? $crs_best : $crs;
    return $src->random_bytes($bytes);
  }
}

# Generate uniform random number in range [2^(bits-1),2^bits-1]
sub makerandom {
  my %param = @_;
  my ($bits, $is_keygen) = ( $param{Size}, $param{KeyGen} );
  croak "makerandom must have Size >= 1" unless defined $bits && $bits > 0;
  return Math::BigInt->bone if $bits == 1;

  my $randbits = $bits - 1;
  my $randbytes = int(($randbits+7)/8);
  my $randbinary = unpack("B*", randombytes( $randbytes, $is_keygen ));
  return Math::BigInt->from_bin( '0b1' . substr($randbinary,0,$randbits) );
}

# Generate uniform random number in range [0, $max]
sub makerandomrange {
  my %param = @_;
  my ($max, $is_keygen) = ( $param{Max}, $param{KeyGen} );
  croak "makerandomrange must have a Max > 0" unless defined $max && $max > 0;
  $max = Math::BigInt->new("$max") unless ref($max) eq 'Math::BigInt';
  my $range = $max->copy->binc;
  my $bits = length($range->as_bin) - 2;
  my $bytes = 1 + int(($bits+7)/8);
  my $rmax = Math::BigInt->bone->blsft(8*$bytes)->bdec();
  my $overflow = $rmax - ($rmax % $range);
  my $U;
  do {
    $U = Math::BigInt->from_hex( '0x' . unpack("H*", randombytes($bytes,$is_keygen)) );
  } while $U >= $overflow;
  $U->bmod($range);  # U is randomly in [0, k*$range-1] for some k.
  return $U;
}

1;
__END__