File Coverage

blib/lib/Data/Encrypted.pm

Criterion	Covered	Total	%
statement	9	91	9.8
branch	0	58	0.0
condition	0	27	0.0
subroutine	3	10	30.0
pod			n/a
total	12	186	6.4

package Data::Encrypted;

use strict;
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK $VAR1);

require Exporter;

require Crypt::RSA;
require Crypt::RSA::Key::Public::SSH;
require Crypt::RSA::Key::Private::SSH;

require Term::ReadPassword;
require File::HomeDir;
require Storable;
require Fcntl;

use Carp;

$VERSION = '0.07';
@ISA = qw(Exporter);
@EXPORT = qw();
@EXPORT_OK = qw(encrypted encrypt finish finished);

my $RESET = 0;
my ($FILE, $FH);
my ($PK, $SK, $PW);

sub import {

    @_ = _get_args(@_);

    # let Exporter finish it's work:
    Data::Encrypted->export_to_level(1, @_);
}

sub _get_args {

    for (my $i = 0 ; $i < @_ ; $i++) {
	if ($_[$i] =~ m/-?reset/oi) {
	    $RESET = 1;
	    splice(@_, $i--, 1);
	} elsif ($_[$i] =~ m/-?file/oi) {
	    $FILE = $_[$i+1];
	    splice(@_, $i--, 2);
	    _get_filehandle();
	} elsif ($_[$i] =~ m/-?fh/oi) {
	    $FH = $_[$i+1];
	    splice(@_, $i--, 2);
	} elsif ($_[$i] =~ m/-?pk/oi) {
	    $PK = $_[$i+1];
	    splice(@_, $i--, 2);
	} elsif ($_[$i] =~ m/-?sk/oi) {
	    $SK = $_[$i+1];
	    splice(@_, $i--, 2);
	} elsif ($_[$i] =~ m/-?pw/oi) {
	    $PW = $_[$i+1];
	    splice(@_, $i--, 2);
	}
    }

    return @_;
}

sub new {

    my $class = shift;
    $class = ref $class || $class;
    my $self = bless {}, $class;

    _get_args(@_);

    unless (defined $FH) {
	_get_filehandle()
    }

    $self->{_public} = ref $PK ? $PK : new Crypt::RSA::Key::Public::SSH
	Filename => $PK || (File::HomeDir::home() . '/.ssh/identity.pub');
    $self->{_private} = ref $SK ? $SK : new Crypt::RSA::Key::Private::SSH
	(Filename => $SK || (File::HomeDir::home() . '/.ssh/identity'),
	 Password => $PW );

    $self->{_rsa} = new Crypt::RSA;

    return $self;
}

sub _get_filehandle {

    if ($FILE =~ m/^~([^\/]*)\//o) {
	my $user = $1;
	my $path;
	if ($user) {
	    $path = File::HomeDir::home($user);
	} else {
	    $path = File::HomeDir::home();
	}
	unless ($path) {
	    croak "No home directory for user: $user\n";
	}
	$FILE =~ s/^~$user/$path/;
    }

    sysopen(FH, $FILE, Fcntl::O_RDWR() | Fcntl::O_CREAT() )
	or croak "Can't open $FILE: $!";
    flock(FH, Fcntl::LOCK_EX())
	or croak "Can't flock file: $!";
    $FH = \*FH;
}

sub encrypted {

    my $self = shift;
    my $arg = shift;

    unless (ref $self) {
	my $newself = Data::Encrypted->new(defined $arg ? $arg : (), @_);
	($self, $arg) = ($newself, $self);
    }

    unless ($arg) {
	croak "Must supply argument to encrypted!";
    }

    unless (exists $self->{_data}) {
	$self->{_data} = '';
	while (<$FH>) {
	    $self->{_data} .= $_;
	}

	$self->{_data} =~ s/\s*$//os;

	if ($self->{_data}) {
	    $self->{_data} = $self->{_rsa}->decrypt(Cyphertext => $self->{_data},
						    Key => $self->{_private},
						    Armour => 1
					           );
	    $self->{_data} = Storable::thaw($self->{_data});
	} else {
	    $self->{_data} = {};
        }
    }

    if ($RESET || ! exists $self->{_data}->{$arg}) {
	$self->{_data}->{$arg} =
	    Term::ReadPassword::read_password(ref($self) .
					      " value for '$arg' not found," .
					      " please enter: ", 0, 1, 1);
    }
    return $self->{_data}->{$arg};
}

*encrypt = \&encrypted;

sub finished {

    if ($FH) {
	flock($FH, Fcntl::LOCK_UN());
	close($FH);
	undef $FH;
    }
}

*finish = \&finished;

sub DESTROY {

    my $self = shift;

    if ($self && ($FH || $FILE)) {
	unless ($FH) {
	    sysopen(FH, $FILE, Fcntl::O_RDWR() | Fcntl::O_CREAT())
		or croak "Can't open $FILE: $!";
	    flock(FH, Fcntl::LOCK_EX())
		or croak "Can't flock file: $!";
	    $FH = \*FH;
	}
	seek($FH, 0, 0);
	unless ($RESET) {
	    # need to rebuild our cryptosystem, ugh.
	    $self->{_public} = ref $PK ? $PK : new Crypt::RSA::Key::Public::SSH
		Filename => $PK || (File::HomeDir::home() . '/.ssh/identity.pub');
	    $self->{_private} = ref $SK ? $SK : new Crypt::RSA::Key::Private::SSH
		(Filename => $SK || (File::HomeDir::home() . '/.ssh/identity'),
		 Password => $PW );
	    $self->{_rsa} = new Crypt::RSA;
	    $self->{_data} = Storable::freeze($self->{_data});
	    $self->{_data} = $self->{_rsa}->encrypt(Message => $self->{_data},
						    Key => $self->{_public},
						    Armour => 1
					         );
	    print $FH $self->{_data};
	}
	delete $self->{_data};
    }

    unless (exists $INC{'Inline/Files.pm'} || ! $FILE) {
	flock($FH, Fcntl::LOCK_UN());
	close($FH);
	undef $FH;
    }

}

1;

__END__