Changeset 1202 for trunk/src/org/expeditee/auth/EncryptedExpReader.java

Timestamp:

01/30/19 12:49:25 (5 years ago)

Author:

bln4

Message:

Initial commit of functionality concerning multiuser login, further to come.

Actions.java -> Actions that allow users to authenticate and secure their accounts.
AuthenticationTag.java -> Enum like structure for text fields associated with authentication.
Authenticator.java -> Startup functionality for when Expeditee is run in authentication mode.
EncryptedExpReader.java -> Reads exp files previously encrypted with EncryptedExpWriter (not currently used) and EncryptedProfileExpWriter
Mail.java -> Functions for transforming database stored messages into datastructures used to display those messages to the MailBay.

File:

• trunk/src/org/expeditee/auth/EncryptedExpReader.java (copied) (copied from trunk/src/org/expeditee/auth/io/EncryptedExpReader.java ) (5 diffs)

trunk/src/org/expeditee/auth/EncryptedExpReader.java

@@ -1 @@
-package org.expeditee.auth.io;
+package org.expeditee.auth;
 
 import java.io.BufferedReader;
 import java.io.FileInputStream;
+import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -19 +20 @@
 import javax.crypto.NoSuchPaddingException;
 import javax.crypto.SecretKey;
-
-import org.expeditee.auth.Authenticator;
+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;
@@ -28 +31 @@
 public class EncryptedExpReader extends ExpReader implements CryptographyConstants {
         static final String ENCRYPTED_EXP_FLAG = "EncryptedExp";
-        private List<SecretKey> keys;
-        
-        public EncryptedExpReader(final String frameName) throws UnsupportedEncodingException {
+        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;
         }
         
@@ -41 +48 @@
         }
         
+        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");
-                return readFrame(new EncryptedLineReader(new BufferedReader(in)));
-        }
-        
-        public class EncryptedLineReader extends BufferedReader {
-
-                public EncryptedLineReader(final Reader in) {
-                        super(in);
-                }
-                                                                  
-                @Override
-                public String readLine() throws IOException {
-                        final String line = super.readLine();   
-                        if (line.isEmpty()) { return ""; }
-                        if (line.startsWith(ENCRYPTED_EXP_FLAG)) {
-                                try {
-                                        // resolve labels to secret keys
-                                        final List<String> labels = Arrays.asList(line.split(" ")).stream().skip(1).collect(Collectors.toList());
-                                        final Authenticator auth = new Authenticator();
-                                        final ThrowingFunction<String, SecretKey, Exception> worker = new ThrowingFunction<String, SecretKey, Exception>() {
-                                                @Override
-                                                public SecretKey applyThrows(final String label) throws Exception {
-                                                        return auth.getSecretKey(label, System.getProperty("password"));
-                                                }
-                                        };
-                                        keys = labels.stream().map(worker).collect(Collectors.toList());
-                                        return readLine();
-                                } catch (final Exception e) {
-                                        return "";
-                                }
-                        }
-                        
-                        if (keys == null) {
-                                // We do not have permission to view this frame.
-                                return "";
-                        }
-                        
-                        // use keys to decrypt
-                        byte[] toDecrypt = Base64.getDecoder().decode(line);
-                        for (final SecretKey key: keys) {
-                                toDecrypt = DecryptSymmetric(toDecrypt, key);
-                        }
-                        final String result = new String(toDecrypt);
-                        if (result.startsWith("Z")) { return result.trim(); }
-                        else { return result; }
-                }               
+                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);
         }
         
@@ -111 +110 @@
                 }
         }
+        
+        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; }
+                }
+        }
 }