// Loads an X.509 certificate from a file.
public static X509Certificate loadCertificate(final String file)
throws IOException, CertificateException {
FileInputStream stream = null;
try {
stream = inputStream(file);
return (X509Certificate) X509CertFactory().generateCertificate(stream);
} finally {
if (stream != null) {
stream.close();
}
}
}
/**
* 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;
}
public PublicKey LoadPublicKey(String path, String algorithm)
throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
// Read Public Key.
File filePublicKey = new File(path + "public.key");
FileInputStream fis = new FileInputStream(path + "public.key");
byte[] encodedPublicKey = new byte[(int) filePublicKey.length()];
fis.read(encodedPublicKey);
fis.close();
// Generate PublicKey.
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedPublicKey);
PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
return publicKey;
}
static {
try {
FileInputStream keyfis = new FileInputStream("src/com/ingenium/ash/publicIngenium");
byte[] encKey = new byte[keyfis.available()];
keyfis.read(encKey);
keyfis.close();
X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(encKey);
KeyFactory keyFactory = KeyFactory.getInstance("DSA", "SUN");
pubKey = keyFactory.generatePublic(pubKeySpec);
} catch (InvalidKeySpecException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
} catch (NoSuchAlgorithmException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
} catch (NoSuchProviderException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
}
}
/**
* 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;
}
