/**
* Reads the raw data from the input File, encrypts and saves its contents to the output File, and
* then save the raw data of the SecretKey used to the SecretKey File.
*
* @param input the File to be read and encrypted
* @param output the File the encrypted data will be saved to
* @param keyFile the File the SecretKey data will be saved to
* @throws InvalidKeyException if the given key is inappropriate for initializing this cipher, or
* if this cipher is being initialized for decryption and requires algorithm parameters that
* cannot be determined from the given key, or if the given key has a keysize that exceeds the
* maximum allowable keysize (as determined from the configured jurisdiction policy files).
* @throws IOException if any of the files do not exist, are a directory rather than a regular
* file, or for some other reason cannot be opened for reading or if an I/O error occurs.
* @throws IllegalBlockSizeException if the cipher is a block cipher, no padding has been
* requested (only in encryption mode), and the total input length of the data processed by
* this cipher is not a multiple of block size; or if this encryption algorithm is unable to
* process the input data provided.
* @throws BadPaddingException if the cipher is in decryption mode, and (un)padding has been
* requested, but the decrypted data is not bounded by the appropriate padding bytes
*/
public void encrypt(File input, File output, File keyFile)
throws InvalidKeyException, IOException, IllegalBlockSizeException, BadPaddingException {
if (debug) {
System.out.println("Initializing encryption...");
}
cipher.init(Cipher.ENCRYPT_MODE, key);
FileInputStream fis = null;
try {
fis = new FileInputStream(input);
data = new byte[(int) input.length()];
if (debug) {
System.out.println("Reading data...");
}
fis.read(data);
} finally {
if (fis != null) {
fis.close();
}
}
if (debug) {
System.out.println("Encrypting data...");
}
data = cipher.doFinal(data);
FileOutputStream fos = null;
try {
fos = new FileOutputStream(output);
if (debug) {
System.out.println("Saving data...");
}
fos.write(data);
} finally {
if (fos != null) {
fos.close();
}
}
if (debug) {
System.out.println("Saving key...");
}
data = key.getEncoded();
fos = null;
try {
fos = new FileOutputStream(keyFile);
fos.write(data);
} finally {
if (fos != null) {
fos.close();
}
}
if (debug) {
System.out.println("Encryption complete!");
}
data = null;
}
void getTable() {
if (chooser == null) {
File userdir = new File(System.getProperty("user.dir"));
chooser = new JFileChooser(userdir);
}
if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
file = chooser.getSelectedFile();
fileLength = file.length();
setTitle(windowTitle + ": " + file.getAbsolutePath());
int size = Key.getEncryptionKeySize(this, true);
key = Key.getEncryptionKey(this, true, size);
if (key == null) key = defaultKey;
initCipher();
} else System.exit(0);
}
/**
* Reads the raw data from the SecretKey File, creates a SecretKey from that raw data, reads the
* raw data from the input File, and then decrypts and saves its contents to the output File.
*
* @param input the File to be read and decrypted
* @param output the File the decrypted data will be saved to
* @param keyFile the File the SecretKey data will be loaded from
* @throws InvalidKeyException if the given key material is shorter than 8 bytes or if the given
* key is inappropriate for initializing this cipher, or if this cipher is being initialized
* for decryption and requires algorithm parameters that cannot be determined from the given
* key, or if the given key has a keysize that exceeds the maximum allowable keysize (as
* determined from the configured jurisdiction policy files).
* @throws IOException if any of the files do not exist, are a directory rather than a regular
* file, or for some other reason cannot be opened for reading or if an I/O error occurs.
* @throws IllegalBlockSizeException if the cipher is a block cipher, no padding has been
* requested (only in encryption mode), and the total input length of the data processed by
* this cipher is not a multiple of block size; or if this encryption algorithm is unable to
* process the input data provided.
* @throws BadPaddingException if the cipher is in decryption mode, and (un)padding has been
* requested, but the decrypted data is not bounded by the appropriate padding bytes.
* @throws NoSuchAlgorithmException if no Provider supports a SecretKeyFactorySpi implementation
* for the specified algorithm.
* @throws InvalidKeySpecException if the given key specification is inappropriate for this
* secret-key factory to produce a secret key.
* @throws UnsupportedOperationException if algorithm is not DES or DESede
*/
public void decrypt(File input, File output, File keyFile)
throws InvalidKeyException, IOException, IllegalBlockSizeException, BadPaddingException,
NoSuchAlgorithmException, InvalidKeySpecException {
if (debug) {
System.out.println("Loading key...");
}
FileInputStream fis = null;
try {
fis = new FileInputStream(keyFile);
data = new byte[fis.available()];
fis.read(data);
} finally {
if (fis != null) {
fis.close();
}
}
switch (Algorithm.valueOf(algorithm)) {
case DES:
key = SecretKeyFactory.getInstance(algorithm).generateSecret(new DESKeySpec(data));
break;
case DESede:
key = SecretKeyFactory.getInstance(algorithm).generateSecret(new DESedeKeySpec(data));
break;
default:
throw new UnsupportedOperationException("Unsupported decryption algorithm");
}
if (debug) {
System.out.println("Initializing decryption...");
}
cipher.init(Cipher.DECRYPT_MODE, key);
if (debug) {
System.out.println("Reading data...");
}
fis = null;
try {
fis = new FileInputStream(input);
data = new byte[(int) input.length()];
fis.read(data);
} finally {
if (fis != null) {
fis.close();
}
}
if (debug) {
System.out.println("Decrypting data...");
}
data = cipher.doFinal(data);
if (debug) {
System.out.println("Saving data...");
}
FileOutputStream fos = null;
try {
fos = new FileOutputStream(output);
fos.write(data);
} finally {
if (fos != null) {
fos.close();
}
}
if (debug) {
System.out.println("Decryption complete!");
}
data = null;
}