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

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 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.io.ExpReader;
import org.expeditee.items.Text;
import org.expeditee.settings.identity.secrets.KeyList;

public class EncryptedExpReader extends ExpReader implements CryptographyConstants {
        static final String ENCRYPTED_EXP_FLAG = "EncryptedExp";
        private SecretKey personalKey;
        private boolean accessDenied = false;

        public EncryptedExpReader(final String frameName) throws UnsupportedEncodingException {
                super(frameName);
        }
        
        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 = 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 {
                Reader in = new InputStreamReader(new FileInputStream(fullPath), "UTF-8");
                return readFrame(new EncryptedLineReader(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 EncryptedLineReader extends BufferedReader {
                public EncryptedLineReader(Reader in) {
                        super(in);
                }
                
                @Override
                /**
                 * Reads a line from an encrypted exp file that uses an encryption specified by the first line of the file.
                 * Returns that line to process, null if the currently logged in users doesn't own the appropriate key (access denied).
                 */
                public String readLine() throws IOException {
                        String line = super.readLine();
                        
                        if (line.isEmpty()) {
                                return "";
                        }
                        if (line.startsWith(ENCRYPTED_EXP_FLAG)) {
                                String label = line.replace(ENCRYPTED_EXP_FLAG, "");
                                // if using Profile label, use personal key
                                if (label.startsWith("Profile")) {
                                        Text text = KeyList.PersonalKey.get();
                                        byte[] keyBytes = Base64.getDecoder().decode(text.getData().get(0));
                                        personalKey = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
                                        return readLine();
                                } else {
                                        personalKey = resolveLabel(label);
                                        if (personalKey == null) {
                                                return null;
                                        } else {
                                                return readLine();
                                        }
                                }
                        }
                        
                        // decrypt line and return result
                        byte[] toDecrypt = Base64.getDecoder().decode(line);
                        byte[] decrypted = DecryptSymmetric(toDecrypt, personalKey);
                        if (decrypted == null) {
                                accessDenied = true;
                                return null; // access denied
                        } else {
                                String decryptedLine = new String(decrypted);
                                if (decryptedLine.startsWith("Z")) { 
                                        return decryptedLine.trim();
                                } else { 
                                        return decryptedLine;
                                }
                        }
                }
                
                private SecretKeySpec resolveLabel(String label) {
                        byte[] keyBytes = EncryptedExpWriter.resolveKeyFromLabel(label, "");
                        return new SecretKeySpec(keyBytes, SymmetricAlgorithm);
                }
        }
}