bitjoe - Contrib - Encryption - SOURCE CODE

use ExtUtils::MakeMaker;

WriteMakefile(
    dist	=> {
	            PREOP	=> 'pod2text Rijndael.pm | tee README >$(DISTVNAME)/README; chmod -R u=rwX,go=rX . ;',
	            COMPRESS	=> 'gzip -9v',
	            SUFFIX	=> '.gz',
	           },
    NAME => "Crypt::Rijndael",
    OBJECT => q[_rijndael$(OBJ_EXT) Rijndael$(OBJ_EXT)],
    VERSION_FROM => "Rijndael.pm",
);

=head1 NAME

Crypt::Rijndael - Crypt::CBC compliant Rijndael encryption module

=head1 SYNOPSIS

 use Crypt::Rijndael;

 # keysize() is 32, but 24 and 16 are also possible
 # blocksize() is 16

 $cipher = new Crypt::Rijndael "a" x 32, Crypt::Rijndael::MODE_CBC;

 $cipher->set_iv($iv);
 $crypted = $cipher->encrypt($plaintext);
 # - OR -
 $plaintext = $cipher->decrypt($crypted);

=head1 DESCRIPTION

This module implements the Rijndael cipher, which has just been selected
as the Advanced Encryption Standard.

=over 4

=cut

package Crypt::Rijndael;

require DynaLoader;

$VERSION = 0.04;
@ISA = qw/DynaLoader/;

bootstrap Crypt::Rijndael $VERSION;

=item keysize

Returns the keysize, which is 32 (bytes). The Rijndael cipher
actually supports keylengths of 16, 24 or 32 bytes, but there is no
way to communicate this to C<Crypt::CBC>.

=item blocksize

The blocksize for Rijndael is 16 bytes (128 bits), although the
algorithm actually supports any blocksize that is any multiple of
our bytes.  128 bits, is however, the AES-specified block size,
so this is all we support.

=item $cipher = new $key [, $mode]

... [truncated, 48 more lines] ...

use ExtUtils::MakeMaker;
# See lib/ExtUtils/MakeMaker.pm for details of how to influence
# the contents of the Makefile that is written.
WriteMakefile(
    'NAME'		=> 'Crypt::Rijndael_PP',
    'VERSION_FROM'	=> 'Rijndael_PP.pm', # finds $VERSION
    'PREREQ_PM'		=> {}, # e.g., Module::Name => 1.1
    'AUTHOR'		=> 'Christian Lackas, <delta@lackas.net>',
    'ABSTRACT'		=> 'Pure Perl implementation of Rijndael (AES)',
);

sub MY::postamble {
	'
all :: README

README: Rijndael_PP.pm
	$(PERL) -e \'use Pod::Text; pod2text "$<"\' > $@
'
}

NAME
    Crypt::Rijndael_PP - Perl implementation of Rijndael

DISCLAIMER
    This is a pure perl implementation of the new AES Rijndael. You want to
    use "Crypt::Rijndael" where available. This implementation is really
    slow, but I am working on it.

SYNOPSIS
     # Functional style
     use Crypt::Rijndael_PP ':all';

     $key = '1234567890ABCDEF' x 4; # 256bit hex number

     # keysize = 256bit, blocksize = 128bit
     $c_txt = rijndael_encrypt($key, MODE_CBC, $data,  256, 128);
     $p_txt = rijndael_decrypt($key, MODE_CBC, $c_txt, 256, 128);

     # OO style
     # same interface as Crypt::Rijndael
     use Crypt::Rijndael_PP;

     $cipher = Crypt::Rijndael_PP->new( pack('H*', $key), MODE_CBC );

     $c_txt = $cipher->encrypt($data);
     $p_txt = $cipher->decrypt($c_txt);

DESCRIPTION
    This modules shares the OO style interface with "Crypt::Rijndael" from
    Rafael R. Sevilla.

        Supported modes: Electronic CodeBook (MODE_ECB) and Cipher Block
        Chaining (MODE_CBC). Please use "Crypt::CBC" for CBC-Mode, as my CBC
        is not compatible with neither "Crypt::CBC" nor "Crypt::Rijndael"
        and it is subject to change in the near future. When using
        "Crypt::CBC" this module is 100% compatible to "Crypt::Rijndael" and
        you can decrypt and encrypt your data with both modules!

        Supported keysizes: 128, 192 and 256 (default)

        Supported blocksizes: 128 (default), 192 and 256

    If the size of the key does not match the given keysize then the key is
    padded with "0" (hex) or truncated to the right size.

    The last data block is padded with "\0" if it does not match a multiple
    of the blocksize.

    Warnings a raised in both cases.


... [truncated, 58 more lines] ...

#!/usr/bin/perl -w
# $Id: Rijndael_PP.pm,v 1.20 2001/08/16 08:55:16 lackas Exp $
package Crypt::Rijndael_PP;

require 5.004;
use strict;
use integer;
use Carp;

use vars qw'$VERSION @EXPORT @EXPORT_OK %EXPORT_TAGS @ISA';
require Exporter;

@ISA = 'Exporter';
$VERSION = 0.04;
@EXPORT_OK = qw(
	blockDecrypt blockEncrypt blockEncryptRound blockDecryptRound
	cipherUpdateRounds cipherInit makeKey
	MODE_ECB MODE_CBC MODE_CFB1
	DIR_ENCRYPT DIR_DECRYPT
);
@EXPORT = qw(rijndael_encrypt rijndael_decrypt);
%EXPORT_TAGS = (
	all => [@EXPORT_OK,@EXPORT],
	modes => [qw(MODE_ECB MODE_CBC MODE_CFB1)],
	directions => [qw(DIR_ENCRYPT DIR_DECRYPT)],
	CAPI => [qw(cipherInit makeKey blockDecrypt blockEncrypt)]
);


# boxes-ref.dat
use constant Logtable => [
  0,   0,  25,   1,  50,   2,  26, 198,  75, 199,  27, 104,  51, 238, 223,   3, 
100,   4, 224,  14,  52, 141, 129, 239,  76, 113,   8, 200, 248, 105,  28, 193, 
125, 194,  29, 181, 249, 185,  39, 106,  77, 228, 166, 114, 154, 201,   9, 120, 
101,  47, 138,   5,  33,  15, 225,  36,  18, 240, 130,  69,  53, 147, 218, 142, 
150, 143, 219, 189,  54, 208, 206, 148,  19,  92, 210, 241,  64,  70, 131,  56, 
102, 221, 253,  48, 191,   6, 139,  98, 179,  37, 226, 152,  34, 136, 145,  16, 
126, 110,  72, 195, 163, 182,  30,  66,  58, 107,  40,  84, 250, 133,  61, 186, 
 43, 121,  10,  21, 155, 159,  94, 202,  78, 212, 172, 229, 243, 115, 167,  87, 
175,  88, 168,  80, 244, 234, 214, 116,  79, 174, 233, 213, 231, 230, 173, 232, 
 44, 215, 117, 122, 235,  22,  11, 245,  89, 203,  95, 176, 156, 169,  81, 160, 
127,  12, 246, 111,  23, 196,  73, 236, 216,  67,  31,  45, 164, 118, 123, 183, 
204, 187,  62,  90, 251,  96, 177, 134,  59,  82, 161, 108, 170,  85,  41, 157, 
151, 178, 135, 144,  97, 190, 220, 252, 188, 149, 207, 205,  55,  63,  91, 209, 
 83,  57, 132,  60,  65, 162, 109,  71,  20,  42, 158,  93,  86, 242, 211, 171, 
 68,  17, 146, 217,  35,  32,  46, 137, 180, 124, 184,  38, 119, 153, 227, 165, 
103,  74, 237, 222, 197,  49, 254,  24,  13,  99, 140, 128, 192, 247, 112,   7 
];

use constant Algotable => [

... [truncated, 2619 more lines] ...

#!/usr/bin/perl -w
# $Id: comp.pl,v 1.6 2001/08/12 20:05:02 lackas Exp $

# Compare results from Crypt::Rijndael_PP with Crypt::Rijndael
# Press Ctrl-C to stop the test (on Unix)
# prints '.' for every correct calculation and dies
# if the results are different

use strict;
use blib qw'./blib';
use Crypt::Rijndael_PP;
use Crypt::Rijndael;

my ($count,$bytes) = 0;

my $mult = 10;

sub result { print "\n$count rounds\n$bytes Bytes\n"; exit; };

$SIG{INT} = \&result;

my $mode = shift || 'CBC';
my $key_size = 256;
my $plain_size = 128;

my %MODE = (
	ECB => {
		c_xs => Crypt::Rijndael::MODE_ECB,
		c_pl => Crypt::Rijndael_PP::MODE_ECB
	},
	CBC => {
		c_xs => Crypt::Rijndael::MODE_CBC,
		c_pl => Crypt::Rijndael_PP::MODE_CBC
	}
);

$|++;
while(1) {
	my $key = gen($key_size);
	my $c_xs = Crypt::Rijndael->new($key, $MODE{$mode}{c_xs});
	my $c_pl = Crypt::Rijndael_PP->new($key, $MODE{$mode}{c_pl});
			
	for (1..10) {
		my $plain = gen($plain_size * (int(rand 16) +1 ));
		my $t_xs = $c_xs->encrypt($plain);
		my $t_pl = $c_pl->encrypt($plain);
		my $p_pl = $c_pl->decrypt($t_pl);
		my $p_xs = $c_xs->decrypt($t_pl);
		if ($t_xs ne $t_pl) {
			print "Ciphertext differs.\n";

... [truncated, 35 more lines] ...