source: trunk/src/org/expeditee/auth/io/EncryptedExpWriter.java@ 1200

package org.expeditee.auth.io;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableEntryException;
import java.security.cert.CertificateException;
import java.util.Arrays;
import java.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.expeditee.auth.Authenticator;
import org.expeditee.io.ExpWriter;
import org.expeditee.settings.UserSettings;
import org.ngikm.cryptography.CryptographyConstants;

public class EncryptedExpWriter extends ExpWriter implements CryptographyConstants {
        private SecretKey key;
        private static final String nl = "\n";
        
        public EncryptedExpWriter() throws IOException {
                try {
                        final Authenticator auth = new Authenticator();
                        SecretKey key = auth.getSecretKey(UserSettings.UserName.get(), System.getProperty("password"));
                        if (key == null) {
                                final byte[] keyBytes = pad(UserSettings.UserName.get().getBytes("UTF-8"));
                                key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
                                auth.putKey(UserSettings.UserName.get(), System.getProperty("password"), key);
                        }
                        this.key = key;                 
                } catch (final KeyStoreException | NoSuchAlgorithmException | CertificateException | IOException | UnrecoverableEntryException e) {
                        e.printStackTrace();
                }
                
        }

        @Override
        protected void preOutputFrame() {
                try {
                        final String line = EncryptedExpReader.ENCRYPTED_EXP_FLAG + " " + UserSettings.UserName.get() + nl;
                        _writer.write(line);
                        _stringWriter.append(line);
                } catch (final IOException e) { 
                        e.printStackTrace();
                }
        }
        
        @Override
        protected void writeLine(String line) throws IOException {
                // do not write empty lines
                if (line == null) { return; }
                
                // prepare line to write out
                final byte[] encrypted = EncryptSymmetric(line.getBytes(), key);
                final String toWrite = Base64.getEncoder().encodeToString(encrypted) + nl;
                
                // output
                _writer.write(toWrite);
                _stringWriter.append(toWrite);
        }
        
        private byte[] pad(final byte[] bytes) {
                int c = 16;
                while (c - bytes.length < 0) { c *= 2; }
                return Arrays.copyOf(bytes, c);
        }
        
        private static byte[] EncryptSymmetric(final byte[] toEncrypt, final SecretKey key) {
                // toEncrypt = Base64.getDecoder().decode(toEncrypt);
                try {
                        final Cipher cipher = Cipher.getInstance(SymmetricAlgorithm + SymmetricAlgorithmParameters);
                        cipher.init(Cipher.ENCRYPT_MODE, key);
                        //could use modulus
                        final int length = (int) ((Math.ceil(toEncrypt.length / 16f)) * 16);
                        final byte[] toEncryptSizeAdjusted = Arrays.copyOf(toEncrypt, length);
                        //System.err.println("(" + toEncryptSizeAdjusted.length + ")" + "Before Encryption Data: "
                        //              + Arrays.toString(toEncryptSizeAdjusted));
                        final byte[] result = cipher.doFinal(toEncryptSizeAdjusted);
                        //System.err.println("(" + result.length + ")" + "Encrypted Data: " + Arrays.toString(result));
                        return result;
                } catch (final NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException
                                | IllegalBlockSizeException | BadPaddingException e) {
                        e.printStackTrace();
                        return null;
                }
        }
}