Changeset 1413 for trunk/src/org/expeditee/encryption

Timestamp:

06/25/19 13:57:37 (5 years ago)

Author:

bln4

Message:

Changed surrogates to work the way discussed with David. EncryptedExpReader/Writer updated to work with this.

Location:

trunk/src/org/expeditee/encryption

Files:

• io/EncryptedExpReader.java (modified) (10 diffs)
• io/EncryptedExpWriter.java (modified) (8 diffs)
• items/surrogates/EncryptionDetail.java (modified) (1 diff)
• items/surrogates/Label.java (modified) (5 diffs)
• items/surrogates/Surrogate.java (deleted)

trunk/src/org/expeditee/encryption/io/EncryptedExpReader.java

@@ -26 +26 @@
 import org.expeditee.encryption.items.surrogates.EncryptionDetail;
 import org.expeditee.encryption.items.surrogates.Label;
-import org.expeditee.encryption.items.surrogates.Surrogate;
 import org.expeditee.encryption.items.surrogates.Label.LabelResult;
 import org.expeditee.gui.Frame;
@@ -37 +36 @@
 
 public class EncryptedExpReader extends ExpReader implements CryptographyConstants {
+        
         private static final String ENCRYPTED_EXP_FLAG = "EncryptedExp";
         private static final String labelProfile = "Profile";
@@ -43 +43 @@
         private boolean accessDenied = false;
 
-        public EncryptedExpReader(String frameName) {
-                super(frameName);
-        }
-
         public static boolean isEncryptedExpediteeFile(final String path) throws IOException {
                 final BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(path), "UTF-8"));
@@ -52 +48 @@
                 in.close();
                 return firstLine.startsWith(ENCRYPTED_EXP_FLAG);
+        }
+        
+        public EncryptedExpReader(String frameName) {
+                super(frameName);
         }
         
@@ -132 +132 @@
                                 continue;
                         }
+                        
                         String tag = getTagEnc(next);
-                        if (tag.equals("S")) {
+                        if (next.startsWith("S ")) {
                                 currentItem = newItem(next);
                                 _linePoints.put(currentItem.getID(), currentItem);
                                 newFrame.addItem(currentItem);
                                 currentItem.setEncryptionDetailForTag(tag + "", EncryptionDetail.UnencryptedOnSave);
+                        } else if (next.startsWith("SurrogateFor")) {
+                                int parentID = Integer.parseInt(next.split(" ")[1]);
+                                newFrame.getItemWithID(parentID).addToSurrogates(currentItem);
                         } else if (currentItem != null && actionShouldBeDelayed(tag.charAt(0))) { 
                                 delayedActions.add(new DelayedAction(currentItem, next));
@@ -147 +151 @@
                 }
                 
-                if (next.equals("Z...")) {
-                        next = readTheSurrogateItems(newFrame, delayedActions);
+                if (next.equals(EncryptedExpWriter.SURROGATE_TERMINATOR)) {
+                        next = readTheItems(newFrame, delayedActions);
                 }
                 
@@ -159 +163 @@
                 String tag = getTagEnc(line);
                 String value = getValue(line);
+                
+                if (item.isSurrogate() && item.isTagInherited(tag)) {
+                        return;
+                }
                 
                 // Attempt to decrypt the line if necessary.
@@ -192 +200 @@
                 }
         }
-                
-        private String readTheSurrogateItems(Frame newFrame, List<DelayedAction> delayedActions) throws IOException {
-                String next = null;
-                Item currentItem = null;
-                
-                Predicate<String> endOfSection = s -> s.equals("Z") || s.equals("Z...");
-                while (_reader.ready() && !endOfSection.test(next = _reader.readLine())) {
-                        if (!isValidLine(next)) {
-                                continue;
-                        }
-                        
-                        String tag = getTagEnc(next);
-                        if (tag.equals("S") && !next.startsWith("SurrogateFor")) {
-                                currentItem = newItem(next);
-                                currentItem.setEncryptionDetailForTag(tag + "", EncryptionDetail.UnencryptedOnSave);
-                        } else if (next.startsWith("SurrogateFor")) {
-                                String id = next.split(" ")[1];
-                                Item classic = newFrame.getItemWithID(Integer.parseInt(id));
-                                if (id == null) {
-                                        System.err.println("WARNING: Attempted to create surrogate for classic ID " + 
-                                                        id + " but was no item on frame " + newFrame.getName() + " exists.");
-                                        continue;
-                                }
-                                currentItem.setAsSurrogateFor(classic);
-                                classic.addToSurrogates(new Surrogate(currentItem));
-                        } else if (currentItem != null && actionShouldBeDelayed(getTag(next))) { 
-                                delayedActions.add(new DelayedAction(currentItem, next));
-                        } else if (currentItem != null) {
-                                processBodyLine(currentItem, next);
-                        } else {
-                                System.err.println("Error while reading in frame (ExpReader): Found body line but no current item to apply it to.");
-                        }
-                }
-
-                return next;
-        }
-        
-        protected static String getTagEnc(String line) {
-                char charAtZero = line.charAt(0);
-                if (charAtZero == '_') {
-                        return line.split(" ")[0];
-                } else {
-                        return charAtZero + "";
-                }
-        }
         
         protected static String getValue(String line) {
@@ -247 +210 @@
         }
         
-        protected static boolean isEncryptedLine(String line) {
+        private static String getTagEnc(String line) {
+                char charAtZero = line.charAt(0);
+                if (charAtZero == '_') {
+                        return line.split(" ")[0];
+                } else {
+                        return charAtZero + "";
+                }
+        }
+                
+        private static boolean isEncryptedLine(String line) {
                 if (line.startsWith("S") || line.startsWith("_el")) {
                         return false;
@@ -278 +250 @@
                 }
         }
-        
+
         private class EncryptedLineReader extends BufferedReader {
                 private boolean noneMode = false;

trunk/src/org/expeditee/encryption/io/EncryptedExpWriter.java

@@ -6 +6 @@
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Base64;
 import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Set;
-import java.util.function.Consumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import javax.crypto.BadPaddingException;
@@ -24 +24 @@
 import org.expeditee.encryption.items.surrogates.EncryptionDetail;
 import org.expeditee.encryption.items.surrogates.Label;
-import org.expeditee.encryption.items.surrogates.Surrogate;
 import org.expeditee.encryption.items.surrogates.Label.LabelResult;
 import org.expeditee.gui.Frame;
@@ -76 +75 @@
         
         @Override
-        public void outputFrame(Frame frame) throws IOException {
-                if (_writer == null) { return; }
-                
-                preOutputFrame();
-                writeHeader(frame);
-                
-                // write item
-                writeItemData(frame);
-                writeTerminator();
-                
-                // write lines and constraints
-                writeLineData();
-                writeTerminator();
-                writeConstraintData();
-                writeTerminator();
-                
-                writeLine(SessionStats.getFrameEventList(frame));
-        }
-        
-        @Override
         protected void preOutputFrame() {
                 try {
@@ -107 +86 @@
         
         @Override
+        public void outputFrame(Frame frame) throws IOException {
+                if (_writer == null) { return; }
+                
+                preOutputFrame();
+                writeHeader(frame);
+                
+                // write item
+                writeItemData(frame);
+                writeTerminator();
+                
+                // write lines and constraints
+                writeLineData();
+                writeTerminator();
+                writeConstraintData();
+                writeTerminator();
+                
+                writeLine(SessionStats.getFrameEventList(frame));
+        }
+        
+        @Override
         protected void writeLine(String line) throws IOException {
                 // do not write empty lines
@@ -125 +124 @@
         }
         
-        @Override
-        protected void writeLineData() throws IOException {
-                super.writeLineData();
-                
-                writeSurrogateLineData();
-        }
-        
-        @Override
         protected void writeClass(Item toWrite) throws IOException {
                 LinkedHashMap<Character,Method> itemTags = new LinkedHashMap<Character, Method>(getItemTags());
                 LinkedHashMap<String,Method> itemTagsExt = new LinkedHashMap<String, Method>(getItemTagsExt());
                 
-                // Perform final update on surrogates to ensure inheritance works.
-                Set<Surrogate> surrogates = toWrite.getSurrogates();
-                for (Surrogate s: surrogates) {
-                        s.toString();
-                }
-                
                 writeTag(toWrite, new Object[] {}, itemTags, 'S');
                 writeTag(toWrite, new Object[] {}, itemTagsExt, "_el");
                 
+                if (toWrite.isSurrogate()) {
+                        writeLine("SurrogateFor " + toWrite.getClassic().getID());
+                }
+                
                 itemTags.remove('S');
                 itemTagsExt.remove("_el");
-                
+                                
                 writeTags(toWrite, new Object[] {}, itemTags);
                 writeTags(toWrite, new Object[] {}, itemTagsExt);
@@ -155 +144 @@
         @Override
         protected <T> void writeTag(Item toWrite, Object[] param, LinkedHashMap<T, Method> tags, T tag) {
+                if (toWrite.isSurrogate() && toWrite.isTagInherited(tag + "")) {
+                        return;
+                }
                 EncryptionDetail encryptionDetail = toWrite.getEncryptionDetailForTag(tag + "");
-                switch (encryptionDetail) {
+                                
+                switch(encryptionDetail) {
                 case UnencryptedOnSave:
-                        super.writeTag(toWrite, param, tags, tag);
+                        writeTagUnencryptedOnSave(toWrite, param, tags, tag);
+                        break;
+                case InheritanceCheckOnSave:
+                        writeTagInheritanceCheckOnSave(toWrite, tags, tag);
                         break;
                 case ReencryptOnSave:
-                        Method toRun = tags.get(tag);
-                        Class<?> declarer = toRun.getDeclaringClass();
-                        LabelResult res = Label.resolveKey(toWrite.getEncryptionLabel());
-                        if (declarer.isAssignableFrom(toWrite.getClass()) && res == LabelResult.SuccessResolveLabelToKey) {
-                                SecretKey key = new SecretKeySpec(res.key, SymmetricAlgorithm);
-                                try {
-                                        Object o = toRun.invoke(toWrite, new Object[] {});
-                                        o = Conversion.ConvertToExpeditee(toRun, o);
-                                        if (o != null) {
-                                                if (o instanceof List) {
-                                                        for (Object line: (List<?>)o) {
-                                                                byte[] encryptedBytes = EncryptSymmetric(line.toString().getBytes(), key);
-                                                                writeLine(tag + "E", Base64.getEncoder().encodeToString(encryptedBytes));
-                                                        }
-                                                } else {
-                                                        byte[] encryptedBytes = EncryptSymmetric(o.toString().getBytes(), key);
-                                                        writeLine(tag + "E", Base64.getEncoder().encodeToString(encryptedBytes));
-                                                }
-                                        }
-                                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-                                        e.printStackTrace();
-                                } catch (IOException e) {
-                                        e.printStackTrace();
-                                }
-                        }
+                        writeTagReencryptOnSave(toWrite, tags, tag);
                         break;
                 case UseUndecipheredValueOnSave:
-                        try {
-                                writeLine(tag + "E", encryptionDetail.getUndecipheredValue());
-                        } catch (IOException e) {
-                                e.printStackTrace();
-                        }
+                        writeTagUseUndecipheredValueOnSave(toWrite, tags, tag);
                         break;
                 }
@@ -204 +172 @@
                 }
                 
-                for (final Item i: frame.getBodyItemsWithInsufficientPermissions()) {
+                for (Item i: frame.getBodyItemsWithInsufficientPermissions()) {
                         assert (!(i instanceof Line));
                         writeItem(i);
                 }
                 
-                writeSurrogateItemsData(frame);
-        }
-        
-        private void writeSurrogateItemsData(Frame frame) throws IOException {
-                List<Surrogate> surrogates = new ArrayList<Surrogate>();
-                
-                Consumer<? super Item> store = item -> surrogates.addAll(item.getSurrogates());
-                frame.getItemsToSave().forEach(store);
-                frame.getBodyItemsWithInsufficientPermissions().forEach(store);
-                
+                List<Item> surrogates = frame.getSurrogateItemsToSave();
                 if (!surrogates.isEmpty()) {
-                        // If there is some surrogates, write the surrogate 
-                        // terminator, then write out the surrogates.
                         writeSurrogateTerminator();
-                        
-                        for (Surrogate surrogate: surrogates) {
-                                String output = surrogate.toString();
-                                writeLine(output);
-                        }
-                }
-        }
-
-        private void writeSurrogateLineData() throws IOException {
-                List<Surrogate> surrogateLines = new ArrayList<Surrogate>();
-                
-                for(Item lineEnd: _lineEnds) {
-                        List<Line> lines = lineEnd.getLines();
-                        for (Line line: lines) {
-                                surrogateLines.addAll(line.getSurrogates());
-                        }
-                }
-                
-                if (!surrogateLines.isEmpty()) {
-                        // If there is some surrogates, write the surrogate 
-                        // terminator, then write out the surrogates.
-                        writeSurrogateTerminator();
-                        
-                        for (Surrogate surrogate: surrogateLines) {
-                                String output = surrogate.toString();
-                                writeLine(output);
-                        }
-                }
+                        for (Item i: surrogates) {
+                                assert (!(i instanceof Line));
+                                writeItem(i);
+                        }
+                }
+        }
+        
+        private <T> void writeTagInheritanceCheckOnSave(Item toWrite, LinkedHashMap<T, Method> tags, T tag) {   
+                List<Item> surrogateItems = toWrite.getSurrogates().stream().collect(Collectors.toList());
+                Function<Item, Boolean> isTagInherited = surrogate -> surrogate.isTagInherited(tag + "");
+                BinaryOperator<Boolean> trueExists = (a, b) -> a || b;
+                boolean surrogatesInherit = surrogateItems.stream().map(isTagInherited).collect(Collectors.reducing(trueExists)).get();
+                if (surrogatesInherit && 
+                                Label.resolveKey(toWrite.getEncryptionLabel()) == LabelResult.SuccessResolveLabelToKey) {
+                        toWrite.setEncryptionDetailForTag(tag + "", EncryptionDetail.UnencryptedOnSave);
+                        writeTagUnencryptedOnSave(toWrite, new Object[] {}, tags, tag);
+                } else {
+                        toWrite.setEncryptionDetailForTag(tag + "", EncryptionDetail.ReencryptOnSave);
+                        writeTagReencryptOnSave(toWrite, tags, tag);
+                }
+        }
+        
+        private <T> void writeTagReencryptOnSave(Item toWrite, LinkedHashMap<T, Method> tags, T tag) {
+                Method toRun = tags.get(tag);
+                Class<?> declarer = toRun.getDeclaringClass();
+                LabelResult res = Label.resolveKey(toWrite.getEncryptionLabel());
+                if (declarer.isAssignableFrom(toWrite.getClass()) && res == LabelResult.SuccessResolveLabelToKey) {
+                        try {
+                                Object o = toRun.invoke(toWrite, new Object[] {});
+                                o = Conversion.ConvertToExpeditee(toRun, o);
+                                if (o == null) {
+                                        return;
+                                }
+                                if (o instanceof List) {
+                                        for (Object line: (List<?>) o) {
+                                                writeLineEnc(tag, line, res.key);
+                                        }
+                                } else {
+                                        writeLineEnc(tag, o, res.key);
+                                }
+                        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+                                e.printStackTrace();
+                        } catch (IOException e) {
+                                e.printStackTrace();
+                        }
+                }
+        }
+        
+        private <T> void writeTagUseUndecipheredValueOnSave(Item toWrite, LinkedHashMap<T, Method> tags, T tag) {
+                EncryptionDetail encryptionDetail = toWrite.getEncryptionDetailForTag(tag + "");
+                try {
+                        writeLine(tag + "E", encryptionDetail.getUndecipheredValue());
+                } catch (IOException e) {
+                        e.printStackTrace();
+                }
+        }
+        
+        private <T> void writeTagUnencryptedOnSave(Item toWrite, Object[] param, LinkedHashMap<T, Method> tags, T tag) {
+                super.writeTag(toWrite, param, tags, tag);
         }
         
         private void writeSurrogateTerminator() throws IOException {
                 writeLine(SURROGATE_TERMINATOR + nl);
+        }
+        
+        private <T> void writeLineEnc(T tag, Object line, byte[] keyBytes) throws IOException {
+                SecretKey key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
+                byte[] lineEncryptedBytes = EncryptSymmetric(line.toString().getBytes(), key);
+                line = Base64.getEncoder().encodeToString(lineEncryptedBytes);
+                writeLine(tag + "E", line.toString());
         }
         
@@ -271 +266 @@
                         return null;
                 }
-        }       
+        }
 }

trunk/src/org/expeditee/encryption/items/surrogates/EncryptionDetail.java

@@ -2 +2 @@
 
 public enum EncryptionDetail {
-        UnencryptedOnSave, ReencryptOnSave, UseUndecipheredValueOnSave;
+        // If the property needs to be unencrypted due to inheritance then do not try to encrypt it.
+        UnencryptedOnSave,
+        
+        // If the property is not inherited by any surrogates then we can try to encrypt it.  
+        // If we do not have key then default to UnencryptedOnSave.
+        ReencryptOnSave,
+        
+        // If the property is no longer inherited by at least one surrogate then this value is present.  
+        // If it turns out there is no longer any surrogates who inherit the value then this value can be replaced with ReencryptOnSave.
+        // Otherwise, this value must be replaced with UnencryptedOnSave.
+        InheritanceCheckOnSave,
+        
+        // If we could not decrypt the value on load then EncryptionDetail.getUndecipheredValue() can be used to get the value for saving.
+        UseUndecipheredValueOnSave;
         
         private String undecipheredValue = null;

trunk/src/org/expeditee/encryption/items/surrogates/Label.java

@@ -1 +1 @@
 package org.expeditee.encryption.items.surrogates;
 
+import java.util.ArrayList;
 import java.util.Base64;
 import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.expeditee.auth.AuthenticatorBrowser;
+import org.expeditee.gui.DisplayController;
 import org.expeditee.gui.Frame;
 import org.expeditee.gui.FrameIO;
+import org.expeditee.gui.MessageBay;
+import org.expeditee.items.Item;
 import org.expeditee.items.Text;
 import org.expeditee.settings.UserSettings;
@@ -12 +19 @@
 public class Label {
         
+        private static List<LabelResult> labelCache = new ArrayList<LabelResult>();
+        private static List<String> forbiddenLabels = new ArrayList<String>();
+        
         public static LabelResult resolveKey(String label) {
+                
+                if (forbiddenLabels.contains(label)) {
+                        return LabelResult.ErrorUnableToFindLabel;
+                }
+                
+                LabelResult fromCache = getFromCache(label);
+                if (fromCache != null) {
+                        return fromCache;
+                }
+
+                
                 String credentialsFrameName = UserSettings.ProfileName.get() + 
                                 AuthenticatorBrowser.CREDENTIALS_FRAME;
@@ -44 +65 @@
                                 LabelResult res = LabelResult.SuccessResolveLabelToKey;
                                 res.key = Base64.getDecoder().decode(data);
+                                res.name = label;
+                                labelCache.add(res);
                                 return res;
                         } catch (IllegalArgumentException e) {
@@ -50 +73 @@
                 }
         }
+        
+        public static void progressSurrogateMode() {
+                Collection<Item> allItems = DisplayController.getCurrentFrame().getAllItems();
+                allItems.removeIf(item -> item.getEncryptionLabel() == null);
+                MessageBay.displayMessage("Encryption labels found on items on current frame: ");
+                Set<String> allLabels = allItems.stream().map(i -> i.getEncryptionLabel()).collect(Collectors.toSet());
+                StringBuilder sb = new StringBuilder();
+                for (String label: allLabels) {
+                        sb.append(label + ",");
+                }
+                MessageBay.displayMessage(sb.deleteCharAt(sb.length() - 1).toString());
+        }
+        
+        public static void resetSurrogateMode() {
+                // TODO Auto-generated method stub
+                
+        }
+        
+        private static LabelResult getFromCache(String label) {
+                List<LabelResult> cacheCanditates = labelCache.stream().filter(labelResult -> labelResult.name.equals(label)).collect(Collectors.toList());
+                if (!cacheCanditates.isEmpty()) {
+                        return cacheCanditates.get(0);
+                } else {
+                        return null;
+                }
+        }
+        
+//      private static List<List<String>> permutation(List<String> strings, List<List<String>> acc) {
+//              for (int i = 0; i < strings.size(); i++) {
+//                      
+//              }
+//      }
         
         public enum LabelResult {
@@ -58 +113 @@
                 
                 public byte[] key;
+                public String name;
                 
                 @Override