NAME¶
Crypt::ECB - Encrypt Data using ECB Mode
SYNOPSIS¶
Use Crypt::ECB OO style
use Crypt::ECB;
$crypt = Crypt::ECB->new;
$crypt->padding(PADDING_AUTO);
$crypt->cipher('Blowfish') || die $crypt->errstring;
$crypt->key('some_key');
$enc = $crypt->encrypt("Some data.");
print $crypt->decrypt($enc);
or use the function style interface
use Crypt::ECB qw(encrypt decrypt encrypt_hex decrypt_hex);
$ciphertext = encrypt($key, 'Blowfish', "Some data", PADDING_AUTO);
$plaintext = decrypt($key, 'Blowfish', $ciphertext, PADDING_AUTO);
$hexcode = encrypt_hex($key, $cipher, $plaintext);
$plain = decrypt_hex($key, $cipher, $hexcode);
DESCRIPTION¶
This module is a Perl-only implementation of the ECB mode. In combination with a
block cipher such as DES, IDEA or Blowfish, you can encrypt and decrypt
messages of arbitrarily long length. Though for security reasons other modes
than ECB such as CBC should be preferred. See textbooks on cryptography if you
want to know why.
The functionality of the module can be accessed via OO methods or via standard
function calls. Remember that some crypting module like for example Blowfish
has to be installed. The syntax follows that of Crypt::CBC.
METHODS¶
new(), key(), cipher(), padding()¶
$crypt = Crypt::ECB->new;
$crypt->key('Some_key');
$crypt->cipher('Blowfish') || die $crypt->errstring;
$crypt->padding(PADDING_AUTO);
print $crypt->key;
print $crypt->cipher;
print $crypt->padding;
$crypt = Crypt::ECB->new('Some_key','Blowfish');
$crypt->cipher || die "'Blowfish' wasn't loaded for some reason.";
new() initializes the variables it uses. Optional
parameters are key and cipher. If called without parameters you have to call
key() and
cipher()
before you can start crypting. If called with key but without cipher, for
compatibility with Crypt::CBC 'DES' is assumed.
key() sets the key if given a parameter. It always
returns the key. Note that some crypting modules require keys of definite
length. For example the Crypt::Blowfish module expects an eight byte key.
cipher() sets the block cipher to be used if given a
parameter. It tries to load the corresponding module. If an error occurs, it
returns 0 and sets $crypt->{Errstring}. Otherwise it returns the cipher
name. Free packages available for Perl are for example Blowfish, DES or IDEA.
If called without parameter it just returns the name of the cipher.
padding() sets the way how data is padded up to a
multiple of the cipher's blocksize. Until now two ways are implemented: When
set to PADDING_NONE, no padding is done. You then have to take care of correct
padding (and truncating) yourself. When set to PADDING_AUTO, the ECB module
handles padding (and truncating when decrypting) the same way Crypt::CBC does.
By default the padding style is set to PADDING_NONE. This means if you don't
bother and your data has not the correct length, the module will complain and
therefore force you to think about what you really want.
start(), mode(), crypt(), finish()¶
$crypt->start('encrypt') || die $crypt->errstring;
$enc .= $crypt->crypt($_) foreach (@lines);
$enc .= $crypt->finish;
$crypt->start('decrypt');
print $crypt->mode;
start() sets the crypting mode and checks if all
required variables like key and cipher are set. Allowed parameters are any
words starting either with 'e' or 'd'. The Method returns the mode which is
set or 0 if an error occurred.
mode() is called without parameters and just returns
the mode which is set.
crypt() processes the data given as argument. If
called without argument $_ is processed. The method returns the processed
data. Cipher and key have to be set in order to be able to process data. If
some of these are missing or
start() was not
called before, the method dies.
After having sent all data to be processed to
crypt() you have to call
finish() in order to flush data that's left in
the buffer.
caching()¶
$crypt->caching(1); # caching on
$crypt->caching(0); # caching off
print $crypt->caching;
The caching mode is returned. If given an argument caching mode is set. Caching
is on if
caching() evaluates true, otherwise
caching is off. By default caching is on.
What is this caching? The Crypt::ECB module communicates with the cipher module
via some object. Creating the cipher object takes some time for the cipher
module has to do some initialization. Now caching means that the same cipher
object is used until caching is turned off or the key or the cipher module are
changed. If caching is off, a new cipher object is created is created each
time
crypt() or
finish() are called and destroyed at the end of
these methods. Crypting using caching is
much faster than without
caching.
encrypt(), decrypt(), encrypt_hex(), decrypt_hex()¶
$enc = $crypt->encrypt($data);
print $crypt->decrypt($enc);
$hexenc = $crypt->encrypt_hex($data);
print $crypt->decrypt_hex($hexenc);
encrypt() and
decrypt()
are convenience methods which call
start(),
crypt() and
finish()
for you.
encrypt_hex() and
decrypt_hex() are convenience functions that
operate on ciphertext in a hexadecimal representation. They are exactly
equivalent to
$hexenc = join('',unpack('H*',$crypt->encrypt($data)));
print $crypt->decrypt(pack('H*',$hexenc));
These functions can be useful if, for example, you wish to place the encrypted
information into an e-mail message, Web page or URL.
errstring()¶
print $crypt->errstring;
Some methods like
cipher() or
start() return 0 if an error occurs. You can then
retrieve a more detailed error message by calling $crypt->errstring.
VARIABLES¶
Variables which could be of interest to the outside world are:
$crypt->{Key},
$crypt->{Cipher},
$crypt->{Module},
$crypt->{Keysize},
$crypt->{Blocksize},
$crypt->{Mode},
$crypt->{Caching},
$crypt->{Padding},
$crypt->{Errstring}.
The variables should not be set directly, use instead the above described
methods. Reading should not pose a problem.
CONSTANTS¶
The two constants naming the padding styles are exported by default:
PADDING_NONE => 0
PADDING_AUTO => 1
FUNCTIONS¶
For convenience en- or decrypting can also be done by calling ordinary
functions. The functions are:
encrypt(),
decrypt(),
encrypt_hex,
decrypt_hex.
The module is smart enough to recognize whether these functions are called in
an OO context or not.
encrypt(), decrypt(), encrypt_hex(), decrypt_hex()¶
$ciphertext = encrypt($key, $cipher, $plaintext, PADDING_AUTO);
$plaintext = decrypt($key, $cipher, $ciphertext, PADDING_AUTO);
$ciphertext = encrypt_hex($key, $cipher, $plaintext, PADDING_AUTO);
$plaintext = decrypt_hex($key, $cipher, $ciphertext, PADDING_AUTO);
encrypt() and
decrypt()
process the provided text and return either the corresponding ciphertext
(encrypt) or plaintext (decrypt). Data and padstyle are optional, but remember
that by default no padding is done. If data is omitted, $_ is assumed.
encrypt_hex() and
decrypt_hex() operate on ciphertext in a
hexadecimal representation. Otherwise usage is the same as for
encrypt() and
decrypt().
BUGS¶
None that I know of.
TODO¶
The other block cipher modes CBC, CFB and OFB could be implemented.
Convenience encrypt and decrypt functions utilizing base64 encoding could be
added.
COPYING¶
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
AUTHOR¶
Christoph Appel (see ECB.pm for email address)
SEE ALSO¶
perl(1),
Crypt::DES(3),
Crypt::IDEA(3),
Crypt::CBC(3)