File Coverage

lib/Crypt/Mode/CBC/Easy.pm

Criterion	Covered	Total	%
statement	47	49	95.9
branch	5	10	50.0
condition	1	3	33.3
subroutine	11	11	100.0
pod	2	2	100.0
total	66	75	88.0

use strict;
package Crypt::Mode::CBC::Easy;
#ABSTRACT: Encrypts/decrypts text and verifies decrypted text with a checksum and a random initialization vector.
$Crypt::Mode::CBC::Easy::VERSION = '0.003';
use Mouse;
use Crypt::CBC;
use Digest::SHA;
use MIME::Base64;
use Bytes::Random::Secure qw//;
use Crypt::Mode::CBC;
use Carp;




has key => (
    isa => 'Str',
    is => 'ro',
    required => 1,
);


has crypt_mode_cbc => (
    isa => 'Crypt::Mode::CBC',
    is => 'ro',
    required => 1,
    default => sub { Crypt::Mode::CBC->new('Twofish') },
);


has block_size => (
    isa => 'Int',
    is => 'ro',
    required => 1,
    default => 16,
);


has checksum_digest_hex => (
    isa => 'CodeRef',
    is => 'ro',
    required => 1,
    default => sub { \&Digest::SHA::sha512_hex },
);


has bytes_random_secure => (
    isa => 'Bytes::Random::Secure',
    is => 'ro',
    required => 1,
    default => sub { Bytes::Random::Secure->new(NonBlocking => 1) },
);


has separator => (
    isa => 'Str',
    is => 'ro',
    required => 1,
    default => '::~;~;~::',
);


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

    croak "must pass in text to be encrypted" unless @plain_texts;

    my $iv = $self->bytes_random_secure->bytes($self->block_size);

    my $digest = $self->_get_digest($iv, \@plain_texts);
    push @plain_texts, $digest;

    my $plain_texts_str = join($self->separator, @plain_texts);
    my $encrypted = $iv . $self->separator . $self->crypt_mode_cbc->encrypt($plain_texts_str, $self->key, $iv);
    my $cipher_text = MIME::Base64::encode($encrypted);

    return $cipher_text;
}


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

    croak "must pass in text to be decrypted" unless $cipher_text;

    my $separator = $self->separator;
    my ($iv, $to_decrypt) = split qr/$separator/, MIME::Base64::decode($cipher_text);

    croak "invalid cipher text" unless $iv and $to_decrypt;

    my $plain_text_with_checksum = $self->crypt_mode_cbc->decrypt($to_decrypt, $self->key, $iv);

    my @decrypted_values = split($self->separator, $plain_text_with_checksum);
    my $digest = pop @decrypted_values;
    my $confirm_digest = $self->_get_digest($iv, \@decrypted_values);

    if ($confirm_digest eq $digest) {
        if (wantarray) {
            return @decrypted_values;
        }
        else {
            return join($separator , @decrypted_values);
        }
    }
    else {
        croak "invalid encrypted text";
    }
}

sub _get_digest {
    my ($self, $iv, $texts) = @_;
    return $self->checksum_digest_hex->($iv . join('', @$texts));
}

1;

__END__