File Coverage

blib/lib/Crypt/EECDH.pm

Criterion	Covered	Total	%
statement	84	87	96.5
branch	19	28	67.8
condition	3	7	42.8
subroutine	15	16	93.7
pod	5	5	100.0
total	126	143	88.1

# -*-cperl-*-
#
# Crypt::EECDH - Simple ephemeral ECDH + AES hybrid cryptosystem
# Copyright (c) 2017 Ashish Gulhati
#
# $Id: lib/Crypt/EECDH.pm v1.005 Sat Jun 10 10:46:49 PDT 2017 $

package Crypt::EECDH;

use warnings;
use strict;

use Crypt::Curve25519;
use Crypt::Ed25519;
use Crypt::EC_DSA;
use Bytes::Random::Secure;
use Crypt::Rijndael;
use Digest::SHA qw/sha256 hmac_sha256/;
use vars qw( $VERSION $AUTOLOAD );

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

sub new {
  my ($class, %arg) = @_;
  bless { debug     => $arg{Debug} || 0,
	  sigscheme => $arg{SigScheme} || 'ECDSA'
	}, $class;
}

my $format = 'C/a C/a n/a N/a';

sub encrypt {
  my ($self, %arg) = @_;

  if (defined $arg{SigningKey} && defined $arg{Signature}) {
    # Check signature on $public_key
    if ($self->sigscheme eq 'Ed25519') {
      return unless Crypt::Ed25519::verify($arg{PublicKey}, $arg{SigningKey}, $arg{Signature});
    }
    else {
      my $ecdsa = new Crypt::EC_DSA;
      return unless $ecdsa->verify( Message => $arg{PublicKey}, Signature => $arg{Signature},
				    Key => $arg{SigningKey} );
    }
  }

  my $random = Bytes::Random::Secure->new( Bits => 128 );
  my $private = curve25519_secret_key($random->bytes(32));
  my $public  = curve25519_public_key($private);
  my $shared  = curve25519_shared_secret($private, $arg{PublicKey});

  my ($encrypt_key, $sign_key) = unpack 'a16 a16', sha256($shared);
  my $iv     = substr sha256($public), 0, 16;
  my $cipher = Crypt::Rijndael->new($encrypt_key, Crypt::Rijndael::MODE_CBC);
  $cipher->set_iv($iv);

  my $pad_length = 16 - length($arg{Message}) % 16;
  my $padding = chr($pad_length) x $pad_length;

  my $ciphertext = $cipher->encrypt($arg{Message} . $padding);
  my $mac = hmac_sha256($iv . $ciphertext, $sign_key);
  return (pack ($format, '', $public, $mac, $ciphertext), $private);
}

sub decrypt {
  my ($self, %arg) = @_;

  my ($options, $public, $mac, $ciphertext) = unpack $format, $arg{Ciphertext};
  die 'Unknown options' if $options ne '';

  my $shared = curve25519_shared_secret($arg{Key}, $public);
  my ($encrypt_key, $sign_key) = unpack 'a16 a16', sha256($shared);
  my $iv     = substr sha256($public), 0, 16;
  die 'MAC is incorrect' if hmac_sha256($iv . $ciphertext, $sign_key) ne $mac;
  my $cipher = Crypt::Rijndael->new($encrypt_key, Crypt::Rijndael::MODE_CBC);
  $cipher->set_iv($iv);

  my $plaintext = $cipher->decrypt($ciphertext);
  my $pad_length = ord substr $plaintext, -1;
  substr($plaintext, -$pad_length, $pad_length, '') eq chr($pad_length) x $pad_length or die 'Incorrectly padded';
  return ($plaintext, $public);
}

sub keygen {
  my ($self, %arg) = @_;
  my $random = Bytes::Random::Secure->new( Bits => 128 );
  my $secret = curve25519_secret_key($random->bytes(32));
  my $public = curve25519_public_key($secret);
  if ($arg{PrivateKey}) {
    # Sign public key with the signing key
    my $signature;
    if ($self->sigscheme eq 'Ed25519') {
      $signature = Crypt::Ed25519::sign( $public, $arg{PublicKey}, $arg{PrivateKey} );
    }
    else {
      my $ecdsa = new Crypt::EC_DSA;
      $signature = $ecdsa->sign( Message => $public, Key => $arg{PrivateKey} );
    }
    return ($public, $secret, $signature);
  }
  else {
    return ($public, $secret);
  }
}

sub signkeygen {
  my $self = shift;
  if ($self->sigscheme eq 'Ed25519') {
    return Crypt::Ed25519::generate_keypair;
  }
  else {
    my $ecdsa = new Crypt::EC_DSA;
    $ecdsa->keygen;
  }
}

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

sub _diag {
  my $self = shift;
  print STDERR @_ if $self->debug;
}

1; # End of Crypt::EECDH

__END__