File Coverage

blib/lib/DBIx/Class/CryptColumn.pm

Criterion	Covered	Total	%
statement	70	70	100.0
branch	12	20	60.0
condition	1	3	33.3
subroutine	17	17	100.0
pod	4	4	100.0
total	104	114	91.2

package DBIx::Class::CryptColumn;
$DBIx::Class::CryptColumn::VERSION = '0.009';
use strict;
use warnings;

use Crypt::Passphrase 0.019;
use Sub::Util 1.40 'set_subname';
use namespace::clean;

use parent 'DBIx::Class';

__PACKAGE__->load_components(qw(InflateColumn::Crypt::Passphrase));

sub new {
	my ($self, $attr, @rest) = @_;

	for my $col (grep { !/^-/ } keys %{ $attr }) {
		next unless my $inflate = $self->column_info($col)->{inflate_passphrase};
		$attr->{$col} = $inflate->hash_password($attr->{$col});
	}

	return $self->next::method($attr, @rest);
}

sub _export_sub {
	my ($self, $name, $sub) = @_;
	my $full_name = $self->result_class . "::$name";
	no strict 'refs';
	*$full_name = set_subname $full_name => $sub;
}

sub register_column {
	my ($self, $column, $info, @rest) = @_;

	if (my $args = $info->{inflate_passphrase}) {
		$self->throw_exception(q['inflate_passphrase' must be a hash reference]) unless ref $args eq 'HASH';

		my $crypt_passphrase = Crypt::Passphrase->new(%{$args});

		if (defined(my $name = $args->{verify_method})) {
			$self->_export_sub($name, sub {
				my ($row, $password) = @_;
				return $crypt_passphrase->verify_password($password, $row->get_column($column));
			});
		}

		if (defined(my $name = $args->{rehash_method})) {
			$self->_export_sub($name, sub {
				my $row = shift;
				return $crypt_passphrase->needs_rehash($row->get_column($column));
			});
		}

		if (defined(my $name = $args->{verify_and_rehash_method})) {
			$self->_export_sub($name, sub {
				my ($row, $password) = @_;

				my $hash = $row->get_column($column);
				my $result = $crypt_passphrase->verify_password($password, $hash);
				if ($result && $crypt_passphrase->needs_rehash($hash)) {
					$row->update({ $column => $password })->discard_changes;
				}

				return $result;
			});
		}

		if (defined(my $name = $args->{recode_hash_method})) {
			$self->_export_sub($name, sub {
				my $row = shift;
				my $old_hash = $row->get_column($column);
				my $new_hash = $crypt_passphrase->recode_hash($old_hash);

				if ($new_hash ne $old_hash) {
					local $self->column_info($column)->{inflate_passphrase};
					$row->update({ $column => $new_hash })->discard_changes;
				}

				return $new_hash;
			});
		}

		$info->{inflate_passphrase} = $crypt_passphrase;
	}

	$self->next::method($column, $info, @rest);
}

sub set_column {
	my ($self, $col, $val, @rest) = @_;

	my $inflate = $self->column_info($col)->{inflate_passphrase};
	$val = $inflate->hash_password($val) if $inflate;

	return $self->next::method($col, $val, @rest);
}

sub set_inflated_column {
	my ($self, $col, $val, @rest) = @_;
	local $self->column_info($col)->{inflate_passphrase};
	$self->next::method($col, $val, @rest);
}

1;

# ABSTRACT: Automatically hash password/passphrase columns

__END__