Gecko [ edgpens.lpkmn.gov.my ]

Name	Size	Permission
Key	[ DIR ]	drwxrwxrwx
Signature	[ DIR ]	drwxrwxrwx
Armour.pm	7.91 KB	-rw-rw-rw-
Buffer.pm	2.11 KB	-rw-rw-rw-
CFB.pm	2.73 KB	-rw-rw-rw-
Certificate.pm	15.95 KB	-rw-rw-rw-
Cipher.pm	5.92 KB	-rw-rw-rw-
Ciphertext.pm	7.01 KB	-rw-rw-rw-
Compressed.pm	4.92 KB	-rw-rw-rw-
Config.pm	3.01 KB	-rw-rw-rw-
Constants.pm	2.39 KB	-rw-rw-rw-
Digest.pm	4.36 KB	-rw-rw-rw-
ErrorHandler.pm	2.37 KB	-rw-rw-rw-
Key.pm	6.11 KB	-rw-rw-rw-
KeyBlock.pm	3.64 KB	-rw-rw-rw-
KeyRing.pm	8.08 KB	-rw-rw-rw-
KeyServer.pm	4.32 KB	-rw-rw-rw-
MDC.pm	2.5 KB	-rw-rw-rw-
Marker.pm	893 B	-rw-rw-rw-
Message.pm	4.32 KB	-rw-rw-rw-
OnePassSig.pm	1.46 KB	-rw-rw-rw-
PacketFactory.pm	8.63 KB	-rw-rw-rw-
Plaintext.pm	3.24 KB	-rw-rw-rw-
S2k.pm	6.05 KB	-rw-rw-rw-
SKSessionKey.pm	6.15 KB	-rw-rw-rw-
SessionKey.pm	6.69 KB	-rw-rw-rw-
Signature.pm	12.44 KB	-rw-rw-rw-
Trust.pm	797 B	-rw-rw-rw-
UserID.pm	2.03 KB	-rw-rw-rw-
Util.pm	4.85 KB	-rw-rw-rw-
Words.pm	11.23 KB	-rw-rw-rw-

Code Editor : S2k.pm

package Crypt::OpenPGP::S2k;
use strict;

use Crypt::OpenPGP::Buffer;
use Crypt::OpenPGP::Digest;
use Crypt::OpenPGP::ErrorHandler;
use Crypt::OpenPGP::Util;
use base qw( Crypt::OpenPGP::ErrorHandler );

use vars qw( %TYPES );
%TYPES = (
    0 => 'Simple',
    1 => 'Salted',
    3 => 'Salt_Iter',
);

sub new {
    my $class = shift;
    my $type = shift;
    $type = $TYPES{ $type } || $type;
    return $class->error("Invalid type of S2k") unless $type;
    my $pkg = join '::', __PACKAGE__, $type;
    my $s2k = bless { }, $pkg;
    $s2k->init(@_);
}

sub parse {
    my $class = shift;
    my($buf) = @_;
    my $id = $buf->get_int8;
    my $type = $TYPES{$id};
    $class->new($type, $buf);
}

sub init { $_[0] }
sub generate {
    my $s2k = shift;
    my($passphrase, $keysize) = @_;
    my($material, $pass) = ('', 0);
    my $hash = $s2k->{hash};
    while (length($material) < $keysize) {
        my $pad = '' . chr(0) x $pass;
        $material .= $s2k->s2k($passphrase, $pad);
        $pass++;
    }
    substr($material, 0, $keysize);
}
sub set_hash {
    my $s2k = shift;
    my($hash_alg) = @_;
    $s2k->{hash} = ref($hash_alg) ? $hash_alg :
        Crypt::OpenPGP::Digest->new($hash_alg);
}

package Crypt::OpenPGP::S2k::Simple;
use base qw( Crypt::OpenPGP::S2k );

use Crypt::OpenPGP::Constants qw( DEFAULT_DIGEST );

sub init {
    my $s2k = shift;
    my($buf) = @_;
    if ($buf) {
        $s2k->{hash_alg} = $buf->get_int8;
    }
    else {
        $s2k->{hash_alg} = DEFAULT_DIGEST;
    }
    if ($s2k->{hash_alg}) {
        $s2k->{hash} = Crypt::OpenPGP::Digest->new($s2k->{hash_alg});
    }
    $s2k;
}

sub s2k { $_[0]->{hash}->hash($_[2] . $_[1]) }

sub save {
    my $s2k = shift;
    my $buf = Crypt::OpenPGP::Buffer->new;
    $buf->put_int8(1);
    $buf->put_int8($s2k->{hash_alg});
    $buf->bytes;
}

package Crypt::OpenPGP::S2k::Salted;
use base qw( Crypt::OpenPGP::S2k );

use Crypt::OpenPGP::Constants qw( DEFAULT_DIGEST );

sub init {
    my $s2k = shift;
    my($buf) = @_;
    if ($buf) {
        $s2k->{hash_alg} = $buf->get_int8;
        $s2k->{salt} = $buf->get_bytes(8);
    }
    else {
        $s2k->{hash_alg} = DEFAULT_DIGEST;
        $s2k->{salt} = Crypt::OpenPGP::Util::get_random_bytes(8);
    }
    if ($s2k->{hash_alg}) {
        $s2k->{hash} = Crypt::OpenPGP::Digest->new($s2k->{hash_alg});
    }
    $s2k;
}

sub s2k { $_[0]->{hash}->hash($_[0]->{salt} . $_[2] . $_[1]) }

sub save {
    my $s2k = shift;
    my $buf = Crypt::OpenPGP::Buffer->new;
    $buf->put_int8(2);
    $buf->put_int8($s2k->{hash_alg});
    $buf->put_bytes($s2k->{salt});
    $buf->bytes;
}

package Crypt::OpenPGP::S2k::Salt_Iter;
use base qw( Crypt::OpenPGP::S2k );

use Crypt::OpenPGP::Constants qw( DEFAULT_DIGEST );

sub init {
    my $s2k = shift;
    my($buf) = @_;
    if ($buf) {
        $s2k->{hash_alg} = $buf->get_int8;
        $s2k->{salt} = $buf->get_bytes(8);
        $s2k->{count} = $buf->get_int8;
    }
    else {
        $s2k->{hash_alg} = DEFAULT_DIGEST;
        $s2k->{salt} = Crypt::OpenPGP::Util::get_random_bytes(8);
        $s2k->{count} = 96;
    }
    if ($s2k->{hash_alg}) {
        $s2k->{hash} = Crypt::OpenPGP::Digest->new($s2k->{hash_alg});
    }
    $s2k;
}

sub s2k {
    my $s2k = shift;
    my($pass, $pad) = @_;
    my $salt = $s2k->{salt};
    my $count = (16 + ($s2k->{count} & 15)) << (($s2k->{count} >> 4) + 6);
    my $len = length($pass) + 8;
    if ($count < $len) {
        $count = $len;
    }
    my $res = $pad;
    while ($count > $len) {
        $res .= $salt . $pass;
        $count -= $len;
    }
    if ($count < 8) {
        $res .= substr($salt, 0, $count);
    } else {
        $res .= $salt;
        $count -= 8;
        $res .= substr($pass, 0, $count);
    }
    $s2k->{hash}->hash($res);
}

sub save {
    my $s2k = shift;
    my $buf = Crypt::OpenPGP::Buffer->new;
    $buf->put_int8(3);
    $buf->put_int8($s2k->{hash_alg});
    $buf->put_bytes($s2k->{salt});
    $buf->put_int8($s2k->{count});
    $buf->bytes;
}

1;
__END__

=head1 NAME

Crypt::OpenPGP::S2k - String-to-key generation

=head1 SYNOPSIS

use Crypt::OpenPGP::S2k;

# S2k generates an encryption key from a passphrase; in order to
    # understand how large of a key to generate, we need to know which
    # cipher we're using, and what the passphrase is.
    my $cipher = Crypt::OpenPGP::Cipher->new( '...' );
    my $passphrase = 'foo';

my $s2k = Crypt::OpenPGP::S2k->new( 'Salt_Iter' );
    my $key = $s2k->generate( $passphrase, $cipher->keysize );

my $serialized = $s2k->save;

=head1 DESCRIPTION

I<Crypt::OpenPGP::S2k> implements string-to-key generation for use in
generating symmetric cipher keys from standard, arbitrary-length
passphrases (like those used to lock secret key files). Since a
passphrase can be of any length, and key material must be a very
specific length, a method is needed to translate the passphrase into
the key. The OpenPGP RFC defines three such methods, each of which
this class implements.

=head1 USAGE

=head2 Crypt::OpenPGP::S2k->new($type)

Creates a new type of S2k-generator of type I<$type>; valid values for
I<$type> are C<Simple>, C<Salted>, and C<Salt_Iter>. These generator
types are described in the OpenPGP RFC section 3.7.

Returns the new S2k-generator object.

=head2 Crypt::OpenPGP::S2k->parse($buffer)

Given a buffer I<$buffer> of type I<Crypt::OpenPGP::Buffer>, determines
the type of S2k from the first octet in the buffer (one of the types
listed above in I<new>), then creates a new object of that type and
initializes the S2k state from the buffer I<$buffer>. Different
initializations occur based on the type of S2k.

Returns the new S2k-generator object.

=head2 $s2k->save

Serializes the S2k object and returns the serialized form; this form
will differ based on the type of S2k.

=head2 $s2k->generate($passphrase, $keysize)

Given a passphrase I<$passphrase>, which should be a string of octets
of arbitrary length, and a keysize I<$keysize>, generates enough key
material to meet the size I<$keysize>, and returns that key material.

=head1 AUTHOR & COPYRIGHTS

Please see the Crypt::OpenPGP manpage for author, copyright, and
license information.

=cut

${this.title}

Code Editor : S2k.pm