package org.bouncycastle.crypto.examples;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.security.SecureRandom;
import org.bouncycastle.crypto.CryptoException;
import org.bouncycastle.crypto.KeyGenerationParameters;
import org.bouncycastle.crypto.engines.DESedeEngine;
import org.bouncycastle.crypto.generators.DESedeKeyGenerator;
import org.bouncycastle.crypto.modes.CBCBlockCipher;
import org.bouncycastle.crypto.paddings.PaddedBufferedBlockCipher;
import org.bouncycastle.crypto.params.DESedeParameters;
import org.bouncycastle.crypto.params.KeyParameter;
import org.bouncycastle.util.encoders.Hex;
DESExample is a simple DES based encryptor/decryptor.
The program is command line driven, with the input
and output files specified on the command line.
java org.bouncycastle.crypto.examples.DESExample infile outfile [keyfile]
A new key is generated for each encryption, if key is not specified,
then the example will assume encryption is required, and as output
create deskey.dat in the current directory. This key is a hex
encoded byte-stream that is used for the decryption. The output
file is Hex encoded, 60 characters wide text file.
When encrypting;
- the infile is expected to be a byte stream (text or binary)
- there is no keyfile specified on the input line
When decrypting;
- the infile is expected to be the 60 character wide base64
encoded file
- the keyfile is expected to be a base64 encoded file
This example shows how to use the light-weight API, DES and
the filesystem for message encryption and decryption.
/**
* DESExample is a simple DES based encryptor/decryptor.
* <p>
* The program is command line driven, with the input
* and output files specified on the command line.
* <pre>
* java org.bouncycastle.crypto.examples.DESExample infile outfile [keyfile]
* </pre>
* A new key is generated for each encryption, if key is not specified,
* then the example will assume encryption is required, and as output
* create deskey.dat in the current directory. This key is a hex
* encoded byte-stream that is used for the decryption. The output
* file is Hex encoded, 60 characters wide text file.
* <p>
* When encrypting;
* <ul>
* <li>the infile is expected to be a byte stream (text or binary)
* <li>there is no keyfile specified on the input line
* </ul>
* <p>
* When decrypting;
* <ul>
* <li>the infile is expected to be the 60 character wide base64
* encoded file
* <li>the keyfile is expected to be a base64 encoded file
* </ul>
* <p>
* This example shows how to use the light-weight API, DES and
* the filesystem for message encryption and decryption.
*
*/
public class DESExample extends Object
{
// Encrypting or decrypting ?
private boolean encrypt = true;
// To hold the initialised DESede cipher
private PaddedBufferedBlockCipher cipher = null;
// The input stream of bytes to be processed for encryption
private BufferedInputStream in = null;
// The output stream of bytes to be procssed
private BufferedOutputStream out = null;
// The key
private byte[] key = null;
/*
* start the application
*/
public static void main(String[] args)
{
boolean encrypt = true;
String infile = null;
String outfile = null;
String keyfile = null;
if (args.length < 2)
{
DESExample de = new DESExample();
System.err.println("Usage: java "+de.getClass().getName()+
" infile outfile [keyfile]");
System.exit(1);
}
keyfile = "deskey.dat";
infile = args[0];
outfile = args[1];
if (args.length > 2)
{
encrypt = false;
keyfile = args[2];
}
DESExample de = new DESExample(infile, outfile, keyfile, encrypt);
de.process();
}
// Default constructor, used for the usage message
public DESExample()
{
}
/*
* Constructor, that takes the arguments appropriate for
* processing the command line directives.
*/
public DESExample(
String infile,
String outfile,
String keyfile,
boolean encrypt)
{
/*
* First, determine that infile & keyfile exist as appropriate.
*
* This will also create the BufferedInputStream as required
* for reading the input file. All input files are treated
* as if they are binary, even if they contain text, it's the
* bytes that are encrypted.
*/
this.encrypt = encrypt;
try
{
in = new BufferedInputStream(new FileInputStream(infile));
}
catch (FileNotFoundException fnf)
{
System.err.println("Input file not found ["+infile+"]");
System.exit(1);
}
try
{
out = new BufferedOutputStream(new FileOutputStream(outfile));
}
catch (IOException fnf)
{
System.err.println("Output file not created ["+outfile+"]");
System.exit(1);
}
if (encrypt)
{
try
{
/*
* The process of creating a new key requires a
* number of steps.
*
* First, create the parameters for the key generator
* which are a secure random number generator, and
* the length of the key (in bits).
*/
SecureRandom sr = null;
try
{
sr = new SecureRandom();
/*
* This following call to setSeed() makes the
* initialisation of the SecureRandom object
* _very_ fast, but not secure AT ALL.
*
* Remove the line, recreate the class file and
* then run DESExample again to see the difference.
*
* The initialisation of a SecureRandom object
* can take 5 or more seconds depending on the
* CPU that the program is running on. That can
* be annoying during unit testing.
* -- jon
*/
sr.setSeed("www.bouncycastle.org".getBytes());
}
catch (Exception nsa)
{
System.err.println("Hmmm, no SHA1PRNG, you need the "+
"Sun implementation");
System.exit(1);
}
KeyGenerationParameters kgp = new KeyGenerationParameters(
sr,
DESedeParameters.DES_EDE_KEY_LENGTH*8);
/*
* Second, initialise the key generator with the parameters
*/
DESedeKeyGenerator kg = new DESedeKeyGenerator();
kg.init(kgp);
/*
* Third, and finally, generate the key
*/
key = kg.generateKey();
/*
* We can now output the key to the file, but first
* hex encode the key so that we can have a look
* at it with a text editor if we so desire
*/
BufferedOutputStream keystream =
new BufferedOutputStream(new FileOutputStream(keyfile));
byte[] keyhex = Hex.encode(key);
keystream.write(keyhex, 0, keyhex.length);
keystream.flush();
keystream.close();
}
catch (IOException createKey)
{
System.err.println("Could not decryption create key file "+
"["+keyfile+"]");
System.exit(1);
}
}
else
{
try
{
// read the key, and decode from hex encoding
BufferedInputStream keystream =
new BufferedInputStream(new FileInputStream(keyfile));
int len = keystream.available();
byte[] keyhex = new byte[len];
keystream.read(keyhex, 0, len);
key = Hex.decode(keyhex);
}
catch (IOException ioe)
{
System.err.println("Decryption key file not found, "+
"or not valid ["+keyfile+"]");
System.exit(1);
}
}
}
private void process()
{
/*
* Setup the DESede cipher engine, create a PaddedBufferedBlockCipher
* in CBC mode.
*/
cipher = new PaddedBufferedBlockCipher(
new CBCBlockCipher(new DESedeEngine()));
/*
* The input and output streams are currently set up
* appropriately, and the key bytes are ready to be
* used.
*
*/
if (encrypt)
{
performEncrypt(key);
}
else
{
performDecrypt(key);
}
// after processing clean up the files
try
{
in.close();
out.flush();
out.close();
}
catch (IOException closing)
{
System.err.println("exception closing resources: " + closing.getMessage());
}
}
/*
* This method performs all the encryption and writes
* the cipher text to the buffered output stream created
* previously.
*/
private void performEncrypt(byte[] key)
{
// initialise the cipher with the key bytes, for encryption
cipher.init(true, new KeyParameter(key));
/*
* Create some temporary byte arrays for use in
* encryption, make them a reasonable size so that
* we don't spend forever reading small chunks from
* a file.
*
* There is no particular reason for using getBlockSize()
* to determine the size of the input chunk. It just
* was a convenient number for the example.
*/
// int inBlockSize = cipher.getBlockSize() * 5;
int inBlockSize = 47;
int outBlockSize = cipher.getOutputSize(inBlockSize);
byte[] inblock = new byte[inBlockSize];
byte[] outblock = new byte[outBlockSize];
/*
* now, read the file, and output the chunks
*/
try
{
int inL;
int outL;
byte[] rv = null;
while ((inL=in.read(inblock, 0, inBlockSize)) > 0)
{
outL = cipher.processBytes(inblock, 0, inL, outblock, 0);
/*
* Before we write anything out, we need to make sure
* that we've got something to write out.
*/
if (outL > 0)
{
rv = Hex.encode(outblock, 0, outL);
out.write(rv, 0, rv.length);
out.write('\n');
}
}
try
{
/*
* Now, process the bytes that are still buffered
* within the cipher.
*/
outL = cipher.doFinal(outblock, 0);
if (outL > 0)
{
rv = Hex.encode(outblock, 0, outL);
out.write(rv, 0, rv.length);
out.write('\n');
}
}
catch (CryptoException ce)
{
}
}
catch (IOException ioeread)
{
ioeread.printStackTrace();
}
}
/*
* This method performs all the decryption and writes
* the plain text to the buffered output stream created
* previously.
*/
private void performDecrypt(byte[] key)
{
// initialise the cipher for decryption
cipher.init(false, new KeyParameter(key));
/*
* As the decryption is from our preformatted file,
* and we know that it's a hex encoded format, then
* we wrap the InputStream with a BufferedReader
* so that we can read it easily.
*/
BufferedReader br = new BufferedReader(new InputStreamReader(in));
/*
* now, read the file, and output the chunks
*/
try
{
int outL;
byte[] inblock = null;
byte[] outblock = null;
String rv = null;
while ((rv = br.readLine()) != null)
{
inblock = Hex.decode(rv);
outblock = new byte[cipher.getOutputSize(inblock.length)];
outL = cipher.processBytes(inblock, 0, inblock.length,
outblock, 0);
/*
* Before we write anything out, we need to make sure
* that we've got something to write out.
*/
if (outL > 0)
{
out.write(outblock, 0, outL);
}
}
try
{
/*
* Now, process the bytes that are still buffered
* within the cipher.
*/
outL = cipher.doFinal(outblock, 0);
if (outL > 0)
{
out.write(outblock, 0, outL);
}
}
catch (CryptoException ce)
{
}
}
catch (IOException ioeread)
{
ioeread.printStackTrace();
}
}
}