The Crypt-Eksblowfish module gives Perl users the access to this, but the module has many parts and is not crystal clear on usage. This is just a clarified version of one of the modules test scripts, to show how you can use it.

Update 2005-07.Jul-12: Version 0.92 ; new method for seed generation as a result of code feedback from PerlMonks. Thank you!

• NAME
• SYNOPSIS
• DESCRIPTION
• CAVEATS
• HISTORY
• AUTHOR
• COPYRIGHT

NAME

Crypt::Random::ISAAC - ISAAC Crypto-secure PRNG, using address allocation as seed.

SYNOPSIS

This is a drop-in replacement for Perl's rand(), but nothing is exported by default.

        use Crypt::Random::ISAAC 'rand';
        print rand();
        
        ## OR ##
        
        use Crypt::Random::ISAAC;
        print Crypt::Random::ISAAC::rand();
        
        ## OR ##
        
        use Crypt::Random::ISAAC qw'rand randinit';
        @Crypt::ISAAC::randrsl = @seed0..255;
        randinit(1); ## inits using seed value;
        print rand();

This can be used with other modules like Crypt::RandPasswd in the following manner:

        use Crypt::Random::ISAAC;
        use Crypt::RandPasswd;
        *Crypt::RandPasswd::rng = \&Crypt::Random::ISAAC::rand;

since our rand function has the same interface.

DESCRIPTION

A CSPRNG using natural timing (specific to exact CPU and load when run) as a seed, conforming to the ISAAC spec (considered Cryptograpically Secure). Core PRNG uses code originally (c)Bob Jenkins, 1996 and ported to Perl by John L. Allen, 2000. See http://burtleburtle.net/bob/rand/isaacafa.html for the original C code and the Perl translation.

Initialization is peformed during module load, but can be repeated.

CAVEATS

Seed not tested

Although the ISAAC algorithm has been well-tested for security, the method for choosing the random seed that is employed by this module has not. The seed is chosen by allocating memory for references, assigning the lower 32 bits of the address to each seed slot. The results are mixed somewhat before use, and care is taken to ensure that a contiguous block of addresses are not used.

If this is not secure enough, the @randrsl array can be populated with seed values from a more entropic source (like /dev/random on *NIX). If this is done, you must call the randinit function to re-seed the generator. For example:

        if (-f '/dev/random') {
                open RAND, '<', '/dev/random' or die('No read on random device');
                for (0..255) { 
                        my $bytes;
                        read(RAND,$bytes,2);
                        $bytes = (ord(substr($bytes,0,1))<<16) + (ord(substr($bytes,1,1)));
                        $Crypt::Random::ISAAC::randrsl$_ = $bytes;
                }
                close RAND;
        }

But then, if you have /dev/random, you probably don't need this module!

Rand function wrapper insufficiently tested

The replacement rand() relies on isaac() for its randomness. Some numerical conversion is done. While I don't believe this conversion has any effect on randomness, it has not been robustly tested. The author welcomes feedback on this function.

HISTORY

Version 0.9

Released on PerlMonks http://www.perlmonks.com - original version.

Version 0.91

Not released, testing version

Version 0.92

Released on PerlMonks http://www.perlmonks.com - new random-seeder method; uses the lowest 32 bits of a series of addresses belonging to references. This should be hard to reproduce or guess.

AUTHOR

Darren Meyer <darren.meyer@gmail.com>, making heavy use of others' code.

COPYRIGHT

Original ISAAC code (c)1996 Bob Jenkins under a ``code is free and may be used as you wish'' license.

Perl port (c)2000 John L. Allen under the same license as the original ISAAC code.

This module is available under the terms of the MIT License, though the code by the above authors is unencumbered.:

Copyright (c)2005 Darren Meyer

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ``Software''), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Crypt::OpenPGP provides no overt mechanism to interrogate a self-signed key to determine the owner's preferred encryption mechanisms. After pointers in Crypt::OpenPGP - determining which cipher to use I came up with this sample code that shows how you can do that.

Caveats: delves into object innards, provided for education only, tested only with modern (v4) signatures, assumption that code is self-documenting may be dubious.

• Supervisor, that compares file md5 checksums with the ones stores in a fingerprint file
• update, that updates information about supervised file into the fingerprint file

Sample Use

my $obj = Blowfish->new($passphrase, length($passphrase));
my $crypttext = $obj->Encrypt($text, length($text));
my $plaintext = $obj->Decrypt($crypttext, length($crypttext));
[download]

This is a complete and historically accurate implementation of the Vigenere cipher. According to The Code Book, by Simon Singh, (Doubleday, 1999, ISBN 0385495315) Blaise de Vigenere formalized this cipher system based on the earlier work of Battista Alberti, Johannes Trithemius and Giovanni Porta.

This cipher is defined to function only on letters, and only with a key comprised exclusively of letters. Among this cipher's strengths is that only the encrypted letters are included in the ciphertext.
All punctuation and spaces are removed, so the ciphertext is an unbroken string of letters. No word breaks or punctuation to help in cryptanalysis.

Don't take that to mean this is secure against anyone serious.
It isn't.

There is a recent reference to a module called Crypt::Vigenere by Alistair Mills, but a CPAN search does not locate it as of 2002-01-13.
Discussion of the submission of that module is at: http://archive.develooper.com/modules@perl.org/msg08962.html

A simple encrypt-decrypt web program that uses MD5 and One Time Pad together. It's as secure as: The 'seed' key used by the sender and the SSL encryption in your web browser.

What happens:

Many thanks to MrNobo1024 (and Euclid) for gcd and to Tye for helping me debug.

bash$ cbc some_text_file
bash$ cbc some_text_file.cbc
bash$ cbc -c some_text_file.cbc

To require literal characters, use lowercase, as in pat fXXd, requiring an f, two identical letters, and a d, such as "food" or "feed".

For grins, dumps the regex that the pattern has been transformed into, so you can write your own, or see how much work you're avoiding by using this program.

"Fun for the entire family!"

-- Rolling Stone magazine (but not about this program)