File Coverage

blib/lib/Crypt/RSA/Blind.pm

Criterion	Covered	Total	%
statement	7	9	77.7
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	10	12	83.3

# -*-cperl-*-
#
# Crypt::RSA::Blind - Blind RSA signatures
# Copyright (c) 2016-2017 Ashish Gulhati
#
# $Id: lib/Crypt/RSA/Blind.pm v1.009 Sat Jun 10 00:16:58 PDT 2017 $

package Crypt::RSA::Blind;

use warnings;
use strict;
use Crypt::FDH;
use Crypt::RSA;
use Crypt::RSA::Primitives;
use Crypt::Random qw(makerandom_itv makerandom);
use Math::Pari qw (Mod component);
use vars qw( $VERSION $AUTOLOAD );

our ( $VERSION ) = '$Revision: 1.009 $' =~ /\s+([\d\.]+)/;

sub new {
  bless { HASHSIZE  => 768,
	  INITSIZE  => 128,
	  BLINDSIZE => 512,
	  _RSA      => new Crypt::RSA,
	  _RSAP     => new Crypt::RSA::Primitives}, shift;
}

sub keygen {
  my $self = shift;
  $self->_rsa->keygen(@_);
}

sub init {
  my $self = shift;
  makerandom( Size => $self->initsize, Strength => 0 );
}

sub request {
  my $self = shift;
  my %arg = @_;
  my ($invertible, $blinding);
  while (!$invertible) {
    $blinding = makerandom_itv( Size => $self->blindsize, Upper => $arg{Key}->n-1, Strength => 0 );
    # Check that blinding is invertible mod n
    $invertible = Math::Pari::gcd($blinding, $arg{Key}->n);
    $invertible = 0 unless $invertible == 1;
  }
  $self->_request($arg{Init} => $blinding);

  my $be = $self->_rsap->core_encrypt(Key => $arg{Key}, Plaintext => $blinding);
  my $fdh = Math::Pari::_hex_cvt ('0x'.Crypt::FDH::hash(Size => $self->hashsize, Message => $arg{Message}));
  component((Mod($fdh,$arg{Key}->n)) * (Mod($be,$arg{Key}->n)), 2);
}

sub sign {
  my $self = shift;
  $self->_rsap->core_sign(@_);
}

sub unblind {
  my $self = shift;
  my %arg = @_;
  my $blinding = $self->_request($arg{Init});
  component((Mod($arg{Signature},$arg{Key}->n)) / (Mod($blinding,$arg{Key}->n)), 2);
}

sub verify {
  my $self = shift;
  my %arg = @_;
  my $pt = $self->_rsap->core_verify(Key => $arg{Key}, Signature => $arg{Signature});
  $pt == Math::Pari::_hex_cvt ('0x'.Crypt::FDH::hash(Size => $self->hashsize, Message => $arg{Message}));
}

sub errstr {
  my $self = shift;
  $self->_rsa->errstr(@_);
}

sub _request {
  my $self = shift;
  my $init = $_[0]; my $ret;
  if ($_[1]) {
    $self->{Requests}->{$init} = $_[1];
  }
  else {
    $ret = $self->{Requests}->{$init};
    delete $self->{Requests}->{$init};
  }
  return $ret;
}

sub AUTOLOAD {
  my $self = shift; (my $auto = $AUTOLOAD) =~ s/.*:://;
  return if $auto eq 'DESTROY';
  if ($auto =~ /^(_rsa|_rsap|hashsize|blindsize|initsize)$/x) {
    $self->{"\U$auto"} = shift if (defined $_[0]);
    return $self->{"\U$auto"};
  }
  else {
    die "Could not AUTOLOAD method $auto.";
  }
}

1; # End of Crypt::RSA::Blind

package Crypt::RSA::Blind::PubKey;

use Compress::Zlib;

sub from_hex {
  Crypt::RSA::Key::Public->new->deserialize(String => [ uncompress(pack('H*',shift)) ]);
}

1; # End of Crypt::RSA::Blind::PubKey

package Crypt::RSA::Blind::SecKey;

use Compress::Zlib;

sub from_hex {
  Crypt::RSA::Key::Private->new->deserialize(String => [ uncompress(pack('H*',shift)) ]);
}

1; # End of Crypt::RSA::Blind::SecKey

__END__