Changeset 1413 for trunk/src/org/expeditee/encryption/io/EncryptedExpWriter.java

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.

File:

• trunk/src/org/expeditee/encryption/io/EncryptedExpWriter.java (modified) (8 diffs)

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;
                 }
-        }       
+        }
 }