Changeset 1202 for trunk/src/org/expeditee/auth/Authenticator.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/Authenticator.java (modified) (2 diffs)

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

@@ -5 +5 @@
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
+import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.Writer;
+import java.security.KeyFactory;
 import java.security.KeyStore;
 import java.security.KeyStore.SecretKeyEntry;
 import java.security.KeyStoreException;
 import java.security.NoSuchAlgorithmException;
+import java.security.PublicKey;
+import java.security.SecureRandom;
 import java.security.UnrecoverableEntryException;
 import java.security.cert.CertificateException;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.X509EncodedKeySpec;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Stream;
 
 import javax.crypto.SecretKey;
-
+import javax.crypto.spec.SecretKeySpec;
+
+import org.expeditee.actions.Actions;
+import org.expeditee.core.Dimension;
+import org.expeditee.core.Point;
+import org.expeditee.gio.EcosystemManager;
+import org.expeditee.gio.GraphicsManager;
+import org.expeditee.gio.InputManager;
+import org.expeditee.gio.InputManager.WindowEventListener;
+import org.expeditee.gio.InputManager.WindowEventType;
+import org.expeditee.gio.gesture.StandardGestureActions;
+import org.expeditee.gui.Browser;
+import org.expeditee.gui.DisplayController;
+import org.expeditee.gui.Frame;
 import org.expeditee.gui.FrameIO;
+import org.expeditee.gui.FrameUtils;
+import org.expeditee.gui.MessageBay;
+import org.expeditee.items.ItemUtils;
+import org.expeditee.items.Text;
+import org.expeditee.settings.Settings;
+import org.expeditee.settings.UserSettings;
+import org.expeditee.settings.auth.secrets.KeyList;
 import org.ngikm.cryptography.CryptographyConstants;
 
 public final class Authenticator implements CryptographyConstants {
-        final KeyStore keyStore = KeyStore.getInstance(KeystoreType);
-        private static final String keystoreFileName = FrameIO.PARENT_FOLDER + "keystore.ks" + File.separator;
-        
-        public Authenticator() throws KeyStoreException, FileNotFoundException, IOException, NoSuchAlgorithmException, CertificateException {
-                final File keyStoreFile = new File(keystoreFileName);
+        
+        // The frame number of the frame containing the current authenticated users public key.
+        public static final int PUBLIC_KEY_FRAME = 4;
+        
+        private final KeyStore keyStore = KeyStore.getInstance(KeystoreType);
+        private static final byte[] TRUE = "yes".getBytes();
+        private static final byte[] FALSE = "no".getBytes();
+        private static final String KEYSTOREFILENAME = "keystore.ks" + File.separator;
+        
+        private static Authenticator instance;
+        
+        public static Authenticator getInstance() throws KeyStoreException, FileNotFoundException, NoSuchAlgorithmException, CertificateException, IOException, ClassNotFoundException, SQLException {
+                if (instance == null) { instance = new Authenticator(); } 
+                return instance;
+        }
+        
+        private Authenticator() throws KeyStoreException, FileNotFoundException, IOException, NoSuchAlgorithmException, CertificateException, ClassNotFoundException, SQLException {
+                UserSettings.setupDefaultFolders();
+                
+                // initialise keystore and actions
+                loadKeystore();
+                Actions.LoadMethods(org.expeditee.auth.Actions.class);
+
+                // draw the window
+                final GraphicsManager g = EcosystemManager.getGraphicsManager();
+                g.setWindowLocation(new Point(50, 50));
+                DisplayController.Init();
+                g.setWindowSize(new Dimension(UserSettings.InitialWidth.get(), UserSettings.InitialHeight.get()));
+                setInputManagerWindowRoutines();
+                
+                // Load documentation and start pages
+                FrameUtils.extractResources(false);
+
+                // Load fonts before loading any frames so the items on the frames will be able to access their fonts
+                Text.InitFonts();
+                
+                // initialing settings does not require a user profile established
+                Settings.Init();
+                
+                // navigate to authentication frame
+                final Frame authFrame = FrameIO.LoadFrame("authentication1");
+                DisplayController.setCurrentFrame(authFrame, true);
+                
+                // set initial values
+                final Stream<Text> usernameItemsStream = authFrame.getTextItems().stream().filter(t -> t.getData() != null && t.getData().contains("txtUsername"));
+                final Stream<Text> passwordItemsStream = authFrame.getTextItems().stream().filter(t -> t.getData() != null && t.getData().contains("txtPassword"));
+                usernameItemsStream.forEach(txtUsername -> txtUsername.setText(System.getProperty("user.name", "")));
+                passwordItemsStream.forEach(txtPassword -> txtPassword.setText(System.getProperty("user.password", "")));
+                                                
+                MessageBay.warningMessages(org.expeditee.actions.Actions.Init());
+                
+                // ensure database
+                Class.forName("org.sqlite.JDBC");
+                if (!mailDatabaseExists()) { 
+                        createMailDatabase();
+                }
+        }
+        
+        private void createMailDatabase() throws ClassNotFoundException, SQLException {
+                Connection c = DriverManager.getConnection("jdbc:sqlite:" + FrameIO.PARENT_FOLDER + "/expmail.db");
+                Statement createTable = c.createStatement();
+                String sql = "CREATE TABLE EXPMAIL (" + 
+                                "SND            TEXT                                    NOT NULL, " + 
+                                "REC            TEXT                                    NOT NULL, " + 
+                                "MSG            TEXT                                    NOT NULL, " +
+                                "MSG2           TEXT                                    NOT NULL, " + 
+                                "OPTS           ARRAY                                   NOT NULL, " +
+                                "OPTSVAL        ARRAY                                   NOT NULL)";
+                createTable.executeUpdate(sql);
+                createTable.close();
+                c.close();
+        }
+        
+        final void loadMailDatabase() throws SQLException {
+                Connection c = DriverManager.getConnection("jdbc:sqlite:" + FrameIO.PARENT_FOLDER + "/expmail.db");
+                Statement query = c.createStatement();
+                ResultSet results = query.executeQuery("SELECT * FROM EXPMAIL");
+                Mail.clear();
+                while (results.next()) {
+                        String from = results.getString("snd");
+                        String to = results.getString("rec");
+                        String msg = results.getString("msg");
+                        String msg2 = results.getString("msg2");
+                        String[] opts = results.getString("opts").split(",");
+                        opts[0] = opts[0].replace("[", "");
+                        opts[opts.length - 1] = opts[opts.length - 1].replace("]", "");
+                        String[] optsVal = results.getString("optsval").split(",");
+                        optsVal[0] = optsVal[0].replace("[", "");
+                        optsVal[optsVal.length - 1] = optsVal[optsVal.length - 1].replace("]", "");
+                        
+                        Map<String, String> options = new HashMap<String, String>();
+                        for (int i = 0, o = 0; i < opts.length && o < optsVal.length; i++, o++) {
+                                String key = opts[i].trim();
+                                String val = optsVal[o].trim();
+                                options.put(key, val);
+                        }
+                        
+                        Mail.addEntry(new Mail.MailEntry(from, to, msg, msg2, options));
+                }
+                results.close();
+                query.close();
+                c.close();
+        }
+        
+        private boolean mailDatabaseExists() {
+                final File file = new File(FrameIO.PARENT_FOLDER + "/expmail.db");
+                return file.exists();
+        }
+                
+        private void loadKeystore()
+                        throws IOException, NoSuchAlgorithmException, CertificateException, FileNotFoundException {
+                final File keyStoreFile = new File(FrameIO.PARENT_FOLDER + KEYSTOREFILENAME);
                 if (!keyStoreFile.exists()) { 
                         keyStore.load(null, "ExpediteeAuthPassword".toCharArray());
                 } else {
-                        try (final InputStream in = new FileInputStream(keystoreFileName)) {
+                        try (final InputStream in = new FileInputStream(FrameIO.PARENT_FOLDER + KEYSTOREFILENAME)) {
                                 keyStore.load(in, "ExpediteeAuthPassword".toCharArray());
                         }
@@ -34 +179 @@
         }
         
-        public final SecretKey getSecretKey(final String label, final String password) throws NoSuchAlgorithmException, UnrecoverableEntryException, KeyStoreException {                
+        final SecretKey getSecretKey(final String label, final String password) throws NoSuchAlgorithmException, KeyStoreException {            
                 final KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(password.toCharArray());
-                final KeyStore.SecretKeyEntry entry = (SecretKeyEntry) keyStore.getEntry(label, entryPassword);
+                KeyStore.SecretKeyEntry entry = null;
+                try {
+                        entry = (SecretKeyEntry) keyStore.getEntry(label, entryPassword);
+                } catch (final UnrecoverableEntryException e) {
+                        entry = null;
+                }
                 if (entry == null) { return null; }
                 else { return entry.getSecretKey(); }
         }
         
-        public final void putKey(final String label, final String password, final SecretKey key) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException {
+        final void putKey(final String label, final String password, final SecretKey key) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException {
                 final KeyStore.SecretKeyEntry entry = new KeyStore.SecretKeyEntry(key);
                 final KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(password.toCharArray());
                 keyStore.setEntry(label, entry, entryPassword);
-                keyStore.store(new FileOutputStream(keystoreFileName), "ExpediteeAuthPassword".toCharArray());
+                keyStore.store(new FileOutputStream(FrameIO.PARENT_FOLDER + KEYSTOREFILENAME), "ExpediteeAuthPassword".toCharArray());
+        }
+        
+        final void putEmail(String username, String email) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException {
+                // Establish location of email file
+                String emailFilePath = FrameIO.PROFILE_PATH + username + File.separator + username + ".email";
+                File emailFile = new File(emailFilePath);
+                
+                // Delete old version if it exists.
+                if (emailFile.exists()) { 
+                        emailFile.delete();
+                }
+                
+                // Write email to file
+                emailFile.createNewFile();
+                Writer w = new FileWriter(emailFile);
+                w.write(email);
+                w.flush();
+                w.close();
+                
+                // TODO: set rights on file to be read only by 'owner' once installed on drive.
+        }
+        
+        final boolean hasRegisteredEmail(String username) throws KeyStoreException {
+                String emailFilePath = FrameIO.PROFILE_PATH + username + File.separator + username + ".email";
+                File emailFile = new File(emailFilePath);
+                return emailFile.exists();
+        }
+        
+        final boolean confirmIntergalaticNumber(final String username, final String email, final String intergalacticNumber) throws NoSuchAlgorithmException, KeyStoreException, CertificateException, FileNotFoundException, IOException {
+                try {
+                        final KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(intergalacticNumber.toCharArray());
+                        final KeyStore.SecretKeyEntry entry = (SecretKeyEntry) keyStore.getEntry(email + username, entryPassword);
+                        if (entry == null) { 
+                                return false;
+                        } else if (entry.getSecretKey().getEncoded() == TRUE) {
+                                keyStore.deleteEntry(email + username);
+                                keyStore.store(new FileOutputStream(FrameIO.PARENT_FOLDER + KEYSTOREFILENAME), "ExpediteeAuthPassword".toCharArray());
+                                return true;
+                        } else { return false; }
+                } catch (final UnrecoverableEntryException e) {
+                        return false;
+                }
+        }
+        
+        final String newIntergalacticNumber(final String username, final String email) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException {
+                // generate intergalactic number
+                final SecureRandom rand = new SecureRandom();
+                final byte[] intergalacticNumberBytes = new byte[20];
+                rand.nextBytes(intergalacticNumberBytes);
+                final String intergalacticNumber = Base64.getEncoder().encodeToString(intergalacticNumberBytes);
+                
+                // store intergalactic number
+                final KeyStore.SecretKeyEntry entry = new KeyStore.SecretKeyEntry(new SecretKeySpec(TRUE, SymmetricAlgorithm));
+                final KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(intergalacticNumber.toCharArray());
+                keyStore.setEntry(email + username, entry, entryPassword);
+                keyStore.store(new FileOutputStream(FrameIO.PARENT_FOLDER + KEYSTOREFILENAME), "ExpediteeAuthPassword".toCharArray());
+                
+                return intergalacticNumber;
+        }
+        
+        final PublicKey getPublicKey(String username) throws InvalidKeySpecException, NoSuchAlgorithmException {
+                Frame withTargetPublic = FrameIO.LoadFrame(username + Authenticator.PUBLIC_KEY_FRAME);
+                Collection<Text> textItems = withTargetPublic.getTextItems(); 
+                textItems.removeIf(t -> !t.getText().startsWith("PublicKey"));
+                
+                if (textItems.isEmpty()) {
+                        return null;
+                } else {
+                        String keyEncoded = textItems.stream().findFirst().get().getData().get(0);
+                        byte[] keyBytes = Base64.getDecoder().decode(keyEncoded);
+                        PublicKey key = KeyFactory.getInstance(AsymmetricAlgorithm).generatePublic(new X509EncodedKeySpec(keyBytes));
+                        return key;
+                }
+        }
+        
+        final void markRequestedColleagues(String username) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException {
+                KeyStore.SecretKeyEntry entry = new KeyStore.SecretKeyEntry(new SecretKeySpec(TRUE, SymmetricAlgorithm));
+                KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(KeyList.PersonalKey.get().getText().toCharArray());
+                keyStore.setEntry(username + "colleaguesRequested", entry, entryPassword);
+                keyStore.store(new FileOutputStream(FrameIO.PARENT_FOLDER + KEYSTOREFILENAME), "ExpediteeAuthPassword".toCharArray());
+        }
+        
+        final void clearRequestedColleagues(String username) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, FileNotFoundException, IOException {
+                KeyStore.SecretKeyEntry entry = new KeyStore.SecretKeyEntry(new SecretKeySpec(FALSE, SymmetricAlgorithm));
+                KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(KeyList.PersonalKey.get().getText().toCharArray());
+                keyStore.setEntry(username + "colleaguesRequested", entry, entryPassword);
+                keyStore.store(new FileOutputStream(FrameIO.PARENT_FOLDER + KEYSTOREFILENAME), "ExpediteeAuthPassword".toCharArray());
+        }
+        
+        final boolean hasRequestedColleagues(String username) throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableEntryException {
+                String alias = username + "colleaguesRequested";
+                if (!keyStore.containsAlias(alias)) {
+                        return false;
+                } else {
+                        KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(KeyList.PersonalKey.get().getText().toCharArray());
+                        KeyStore.SecretKeyEntry entry = (SecretKeyEntry) keyStore.getEntry(alias, entryPassword);
+                        return Arrays.equals(entry.getSecretKey().getEncoded(), TRUE);
+                }
+        }
+        
+        final void putColleagues(String username, String[] colleagues) throws KeyStoreException {
+                String alias = username + "colleagues";
+                final SecretKeySpec secretKeySpec = new SecretKeySpec((colleagues[0] + System.getProperty("line.separator") + colleagues[1]).getBytes(), SymmetricAlgorithm);
+                KeyStore.SecretKeyEntry entry = new KeyStore.SecretKeyEntry(secretKeySpec);
+                KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(KeyList.PersonalKey.get().getText().toCharArray());
+                keyStore.setEntry(alias, entry, entryPassword);
+        }
+        
+        final String[] getColleagues(String username) throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableEntryException {
+                String alias = username + "colleagues";
+                if (!keyStore.containsAlias(alias)) {
+                        return null;
+                } else {
+                        KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(KeyList.PersonalKey.get().getText().toCharArray());
+                        KeyStore.SecretKeyEntry entry = (SecretKeyEntry) keyStore.getEntry(alias, entryPassword);
+                        byte[] colleaguesEncoded = entry.getSecretKey().getEncoded();
+                        String colleagues = new String(colleaguesEncoded);
+                        return colleagues.split(System.getProperty("line.separator"));
+                }
+        }
+        
+        private static void setInputManagerWindowRoutines()     {
+                InputManager manager = EcosystemManager.getInputManager();
+                
+            // Refresh the layout when the window resizes
+                manager.addWindowEventListener(new WindowEventListener() {
+                        @Override
+                        public void onWindowEvent(WindowEventType type)
+                        {
+                                if (type != WindowEventType.WINDOW_RESIZED) {
+                                        return;
+                                }
+                                DisplayController.refreshWindowSize();
+                                FrameIO.RefreshCacheImages();
+                                for (Frame frame : DisplayController.getFrames()) {
+                                        if (frame != null) {
+                                                ItemUtils.Justify(frame);
+                                                frame.refreshSize();
+                                        }
+                                }
+                                DisplayController.requestRefresh(false);
+                        }
+                });
+                
+                manager.addWindowEventListener(new WindowEventListener() {
+                        @Override
+                        public void onWindowEvent(WindowEventType type)
+                        {
+                                if (type != WindowEventType.MOUSE_EXITED_WINDOW) {
+                                        return;
+                                }
+                                StandardGestureActions.mouseExitedWindow();
+                        }
+                });
+                
+                manager.addWindowEventListener(new WindowEventListener() {
+                        @Override
+                        public void onWindowEvent(WindowEventType type)
+                        {
+                                if (type != WindowEventType.MOUSE_ENTERED_WINDOW) {
+                                        return;
+                                }
+                                StandardGestureActions.mouseEnteredWindow();
+                        }
+                });
+                
+                manager.addWindowEventListener(new WindowEventListener() {
+                        @Override
+                        public void onWindowEvent(WindowEventType type)
+                        {
+                                if (type != WindowEventType.WINDOW_CLOSED) {
+                                        return;
+                                }
+                                if (Browser._theBrowser != null) {
+                                        Browser._theBrowser.exit();
+                                }
+                        }
+                });
         }
 }