File Coverage

blib/lib/Crypt/Keyczar.pm

Criterion	Covered	Total	%
statement	85	95	89.4
branch	14	18	77.7
condition	3	9	33.3
subroutine	22	24	91.6
pod	0	6	0.0
total	124	152	81.5

package Crypt::Keyczar;
use base 'Exporter';
use strict;
use warnings;
use Carp;
use Crypt::Keyczar::FileReader;
use Crypt::Keyczar::KeyMetadata;
use Crypt::Keyczar::Key;


our $VERSION = 0.09;

use constant FORMAT_VERSION => 0;
use constant FORMAT_BYTES   => pack 'C', 0;
use constant KEY_HASH_SIZE  => 4;
use constant HEADER_SIZE    => 1 + 4;

our @EXPORT_OK = qw(FORMAT_VERSION FORMAT_BYTES KEY_HASH_SIZE HEADER_SIZE);


sub new {
    my $class = shift;
    my $reader = shift;

    if (UNIVERSAL::isa($reader, 'Crypt::Keyczar::Reader')) {
        return $class->_new($reader);
    }
    else {
        return $class->_new(Crypt::Keyczar::FileReader->new($reader));
    }
}


sub _new {
    my $class = shift;
    my $reader = shift;

    my $self = bless {
        metadata => undef,
        primary_version => undef,
        version_map => {},
        hash_map    => {},
    }, $class;

    $self->metadata(Crypt::Keyczar::KeyMetadata->read($reader->get_metadata()));
    for my $v ($self->metadata->get_versions) {
        next if !$v;
        if ($v->status eq 'PRIMARY') {
            if ($self->primary) {
                croak "duplicate primary key";
            }
            $self->primary($v);
        }
        my $key = Crypt::Keyczar::Key->read_key(
            $self->metadata->get_type(), $reader->get_key($v->get_number()));
        my $key_hash = Crypt::Keyczar::_KeyHash->new($key->hash());
        $self->{hash_map}->{$key_hash->hash_code()} = $key;
        $self->{version_map}->{$v->get_number()} = $key;
    }
    return $self;
}


sub metadata {
    my $self = shift;
    $self->{metadata} = shift if @_;
    return $self->{metadata};
}


sub primary  {
    my $self = shift;
    $self->{primary_version} = shift if  @_;
    return $self->{primary_version};
}


sub get_key_by_number {
    my $self = shift;
    my $num = shift;
    return $self->{version_map}->{$num};
}


sub get_key {
    my $self = shift;
    my $id = shift;
    if (ref $id && $id->isa('Crypt::Keyczar::KeyVersion')) {
        # find by KeyVersion
        return $self->{version_map}->{$id->get_number};
    }
    elsif (ref $id && $id->isa('Crypt::Keyczar::Key')) {
        return $self->{hash_map}->{$id->hash};
    }
    else {
        # find by hash code
        my $hash = Crypt::Keyczar::_KeyHash->new($id);
        return $self->{hash_map}->{$hash->hash_code};
    }
}


sub add_key {
    my $self = shift;
    my ($version, $key) = @_;

    my $hash = Crypt::Keyczar::_KeyHash->new($key->hash);
    $self->{hash_map}->{$hash->hash_code} = $key;
    $self->{version_map}->{$version->get_number} = $key;

    $self->metadata->add_version($version);
}


1;


package Crypt::Keyczar::_KeyHash;
use strict;
use warnings;
use Carp;


sub new {
    my $class = shift;
    my $data = shift;
    if (length $data != Crypt::Keyczar::KEY_HASH_SIZE()) {
        confess "is not keyczar hash";
    }
    my $self = bless \$data, $class;
    return $self;
}


sub equals {
    my $self = shift;
    my $obj = shift;
    return $obj->isa('Crypt::Keyczar::_KeyHash') && $obj->hash_code() == $self->hash_code();
}


sub hash_code {
    my $self = shift;
    return unpack 'N', $$self;
}

1;
__END__