File Coverage

blib/lib/VOMS/Lite/RSAHelper.pm

Criterion	Covered	Total	%
statement	75	81	92.5
branch	4	8	50.0
condition	2	6	33.3
subroutine	8	9	88.8
pod	0	5	0.0
total	89	109	81.6

package VOMS::Lite::RSAHelper;

use 5.004;
use strict;
use Math::BigInt lib => 'GMP';

require Exporter;
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
@ISA = qw(Exporter);
%EXPORT_TAGS = ( );
@EXPORT_OK = qw( rsasign rsaencrypt rsaverify rsadecrypt );
@EXPORT = ( );
$VERSION = '0.20';

###############################################

sub rsasign { # use private key to encrypt
  return &rsaenc( "01", @_);
}

###############################################

sub rsaencrypt { # use public key to encrypt
  return &rsaenc( "02", @_);
}

###############################################

sub rsaverify {
  return rsadecrypt( @_ );
}

###############################################

sub rsadecrypt {
  my ($EDhex,$chex,$nhex)=@_;

# Even up hex lengths into whole octets
  $chex=~s/^.(..)*$/0$&/;
  $nhex=~s/^.(..)*$/0$&/;
  $EDhex=~s/^.(..)*$/0$&/;
  my $khex=length($nhex);

# Length of modulus and Data in octets
  my $k=$khex/2;
  my $EDlen=length($EDhex)/2;

# Create Integer representing Data
  my $x=Math::BigInt->bzero();
  foreach (split(//,$EDhex)) {
    $x->bmul(16);
    $x->badd(hex($_));
  }

# Create Integer representing Modulus
  my $n=Math::BigInt->bzero();
  foreach (split(//,$nhex)) {
    $n->bmul(16);
    $n->badd(hex($_));
  }

# Create Integer representing Exponent
  my $c=Math::BigInt->bzero();
  foreach (split(//,$chex)) {
    $c->bmul(16);
    $c->badd(hex($_));
  }

# Do Big RSA Maths y = x^c mod n
  my $y=Math::BigInt->bzero();
  $y = $x->bmodpow($c,$n);

# Get Encrypted Data Character String
  my $Dhex=$y->as_hex();
  $Dhex=~s/^0x//;
  $Dhex=~s/^.(..)*$/0$&/; # Even up the length

  if ( length($Dhex) < ($khex-4) ) { # short string: BT must be 00 (NB RFC difference should be ($khex-2) )
    return $Dhex;
  }
  else { # long string: BT is any one of 00, 01 and 02
    my $BT=substr($Dhex,0,2);
    $Dhex=substr($Dhex,2);
    if ( $BT eq "00" ) {
      until ( substr($Dhex,0,2) ne '00' || $Dhex eq "" ) { $Dhex=substr($Dhex,2); }
    }
    else { # BT = 01 or 02
      until ( substr($Dhex,0,2) eq '00' || $Dhex eq "" ) { $Dhex=substr($Dhex,2); }
      $Dhex=substr($Dhex,2);
    }
  }
  return $Dhex;
}

###############################################

sub rsaenc { #RSA Algorythm as per RFC2313  (with tweak for openssl verification stuff)

# Get block type, Data, HexKey, HexModulus
  my ($BT,$Dhex,$chex,$nhex)=@_;

# Even up hex lengths into whole octets
  $chex=~s/^.(..)*$/0$&/;
  $nhex=~s/^.(..)*$/0$&/;
  $Dhex=~s/^.(..)*$/0$&/;
  my $khex=length($nhex);

# Length of modulus and Data in octets
  my $k=$khex/2;
  my $Dlen=length($Dhex)/2;

# Barf if datalen is too long for RSA
  ( $Dlen > ($k - 11) ) && die "Too much data to encrypt!";

# Padding for signing (why - 4 and not - 3 as per RFC I don't know)
  my $PS="ff" x ( $k - 4 - $Dlen);

# If encrypting alter padding to random
  if ( $BT eq "02" ) { $PS=~s/../unpack('H2',pack('i',int(rand(255)+1)))/ge; }

# Make Encryption Block. EB = 00 || BT || PS || 00 || D
  my $EB='00'.$BT.$PS.'00'.$Dhex;

# Create Integer representing Data
  my $x=Math::BigInt->bzero();
  foreach (split(//,$EB)) {
    $x->bmul(16);
    $x->badd(hex($_));
  }

# Create Integer representing Modulus
  my $n=Math::BigInt->bzero();
  foreach (split(//,$nhex)) {
    $n->bmul(16);
    $n->badd(hex($_));
  }

# Create Integer representing Exponent
  my $c=Math::BigInt->bzero();
  foreach (split(//,$chex)) {
    $c->bmul(16);
    $c->badd(hex($_));
  }

# Do Big RSA Maths y = x^c mod n
  my $y=Math::BigInt->bzero();
  $y = $x->bmodpow($c,$n);

# Get Encrypted Data Character String
  my $ED=$y->as_hex();
  $ED=~s/^0x//;
  $ED=~s/^.(..)*$/0$&/;

# Send Hex Data back
  return $ED;
}

1;
__END__