Crypt-Eksblowfish
view release on metacpan or search on metacpan
version 0.007; 2009-04-22
* in XS code, use the correct "PREINIT:" instead of "INIT:" to introduce
variable declarations
* test Uklblowfish with long keys
version 0.006; 2009-04-21
* in C::E::Family, new method "as_class" to work around Crypt::CBC
brain damage
* use simpler "parent" pragma in place of "base"
* in documentation, use the term "truth value" instead of the less
precise "boolean"
* drop prototypes from method subs (where the prototypes have no effect)
* in C::E::Family, abandon use of the "fields" module
lib/Crypt/Eksblowfish.pm view on Meta::CPAN
Performs key setup on a new instance of the Eksblowfish algorithm,
returning the keyed state. The KEY may be any length from 1 octet to
72 octets inclusive. The SALT is a family key, and must be exactly
16 octets. COST is an integer parameter controlling the expense of
keying: the number of operations in key setup is proportional to 2^COST.
All three parameters influence all the subkeys; changing any of them
produces a different encryption function.
Due to the mandatory family-keying parameters (COST and SALT), this
constructor does not match the interface expected by C<Crypt::CBC>
and similar crypto plumbing modules. To
use Eksblowfish with them it is necessary to have an object that
encapsulates a cipher family and provides a constructor that takes only a
key argument. That facility is supplied by C<Crypt::Eksblowfish::Family>.
=back
=head1 METHODS
=over
lib/Crypt/Eksblowfish/Blowfish.pm view on Meta::CPAN
=over
=item Crypt::Eksblowfish::Blowfish->blocksize
Returns 8, indicating the Blowfish block size of 8 octets. This method
may be called on either the class or an instance.
=item Crypt::Eksblowfish::Blowfish->keysize
Returns 0, indicating that the key size is variable. This situation is
handled specially by C<Crypt::CBC>.
=back
=cut
sub keysize { 0 }
=head1 CONSTRUCTOR
=over
lib/Crypt/Eksblowfish/Family.pm view on Meta::CPAN
$cipher = $family->new($key);
=head1 DESCRIPTION
An object of this class represents an Eksblowfish cipher family.
It contains the family parameters (cost and salt), and if combined
with a key it yields an encryption function. See L<Crypt::Eksblowfish>
for discussion of the Eksblowfish algorithm.
It is intended that an object of this class can be used in situations
such as the "-cipher" parameter to C<Crypt::CBC>. Normally that parameter
is the name of a class, such as "Crypt::Rijndael", where the class
implements a block cipher algorithm. The class provides a C<new>
constructor that accepts a key. In the case of Eksblowfish, the key
alone is not sufficient. An Eksblowfish family fills the role of block
cipher algorithm. Therefore a family object is used in place of a class
name, and it is the family object the provides the C<new> constructor.
=head2 Crypt::CBC
C<Crypt::CBC> itself has a problem, with the result that this class can
no longer be used with it in the manner originally intended.
When this class was originally designed, it worked with C<Crypt::CBC>
as described above: an object of this class would be accepted by
C<Crypt::CBC> as a cipher algorithm, and C<Crypt::CBC> would happily
supply it with a key and encrypt using the resulting cipher object.
C<Crypt::CBC> didn't realise it was dealing with a family object, however,
and there was some risk that a future version might accidentally squash
the object into a string, which would be no use. In the course of
discussion about regularising the use of cipher family objects, the
author of C<Crypt::CBC> got hold of the wrong end of the stick, and
ended up changing C<Crypt::CBC> in a way that totally breaks this usage,
rather than putting it on a secure footing.
The present behaviour of C<Crypt::CBC> is that if an object (rather
than a class name) is supplied as the "-cipher" parameter then it has
a completely different meaning from usual. In this case, the object
supplied is used as the keyed cipher, rather than as a cipher algorithm
which must be given a key. This bypasses all of C<Crypt::CBC>'s usual
keying logic, which can hash and salt a passphrase to generate the key.
It is arguably a useful feature, but it's a gross abuse of the "-cipher"
parameter and a severe impediment to the use of family-keyed cipher
algorithms.
This class now provides a workaround. For the benefit of C<Crypt::CBC>,
and any other crypto plumbing that requires a keyable cipher algorithm
to look like a Perl class (rather than an object), a family object
of this class can in fact be reified as a class of its own. See the
method L</as_class>.
=cut
package Crypt::Eksblowfish::Family;
{ use 5.006; }
lib/Crypt/Eksblowfish/Family.pm view on Meta::CPAN
Returns 8, indicating the Eksblowfish block size of 8 octets.
=cut
sub blocksize { 8 }
=item $family->keysize
Returns 0, indicating that the key size is variable. This situation is
handled specially by C<Crypt::CBC>.
=cut
sub keysize { 0 }
=item $family->new(KEY)
Performs key setup on a new instance of the Eksblowfish algorithm,
returning the keyed state. The KEY may be any length from 1 octet to 72
octets inclusive. The object returned is of class C<Crypt::Eksblowfish>;
lib/Crypt/Eksblowfish/Family.pm view on Meta::CPAN
sub new {
my($self, $key) = @_;
croak "Crypt::Eksblowfish::Family::new is not a class method ".
"(perhaps you want new_family instead)"
if ref($self) eq "";
return Crypt::Eksblowfish->new($self->{cost}, $self->{salt}, $key);
}
=item $family->encrypt
This method nominally exists, to satisfy C<Crypt::CBC>. It can't really
be used: it doesn't make any sense.
=cut
sub encrypt { croak "Crypt::Eksblowfish::Family::encrypt called" }
=item $family->as_class
Generates and returns (the name of) a Perl class that behaves as a
keyable cipher algorithm identical to this Eksblowfish cipher family.
The same methods that can be called as instance methods on $family can
be called as class methods on the generated class.
You should prefer to use the family object directly wherever you can.
Aside from being a silly indirection, the classes generated by this
method cannot be garbage-collected. This method exists only to cater to
C<Crypt::CBC>, which requires a keyable cipher algorithm to look like a
Perl class, and won't operate correctly on one that looks like an object.
=cut
sub as_class {
my($self) = @_;
return $self->{as_class} ||= do {
my $pkg = genpkg(__PACKAGE__."::");
no strict "refs";
@{"${pkg}::ISA"} = (ref($self));
lib/Crypt/Eksblowfish/Family.pm view on Meta::CPAN
*{"${pkg}::new"} = sub { shift; $self->new(@_) };
*{"${pkg}::as_class"} = sub { $pkg };
$pkg;
};
}
=back
=head1 SEE ALSO
L<Crypt::CBC>,
L<Crypt::Eksblowfish>
=head1 AUTHOR
Andrew Main (Zefram) <zefram@fysh.org>
=head1 COPYRIGHT
Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
Andrew Main (Zefram) <zefram@fysh.org>
lib/Crypt/Eksblowfish/Uklblowfish.pm view on Meta::CPAN
=over
=item Crypt::Eksblowfish::Uklblowfish->blocksize
Returns 8, indicating the Blowfish block size of 8 octets. This method
may be called on either the class or an instance.
=item Crypt::Eksblowfish::Uklblowfish->keysize
Returns 0, indicating that the key size is variable. This situation is
handled specially by C<Crypt::CBC>.
=back
=cut
sub keysize { 0 }
=head1 CONSTRUCTOR
=over
( run in 1.134 second using v1.01-cache-2.11-cpan-df04353d9ac )