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

package org.expeditee.auth;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import java.util.Collection;
import java.util.List;

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.encryption.CryptographyConstants;
import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameIO;
import org.expeditee.gui.MessageBay;
import org.expeditee.io.ExpWriter;
import org.expeditee.items.Text;
import org.expeditee.settings.UserSettings;
import org.expeditee.settings.identity.secrets.KeyList;

public class EncryptedExpWriter extends ExpWriter implements CryptographyConstants {
        private SecretKey key;
        private String label;
        private static final String nl = "\n";
        
        public EncryptedExpWriter(String encryptionLabel) throws IOException {
                if (encryptionLabel.compareTo("Profile") == 0) {
                        // obtain personal key
                        Text text = KeyList.PersonalKey.get();
                        List<String> data = text.getData();
                        if (data != null && !data.isEmpty()) {
                                byte[] keyBytes = Base64.getDecoder().decode(data.get(0));
                                key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
                        }
                        label = "Profile";
                } else {
                        byte[] keyBytes = resolveKeyFromLabel(encryptionLabel, _framename);
                        key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
                        label = encryptionLabel;
                }
        }

        @Override
        protected void preOutputFrame() {
                try {
                        String line = EncryptedExpReader.ENCRYPTED_EXP_FLAG + label + 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
                byte[] encrypted = EncryptSymmetric(line.getBytes(), key);
                String toWrite = Base64.getEncoder().encodeToString(encrypted) + nl;
                
                // output
                _writer.write(toWrite);
                _stringWriter.append(toWrite);
        }
        
        protected static byte[] resolveKeyFromLabel(String label, String framename) {
                String credentialsFrameName = UserSettings.ProfileName.get() + AuthenticatorBrowser.CREDENTIALS_FRAME;
                Frame credentialsFrame = FrameIO.LoadFrame(credentialsFrameName);
                Collection<Text> textItems = credentialsFrame.getTextItems();
                textItems.removeIf(t -> !t.getText().equals("Secrets"));
                textItems.removeIf(t -> !t.hasLink());
                if (textItems.isEmpty()) {
                        MessageBay.errorMessage("Unable to find label " + label + " to encrypt frame " + framename + ".");
                        return null;
                } else {
                        Text linkToSecretsFrame = textItems.iterator().next();
                        Frame secretsFrame = FrameIO.LoadFrame(linkToSecretsFrame.getParent().getFramesetName() + linkToSecretsFrame.getLink());
                        Collection<Text> labels = secretsFrame.getTextItems();
                        labels.removeIf(lbl -> !lbl.getText().equals(label));
                        labels.removeIf(lbl -> lbl.getData() == null || lbl.getData().size() == 0);
                        if (labels.isEmpty()) {
                                MessageBay.errorMessage("Unable to find label " + label + " to encrypt frame " + framename + ".");
                                return null;
                        }
                        
                        Text labelItem = labels.iterator().next();
                        String data = labelItem.getData().get(0);
                        if (data.contains("{")) {
                                MessageBay.errorMessage("You only have a fraction of the required key to access " + framename + ".");
                                return null;
                        } else {
                                try {
                                        return Base64.getDecoder().decode(data);
                                } catch (IllegalArgumentException e) {
                                        MessageBay.errorMessage("Unable to create key out of data stored in label " + label + ".");
                                        return null;
                                }
                        }
                }
        }
        
        private static byte[] EncryptSymmetric(byte[] toEncrypt, SecretKey key) {
                try {
                        Cipher cipher = Cipher.getInstance(SymmetricAlgorithm + SymmetricAlgorithmParameters);
                        cipher.init(Cipher.ENCRYPT_MODE, key);
                        //could use modulus
                        int length = (int) ((Math.ceil(toEncrypt.length / 16f)) * 16);
                        byte[] toEncryptSizeAdjusted = Arrays.copyOf(toEncrypt, length);
                        byte[] result = cipher.doFinal(toEncryptSizeAdjusted);
                        return result;
                } catch (final NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException
                                | IllegalBlockSizeException | BadPaddingException e) {
                        e.printStackTrace();
                        return null;
                }
        }
}