source: trunk/src/org/expeditee/auth/EncryptedExpReader.java@ 1202

package org.expeditee.auth;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import java.util.stream.Collectors;

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.gui.Frame;
import org.expeditee.io.ExpReader;
import org.expeditee.items.Text;
import org.expeditee.settings.auth.secrets.KeyList;
import org.ngikm.Util.ThrowingFunction;
import org.ngikm.cryptography.CryptographyConstants;

public class EncryptedExpReader extends ExpReader implements CryptographyConstants {
        static final String ENCRYPTED_EXP_FLAG = "EncryptedExp";
        private SecretKey personalKey;
        private List<SecretKey> multiKey;
        private boolean accessDenied = false;
        private boolean usePersonalKey;
        
        public EncryptedExpReader(final String frameName, final boolean usePersonalKey) throws UnsupportedEncodingException {
                super(frameName);
                this.usePersonalKey = usePersonalKey;
        }
        
        public static boolean isEncryptedExpediteeFile(final String path) throws IOException {
                final BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(path), "UTF-8"));
                final String firstLine = in.readLine();
                in.close();
                return firstLine.startsWith(ENCRYPTED_EXP_FLAG);
        }
        
        public int getVersionEnc(String fullpath) {
                try {
                        BufferedReader reader;
                        if (usePersonalKey) {
                                reader = new EncryptedProfileLineReader(new BufferedReader(new FileReader(fullpath)));
                        } else {
                                reader = new EncryptedLineReader(new BufferedReader(new FileReader(fullpath)));
                        }
                        String next = "";
                        // First read the header lines until we get the version number
                        while (reader.ready() && !(next = reader.readLine()).equals("Z")) {
                                if (isValidLine(next)) {
                                        Character tag = getTag(next);
                                        String value = getValue(next);
                                        if (tag.equals('V')) {
                                                reader.close();
                                                return Integer.parseInt(value);
                                        }
                                }
                        }
                        reader.close();
                } catch (Exception e) {
                }
                return -1;
        }
        
        @Override
        public Frame readFrame(final String fullPath) throws IOException {
                final Reader in = new InputStreamReader(new FileInputStream(fullPath), "UTF-8");
                if (usePersonalKey) {
                        return readFrame(new EncryptedProfileLineReader(new BufferedReader(in)));
                } else {
                        return readFrame(new EncryptedLineReader(new BufferedReader(in)));
                }
        }
        
        @Override
        public Frame readFrame(final BufferedReader reader) throws IOException {
                if (accessDenied) { return null; }
                else return super.readFrame(reader);
        }
        
        private static byte[] DecryptSymmetric(final byte[] toDecrypt, final SecretKey key) {
                try {
                        final Cipher cipher = Cipher.getInstance(SymmetricAlgorithm + SymmetricAlgorithmParameters);
                        cipher.init(Cipher.DECRYPT_MODE, key);
                        final byte[] decryptedBytes = cipher.doFinal(toDecrypt);
                        int indexOfZero = decryptedBytes.length - 1;
                        for (int i = decryptedBytes.length - 1; i >= 0; i--) {
                                if (decryptedBytes[i] != (byte) 0) {
                                        indexOfZero = i + 1;
                                        break;
                                }
                        }
                        if (indexOfZero < 0) { return decryptedBytes; }
                        else { return Arrays.copyOf(decryptedBytes, indexOfZero); }
                } catch (final NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException
                                | IllegalBlockSizeException | BadPaddingException e) {
                        e.printStackTrace();
                        return null;
                }
        }
        
        private class EncryptedProfileLineReader extends BufferedReader {

                public EncryptedProfileLineReader(final Reader in) {
                        super(in);
                }
                
                @Override
                /**
                 * Reads a line from an encrypted exp file that uses profile encryption (single key; personal key)
                 * Returns that line to process, null if the currently logged in users personal key is not the appropriate one (access denied).
                 */
                public String readLine() throws IOException {
                        // read encrypted line
                        final String line = super.readLine();
                        
                        if (line.isEmpty()) { return ""; }
                        if (line.startsWith(ENCRYPTED_EXP_FLAG)) {
                                // record/overwrite previous personal key then ignore this line by recursing
                                final Text text = KeyList.PersonalKey.get();
                                final byte[] keyBytes = Base64.getDecoder().decode(text.getData().get(0));
                                personalKey = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
                                return readLine();
                        }
                        
                        // decrypt line and return result
                        final byte[] toDecrypt = Base64.getDecoder().decode(line);
                        final byte[] decrypted = DecryptSymmetric(toDecrypt, personalKey);
                        if (decrypted == null) {
                                accessDenied = true;
                                return null; // access denied
                        } else {
                                final String decryptedLine = new String(decrypted);
                                if (decryptedLine.startsWith("Z")) { return decryptedLine.trim(); }
                                else { return decryptedLine; }
                        }
                }       
        }
        
        private class EncryptedLineReader extends BufferedReader {
                
                public EncryptedLineReader(final Reader in) {
                        super(in);
                }
                
                @Override
                /**
                 * Reads a line from an encrypted exp file that uses (potentially multiple) labeled keys
                 * Returns that line to process, null if the ...
                 */
                public String readLine() throws IOException {
                        // read encrypted line
                        final String line = super.readLine();
                        
                        if (line.isEmpty()) { return ""; }
                        if (line.startsWith(ENCRYPTED_EXP_FLAG)) {
                                // resolve labels to secret keys
                                final List<String> labels = Arrays.asList(line.split(" ")).stream().skip(1).collect(Collectors.toList());
                                final ThrowingFunction<String, SecretKey, Exception> worker = new ThrowingFunction<String, SecretKey, Exception>() {
                                        @Override
                                        public SecretKey applyThrows(final String label) throws Exception {
                                                return Authenticator.getInstance().getSecretKey(label, System.getProperty("password"));
                                        }
                                };
                                multiKey = labels.stream().map(l -> {
                                        try {
                                                return worker.apply(l);
                                        } catch (final Exception e) {
                                                return null;
                                        }
                                }).collect(Collectors.toList());
                                
                                // confirm you have all the keys necessary for decryption
                                if (multiKey.contains(null)) {
                                        return null;
                                }
                                
                                // move onto the next line
                                return readLine();
                        }
                        
                        // decrypt line and return result
                        final byte[] toDecrypt = Base64.getDecoder().decode(line);
                        byte[] decryptedBytes = null;
                        for (final SecretKey key: multiKey) {
                                decryptedBytes = DecryptSymmetric(toDecrypt, key);
                                if (decryptedBytes == null) { return null; }
                        }
                        final String decrypted = new String(decryptedBytes);
                        if (decrypted.startsWith("Z")) { return decrypted.trim(); }
                        else { return decrypted; }
                }
        }
}