TotallySuspiciousFile.txt

import java.io.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.util.*;
import java.nio.file.*;

/*
 *               Cryptr
 *
 * Cryptr is a java encryption toolset
 * that can be used to encrypt/decrypt files
 * and keys locally, allowing for files to be
 * shared securely over the world wide web
 *
 * Cryptr provides the following functions:
 *	 1. Generating a secret key
 *   2. Encrypting a file with a secret key
 *   3. Decrypting a file with a secret key
 *   4. Encrypting a secret key with a public key
 *   5. Decrypting a secret key with a private key
 *
 */

public class Cryptr {


	/**
	 * Generates an 128-bit AES secret key and writes it to a file
	 *
	 * @param  secKeyFile    name of file to store secret key
	 */
	static void generateKey(String secKeyFile) throws Exception{
		KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
		keyGenerator.init(128);
		SecretKey key = keyGenerator.generateKey();
		
		String keyString = Base64.getEncoder().encodeToString(key.getEncoded());
		System.out.println(keyString);
		
		try(FileOutputStream out = new FileOutputStream(secKeyFile)){
			byte[] keyb = key.getEncoded();
			out.write(keyb);
		}
	}


	/**
	 * Extracts secret key from a file, generates an
	 * initialization vector, uses them to encrypt the original
	 * file, and writes an encrypted file containing the initialization
	 * vector followed by the encrypted file data
	 *
	 * @param  originalFile    name of file to encrypt
	 * @param  secKeyFile      name of file storing secret key
	 * @param  encryptedFile   name of file to write iv and encrypted file data
	 */
	static void encryptFile(String originalFile, String secKeyFile, String encryptedFile) {
		byte[] key = null;
		try{	
			key = Files.readAllBytes(Paths.get(secKeyFile));
		}
		catch(IOException e){
			System.out.println("IOException Thrown");
			System.exit(0);
		}
		SecretKeySpec skey = new SecretKeySpec(key, "AES");

		byte[] iv = new byte[128/8];
		SecureRandom srandom = new SecureRandom();
		srandom.nextBytes(iv);
		IvParameterSpec ivspec = new IvParameterSpec(iv);
		try(FileOutputStream out = new FileOutputStream(encryptedFile);
			FileInputStream in = new FileInputStream(originalFile)){
			
			out.write(iv);
		
			Cipher ci = Cipher.getInstance("AES/CBC/PKCS5Padding");
			ci.init(Cipher.ENCRYPT_MODE, skey, ivspec);
			
			byte[] ibuf = new byte[1024];
			int len;
			while((len = in.read(ibuf)) != -1){
				byte[] obuf = ci.update(ibuf,0, len);
				if(obuf != null)
					out.write(obuf);
			}
			byte[] obuf = ci.doFinal();
			if(obuf != null) 
				out.write(obuf);
			
			in.close();
			out.close();
		}
		catch(Exception e){
			System.out.println("you dun goofed");
		}
	}


	/**
	 * Extracts the secret key from a file, extracts the initialization vector
	 * from the beginning of the encrypted file, uses both secret key and
	 * initialization vector to decrypt the encrypted file data, and writes it to
	 * an output file
	 *
	 * @param  encryptedFile    name of file storing iv and encrypted data
	 * @param  secKeyFile	    name of file storing secret key
	 * @param  outputFile       name of file to write decrypted data to
	 */
	static void decryptFile(String encryptedFile, String secKeyFile, String outputFile) {
		byte[] key = null;
		try{
			key = Files.readAllBytes(Paths.get(secKeyFile));
		}
		catch(IOException e){
			System.out.println("IOException Thrown");
			System.exit(0);
		}
		
		SecretKeySpec skey = new SecretKeySpec(key, "AES");
	
		byte[] iv = new byte[128/8];
		try(FileInputStream in = new FileInputStream(encryptedFile);
			FileOutputStream out = new FileOutputStream(outputFile)){
			
			in.read(iv);
			IvParameterSpec ivspec = new IvParameterSpec(iv);			

			Cipher ci = Cipher.getInstance("AES/CBC/PKCS5Padding");
			ci.init(Cipher.DECRYPT_MODE, skey, ivspec);
			
			byte[] ibuf = new byte[1024];
			int len;
			while((len = in.read(ibuf)) != -1){
				byte[] obuf = ci.update(ibuf, 0, len);
				if(obuf != null) 
					out.write(obuf);
			}
			byte[] obuf = ci.doFinal();
			if(obuf != null)
				out.write(obuf);
			
			in.close();
			out.close();
		}
		catch(Exception e){
			System.out.println("You dun goofed");
		}
	}


	/**
	 * Extracts secret key from a file, encrypts a secret key file using
     * a public Key (*.der) and writes the encrypted secret key to a file
	 *
	 * @param  secKeyFile    name of file holding secret key
	 * @param  pubKeyFile    name of public key file for encryption
	 * @param  encKeyFile    name of file to write encrypted secret key
	 */
	static void encryptKey(String secKeyFile, String pubKeyFile, String encKeyFile) {
		/*byte[] bytes = null;
		X509EncodedKeySpec ks = null;
		KeyFactory kf = null;*/
		PublicKey pub = null;
		try{
			byte[] bytes = Files.readAllBytes(Paths.get(pubKeyFile));
			X509EncodedKeySpec ks = new X509EncodedKeySpec(bytes);
			KeyFactory kf = KeyFactory.getInstance("RSA");
			pub = kf.generatePublic(ks);
		}
		catch(Exception e){
			System.out.println("Exception Thrown");
			System.exit(0);	
		}
		
		try(FileInputStream in = new FileInputStream(secKeyFile);
			FileOutputStream out = new FileOutputStream(encKeyFile)){
			
			Cipher ci = Cipher.getInstance("RSA/ECB/PKCS1Padding");
			ci.init(Cipher.ENCRYPT_MODE, pub);
			
			byte[] ibuf = new byte[1024];
			int len;
			while((len = in.read(ibuf)) != -1){
				byte[] obuf = ci.update(ibuf, 0, len);
				if(obuf != null) 
					out.write(obuf);
			}
			byte[] obuf = ci.doFinal();
			if(obuf != null) 
				out.write(obuf);
			
			in.close();
			out.close();
		}
		catch(Exception e){
			System.out.println("Exception Thrown " + e.toString());
		}
	}


	/**
	 * Decrypts an encrypted secret key file using a private Key (*.der)
	 * and writes the decrypted secret key to a file
	 *
	 * @param  encKeyFile       name of file storing encrypted secret key
	 * @param  privKeyFile      name of private key file for decryption
	 * @param  secKeyFile       name of file to write decrypted secret key
	 */
	static void decryptKey(String encKeyFile, String privKeyFile, String secKeyFile) {
		PrivateKey pvt = null;
		try{
			byte[] bytes = Files.readAllBytes(Paths.get(privKeyFile));
			PKCS8EncodedKeySpec ks = new PKCS8EncodedKeySpec(bytes);
			KeyFactory kf = KeyFactory.getInstance("RSA");
			pvt = kf.generatePrivate(ks);
		}
		catch(Exception e){
			System.out.println("Exception Thrown");
			System.exit(0);
		}

		try(FileInputStream in = new FileInputStream(encKeyFile);
			FileOutputStream out = new FileOutputStream(secKeyFile)){
			
			Cipher ci = Cipher.getInstance("RSA/ECB/PKCS1Padding");
			ci.init(Cipher.DECRYPT_MODE, pvt);
			
			byte[] ibuf = new byte[1024];
			int len;
			while((len = in.read(ibuf)) != -1){
				byte[] obuf = ci.update(ibuf, 0, len);
				if(obuf != null)
					out.write(obuf);
			}
			byte[] obuf = ci.doFinal();
			if(obuf != null)
				out.write(obuf);
			
			in.close();
			out.close();
		}
		catch(Exception e){
			System.out.println("Exception Thrown " + e.toString());
		}
	}


	/**
	 * Main Program Runner
	 */
	public static void main(String[] args) throws Exception{

		String func;

		if(args.length < 1) {
			func = "";
		} else {
			func = args[0];
		}

		switch(func)
		{
			case "generatekey":
				if(args.length != 2) {
					System.out.println("Invalid Arguments.");
					System.out.println("Usage: Cryptr generatekey <key output file>");
					break;
				}
				System.out.println("Generating secret key and writing it to " + args[1]);
				generateKey(args[1]);
				break;
			case "encryptfile":
				if(args.length != 4) {
					System.out.println("Invalid Arguments.");
					System.out.println("Usage: Cryptr encryptfile <file to encrypt> <secret key file> <encrypted output file>");
					break;
				}
				System.out.println("Encrypting " + args[1] + " with key " + args[2] + " to "  + args[3]);
				encryptFile(args[1], args[2], args[3]);
				break;
			case "decryptfile":
				if(args.length != 4) {
					System.out.println("Invalid Arguments.");
					System.out.println("Usage: Cryptr decryptfile <file to decrypt> <secret key file> <decrypted output file>");
					break;
				}
				System.out.println("Decrypting " + args[1] + " with key " + args[2] + " to " + args[3]);
				decryptFile(args[1], args[2], args[3]);
				break;
			case "encryptkey":
				if(args.length != 4) {
					System.out.println("Invalid Arguments.");
					System.out.println("Usage: Cryptr encryptkey <key to encrypt> <public key to encrypt with> <encrypted key file>");
					break;
				}
				System.out.println("Encrypting key file " + args[1] + " with public key file " + args[2] + " to " + args[3]);
				encryptKey(args[1], args[2], args[3]);
				break;
			case "decryptkey":
				if(args.length != 4) {
					System.out.println("Invalid Arguments.");
					System.out.println("Usage: Cryptr decryptkey <key to decrypt> <private key to decrypt with> <decrypted key file>");
					break;
				}
				System.out.println("Decrypting key file " + args[1] + " with private key file " + args[2] + " to " + args[3]);
				decryptKey(args[1], args[2], args[3]);
				break;
			default:
				System.out.println("Invalid Arguments.");
				System.out.println("Usage:");
				System.out.println("  Cryptr generatekey <key output file>");
				System.out.println("  Cryptr encryptfile <file to encrypt> <secret key file> <encrypted output file>");
				System.out.println("  Cryptr decryptfile <file to decrypt> <secret key file> <decrypted output file>");
				System.out.println("  Cryptr encryptkey <key to encrypt> <public key to encrypt with> <encrypted key file> ");
				System.out.println("  Cryptr decryptkey <key to decrypt> <private key to decrypt with> <decrypted key file>");
		}

		System.exit(0);

	}

}