File Coverage

blib/lib/Crypt/ProtectedString.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

package Crypt::ProtectedString;

use 5.008001;
use strict;
use warnings;

our $VERSION = '0.00_01';
$VERSION = eval $VERSION;  # see L

# Format:
#   VERSION$TYPE$CIPHERTEXT$DISPLAYTEXT$reserved fields for future use
#
# Version = #!PROTECTEDKEYID, where PROTECTEDKEYID is an integer reference
#   to the protected key to use...
#
# For credit cards: TYPE=cc-number, optional field 1 = plaintext exp. date
#   For example: #!1$CC$base64-string-here$**** **** **** 1234$12/08$
#
# For passwords: TYPE=password, DISPLAYTEXT= empty ($$).

use Module::Pluggable ( search_path => ['Crypt::ProtectedString::Types'],
			instantiate => 'new' );
use Carp;

our $delimiter = '$';
our $version_string = '#!1';

sub _choose_best {
  my $query = shift;
  my $prio_method = shift;
  my $exec_method = shift;

  my @priorities;

  foreach my $plugin ( plugins() ) {
    if ($plugin->can($prio_method) && $plugin->can($exec_method)) {
      my $priority = $plugin->$prio_method($query);
      push @priorities, [$plugin, $priority];
    }
  }

  @priorities = sort {$b->[1] <=> $a->[1]} @priorities;
  return $priorities[0]->[0];
}

sub new {
  my $class = shift;

  if ($#_ == -1) {
    return __PACKAGE__->_new_blank($class);
  } elsif ($#_ == 0) {
    my $protectedstr = shift;

    return __PACKAGE__->_new_from_protected($class, $protectedstr);
  } elsif ($#_ == 1) {
    my $datatype = shift;
    my $plaintext = shift;

    return __PACKAGE__->_new_from_plaintext($class, $datatype, $plaintext);
  } else {
    die("Invalid number of arguments in Secrets");
  }

}

sub _new_blank {
  my $class = shift;
  my $self;
  $self->{protected} = '';
  bless $self, $class;
}

sub _new_from_protected {
  my $class = shift;
  my $protectedstr = shift;
  my $self;
  $self->{protected} = $protectedstr;
  return bless $self, $class;
}

sub _new_from_plaintext {
  my $class = shift;
  my $type = shift;
  my $plaintext = shift;
  my $self;
  bless $self, $class;

  $self->{protected} = $self->protect($type,$plaintext);

  return $self;
}

sub display {
  my $self = shift;
  my @parr;
  my $protectedstr = $self->{protected};
  if ($#_ == -1) {
    @parr = split(/$delimiter/, $self->{protected}, 5);
    return $parr[3];
  }
  elsif($#_ == 0) {
    $protectedstr = $_[0];
    @parr = split(/$delimiter/, $protectedstr, 5);
    return $parr[3];
  }
  elsif($#_ == 1) {
    my $type = $_[0];
    my $plaintext = $_[1];
    my $displayer = __PACKAGE__->_choose_best($type,'can_display','display');
    return $displayer->display($type, $plaintext);
  }
  else { die("Invalid arguments to ProtectedString create_display."); }
}

sub _protect {
  my $type = shift;
  my $plaintext = shift;
  my $displaytext = shift;
  my $ciphertext = __PACKAGE__->_encrypt($type, $plaintext, $version_string);

  return join ($delimiter, $version_string, $type, $ciphertext, $displaytext, @_);
}

sub protect {
  my $self = shift;
  my $type = shift;
  my $plaintext = shift;
  my $displaytext = $self->display($type, $plaintext);

  $self->{protected} = __PACKAGE__->_protect($type,$plaintext,$displaytext, @_);

  return $self->{protected};
}

sub _encrypt {
  my $type = shift;
  my $plaintext = shift;
  my $keyid = shift;
  $keyid ||= $version_string;
  my $cryptkeeper = __PACKAGE__->_choose_best($type,'can_encrypt','encrypt');

  return $cryptkeeper->encrypt($type,$plaintext,$keyid);
}

sub _decrypt {
  my $type = shift;
  my $ciphertext = shift;
  my $keyid = shift;

  my $cryptkeeper = __PACKAGE__->_choose_best($type,'can_decrypt','decrypt');

  return $cryptkeeper->decrypt($type, $ciphertext, $keyid);
}

sub decrypt {
  my $self = shift;
  my ($type,$ciphertext,$keyid);
  if ($#_ == -1) {
    my @parr = split(/$delimiter/, $self->{protected}, 5);
    $type = $parr[1];
    $ciphertext = $parr[2];
    $keyid = $parr[0];
  } elsif($#_ == 0) {
    my @parr = split(/$delimiter/, $_[0], 5);
    $type = $parr[1];
    $ciphertext = $parr[2];
    $keyid = $parr[0];
  } elsif($#_ == 1) {
    $type = shift;
    $ciphertext = shift;
    $keyid = $version_string;
  } elsif($#_ == 2) {
    $type = shift;
    $ciphertext = shift;
    $keyid = shift;
    $keyid ||= $version_string;
  } else { die("Invalid arguments to ProtectedString decrypt."); }

  return __PACKAGE__->_decrypt($type,$ciphertext,$keyid);
}

sub AS_STRING {
  my $self = shift;

  return $self->{protected};

}

1;
__END__