Symmetric Cryptography in Perl
by Abhijit Menon-Sen
|
Pages: 1, 2
Given enough patience and ciphertext, Eve can start to build a code book that maps ciphertext blocks to plaintext ones. Then, without knowing either the algorithm or the key, she could simply look up the relevant blocks in the intercepted ciphertext and write down large parts of the original plaintext!
Several new cipher modes have been invented to address this problem. One of the most generally useful ones is Cipher Block Chaining. CBC starts by generating a random block (called an Initializ,ation Vector, or IV) and encrypting it. The first plaintext block is XORed with the encrypted IV before being encrypted. Thereafter, each block is XORed with the ciphertext of the block preceding it, and then encrypted.
Here, each ciphertext block depends on the preceding ciphertext block,
and the plaintext blocks so far. Thus, the blocks must be decrypted in
order, and none of the patterns displayed by ECB are present. The IV
itself does not need to be kept secret, and is usually transmitted with
the ciphertext like $size above.
Decryption of the ciphertext proceeds in the opposite order. The first ciphertext block is decrypted and XORed with the IV to form the first plaintext block, and each ciphertext block thereafter is XORed with the previous one to form a plaintext block. Other modes are similar in intent, but vary in detail, including the way errors in transmission affect the ciphertext, and the amount of feedback or dependency on previous blocks.
Alice and Bob could alter their code to perform cipher block chaining, but the handy Crypt::CBC module can save them the trouble. The module, available from the CPAN, is used in conjunction with a symmetric cipher module (like Crypt::Twofish). It handles padding, IV generation and all other details. The user only needs to specify a key, and the data to be encrypted or decrypted.
Thus, Alice could just do:
use Crypt::CBC;
$cipher = new Crypt::CBC ($key, 'Twofish');
undef $/; $plaintext = <PLAINTEXT>;
print CIPHERTEXT $cipher->encrypt($plaintext);
And Bob could do:
use Crypt::CBC;
$cipher = new Crypt::CBC ($key, 'Twofish');
undef $/; $ciphertext = <CIPHERTEXT>;
print PLAINTEXT $cipher->decrypt($ciphertext);
Much simpler!
Asymmetric Cryptography
Asymmetric (or public-key) ciphers use a pair of mathematically related keys, and the algorithms are so designed that data encrypted with one half of the key pair can only be decrypted by the other. Bob can generate a key pair and keep one half secret, while publishing the other half. Alice can then encrypt the recipe with Bob's public key, knowing that it can only be decrypted with the secret half. Although this eliminates the need to share keys over a secure channel, it has its problems, too. For one, most public key encryption schemes require much longer keys (often 2048 bits or more) and are much slower.
The Crypt namespace contains modules for public key cryptography as
well. Crypt::RSA is a portable implementation of the (now free) RSA
algorithm, one of the most widely studied public-key encryption schemes.
There are interfaces to various versions of PGP (Crypt::PGP2,
Crypt::PGP5, Crypt::GPG), as well as implementations of public-key
based signature algorithms (Crypt::DSA).
Cryptanalysis
Unfortunately, our implicit assumption that the ciphertext is useless to Eve is not always true. Depending on the information and resources that are available to her, she can try various means to retrieve the recipe. The simplest strategy is to try and guess the key Alice used. This is known as a brute-force attack, and involves repeatedly generating random keys and trying to decrypt the ciphertext with each one.
The effectiveness of this approach depends on the size of the key: the longer it is, the more possible keys there are, and the more guesses will be required, on average, to find the right one. Thus, the only possible defense is to use a key long enough to make a key search computationally impractical.
How long is a safe key? DES with 56-bit keys was recently cracked in a
little less than a day, but the 128-bit keyspace (range of possible
keys) is 4 * 10**21 times larger still. Although computing power is
becoming cheaper, it seems likely that 128-bit keys will be safe from
brute-force attacks for many years to come.
Of course, there are far more sophisticated attacks that they may be vulnerable to. As we saw in the description of ECB, cryptanalysts can often exploit patterns in the plaintext (long signatures, repeated phrases) or ciphertext (repeated blocks) to great advantage, or they may look for weaknesses (or exploit known ones) in the algorithm. Often, a combination of such techniques reduces the potential keyspace enough that a brute-force attack becomes practical.
Cryptanalysis and cryptographic techniques advanced hand-in-hand; new ciphers are designed to withstand old attacks, and newer attacks are attempted all the time. This makes it very important to stay abreast of current advances in cryptographic technology if you are serious about protecting your data for long periods of time.
Further Resources
- google.com
- The Great God Google knows enough about cryptography-related material to keep you occupied for a considerable amount of time.
- perl-crypto-subscribe@perl.org
- The perl-crypto mailing list, although not very active at the moment, is intended for discussion of all aspects (both user and developer level) of cryptography with Perl.
- Crypt::Twofish
- The Crypt::Twofish module, which has benefited from the inputs of several people, is a good example of how to write a portable cipher implementation.
