File Coverage

blib/lib/Crypt/CipherSaber.pm

Criterion	Covered	Total	%
statement	79	79	100.0
branch	12	12	100.0
condition	5	5	100.0
subroutine	12	12	100.0
pod	5	5	100.0
total	113	113	100.0

package Crypt::CipherSaber;

use strict;

use Carp;
use Scalar::Util 'reftype';

use vars '$VERSION';

$VERSION = '1.01';

sub new
{
    my ($class, $key, $N) = @_;

    # CS-2 shuffles the state array N times, CS-1 once
    if ( !( defined $N ) or ( $N < 1 ) )
    {
        $N = 1;
    }
    bless [ $key, [ 0 .. 255 ], $N ], $class;
}

sub crypt
{
    my ($self, $iv, $message) = @_;
    $self->_setup_key($iv);

    my $state   = $self->[1];
    my $output  = _do_crypt( $state, $message );
    $self->[1]  = [ 0 .. 255 ];
    return $output;
}

sub encrypt
{
    my $self = shift;
    my $iv   = $self->_gen_iv();
    return $iv . $self->crypt( $iv, @_ );
}

sub decrypt
{
    my $self = shift;
    my ( $iv, $message ) = unpack( "a10a*", +shift );
    return $self->crypt( $iv, $message );
}

sub fh_crypt
{
    my ( $self, $in, $out, $iv ) = @_;

    for my $glob ($in, $out)
    {
        my $reftype = reftype( $glob ) || '';
        unless ($reftype eq 'GLOB')
        {
            require Carp;
            Carp::carp( 'Non-filehandle passed to fh_crypt()' );
            return;
        }
    }

    local *OUT = $out;
    if ( defined($iv) )
    {
        $iv = $self->_gen_iv() if length($iv) == 1;
        $self->_setup_key($iv);
        print OUT $iv;
    }

    my $state = $self->[1];

    my ( $buf, @vars );

    while (<$in>)
    {
        unless ($iv)
        {
            ( $iv, $_ ) = unpack( "a10a*", $_ );
            $self->_setup_key($iv);
        }
        my $line;
        ( $line, $state, @vars ) = _do_crypt( $state, $_, @vars );
        print OUT $line;
    }
    $self->[1] = [ 0 .. 255 ];
    return 1;
}

###################
#
# PRIVATE METHODS
#
###################
sub _gen_iv
{
    my $iv;
    for ( 1 .. 10 )
    {
        $iv .= chr( int( rand(256) ) );
    }
    return $iv;
}

sub _setup_key
{
    my $self   = shift;
    my $key    = $self->[0] . shift;
    my @key    = map { ord } split( //, $key );
    my $state  = $self->[1];
    my $j      = 0;
    my $length = @key;

    # repeat N times, for CS-2
    for ( 1 .. $self->[2] )
    {
        for my $i ( 0 .. 255 )
        {
            $j += ( $state->[$i] + ( $key[ $i % $length ] ) );
            $j %= 256;
            ( @$state[ $i, $j ] ) = ( @$state[ $j, $i ] );
        }
    }
}

sub _do_crypt
{
    my ( $state, $message, $i, $j, $n ) = @_;

    my $output = '';

    for ( 0 .. ( length($message) - 1 ) )
    {
        $i++;
        $i %= 256;
        $j += $state->[$i];
        $j %= 256;
        @$state[ $i, $j ] = @$state[ $j, $i ];
        $n = $state->[$i] + $state->[$j];
        $n %= 256;
        $output .= chr( $state->[$n] ^ ord( substr( $message, $_, 1 ) ) );
    }

    return wantarray ? ( $output, $state, $i, $j, $n ) : $output;
}

1;

__END__