Changeset 1401


Ignore:
Timestamp:
05/31/19 16:29:24 (5 years ago)
Author:
bln4
Message:

Refactoring on how labels are resolved.

Location:
trunk/src/org/expeditee
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/org/expeditee/auth/account/Authenticate.java

    r1389 r1401  
    190190                        }
    191191
    192                         String message = "Was the list of possible enum results updated without nessasary changes to thh toString() function?";
     192                        String message = "Was the list of possible enum results updated without nessasary changes to the toString() function?";
    193193                        throw new IllegalArgumentException(message);
    194194                }

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

    r1400 r1401  
    2222
    2323import org.expeditee.encryption.CryptographyConstants;
     24import org.expeditee.encryption.Label;
     25import org.expeditee.encryption.Label.LabelResult;
    2426import org.expeditee.gui.Frame;
    2527import org.expeditee.io.ExpReader;
    … …  
    8991                        // Decrypt the Text Items
    9092                        if (i instanceof Text) {
    91                                 byte[] keyBytes = EncryptedExpWriter.resolveKeyFromLabel(i.getEncryptionLabel(), "");
    92                                 if (keyBytes == null) { continue; }
    93                                 SecretKeySpec key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
    94                                 byte[] decryptedBytes = DecryptSymmetric(Base64.getDecoder().decode(i.getText()), key);
    95                                 i.setText(new String(decryptedBytes));
     93                                LabelResult res = Label.resolveKey(i.getEncryptionLabel());
     94                                if (res == LabelResult.SuccessResolveLabelToKey) {
     95                                        byte[] keyBytes = res.key;
     96                                        if (keyBytes == null) { continue; }
     97                                        SecretKeySpec key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
     98                                        byte[] decryptedBytes = DecryptSymmetric(Base64.getDecoder().decode(i.getText()), key);
     99                                        i.setText(new String(decryptedBytes));
     100                                }
    96101                        }
    97102                }
    … …  
    170175               
    171176                private SecretKeySpec resolveLabel(String label) {
    172                         byte[] keyBytes = EncryptedExpWriter.resolveKeyFromLabel(label, "");
    173                         return new SecretKeySpec(keyBytes, SymmetricAlgorithm);
     177                        LabelResult res = Label.resolveKey(label);
     178                        if (res == LabelResult.SuccessResolveLabelToKey) {
     179                                byte[] keyBytes = res.key;
     180                                return new SecretKeySpec(keyBytes, SymmetricAlgorithm);
     181                        }
     182                        return null;
    174183                }
    175184        }

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

    r1400 r1401  
    1616import javax.crypto.spec.SecretKeySpec;
    1717
    18 import org.expeditee.auth.AuthenticatorBrowser;
    1918import org.expeditee.encryption.CryptographyConstants;
     19import org.expeditee.encryption.Label;
     20import org.expeditee.encryption.Label.LabelResult;
    2021import org.expeditee.gui.Frame;
    21 import org.expeditee.gui.FrameIO;
    2222import org.expeditee.gui.MessageBay;
    2323import org.expeditee.io.ExpWriter;
    2424import org.expeditee.items.Item;
    2525import org.expeditee.items.Text;
    26 import org.expeditee.settings.UserSettings;
    2726import org.expeditee.settings.identity.secrets.KeyList;
    2827
    … …  
    4342                        label = "Profile";
    4443                } else {
    45                         byte[] keyBytes = resolveKeyFromLabel(encryptionLabel, _framename);
    46                         key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
    47                         label = encryptionLabel;
     44                        LabelResult res = Label.resolveKey(encryptionLabel);
     45                        if (res == LabelResult.SuccessResolveLabelToKey) {
     46                                byte[] keyBytes = res.key;
     47                                key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
     48                                label = encryptionLabel;
     49                        } else if (res == LabelResult.ErrorUnableToFindLabel) {
     50                                MessageBay.errorMessage(res.toString() + encryptionLabel);
     51                        } else {
     52                                MessageBay.errorMessage(res.toString());
     53                        }
    4854                }
    4955        }
    … …  
    8894                        // Encrypt the Text Items
    8995                        if (i instanceof Text) {
    90                                 byte[] keyBytes = resolveKeyFromLabel(i.getEncryptionLabel(), "(actually item) on " + i.getParent().getName());
    91                                 if (keyBytes == null) { continue; }
    92                                 SecretKeySpec key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
    93                                 byte[] encryptedBytes = EncryptSymmetric(i.getText().getBytes(), key);
    94                                 i.setText(Base64.getEncoder().encodeToString(encryptedBytes));
     96                                LabelResult res = Label.resolveKey(i.getEncryptionLabel());
     97                                if (res == LabelResult.SuccessResolveLabelToKey) {
     98                                        byte[] keyBytes = res.key;
     99                                        if (keyBytes == null) { continue; }
     100                                        SecretKeySpec key = new SecretKeySpec(keyBytes, SymmetricAlgorithm);
     101                                        byte[] encryptedBytes = EncryptSymmetric(i.getText().getBytes(), key);
     102                                        i.setText(Base64.getEncoder().encodeToString(encryptedBytes));
     103                                }
    95104                        }
    96105                }
    97106        }
    98107       
    99         protected static byte[] resolveKeyFromLabel(String label, String framename) {
    100                 String credentialsFrameName = UserSettings.ProfileName.get() + AuthenticatorBrowser.CREDENTIALS_FRAME;
    101                 Frame credentialsFrame = FrameIO.LoadFrame(credentialsFrameName);
    102                 Collection<Text> textItems = credentialsFrame.getTextItems();
    103                 textItems.removeIf(t -> !t.getText().equals("Secrets"));
    104                 textItems.removeIf(t -> !t.hasLink());
    105                 if (textItems.isEmpty()) {
    106                         MessageBay.errorMessage("Unable to find label " + label + " to encrypt frame " + framename + ".");
    107                         return null;
    108                 } else {
    109                         Text linkToSecretsFrame = textItems.iterator().next();
    110                         Frame secretsFrame = FrameIO.LoadFrame(linkToSecretsFrame.getParent().getFramesetName() + linkToSecretsFrame.getLink());
    111                         Collection<Text> labels = secretsFrame.getTextItems();
    112                         labels.removeIf(lbl -> !lbl.getText().equals(label));
    113                         labels.removeIf(lbl -> lbl.getData() == null || lbl.getData().size() == 0);
    114                         if (labels.isEmpty()) {
    115                                 MessageBay.errorMessage("Unable to find label " + label + " to encrypt frame " + framename + ".");
    116                                 return null;
    117                         }
    118                        
    119                         Text labelItem = labels.iterator().next();
    120                         String data = labelItem.getData().get(0);
    121                         if (data.contains("{")) {
    122                                 MessageBay.errorMessage("You only have a fraction of the required key to access " + framename + ".");
    123                                 return null;
    124                         } else {
    125                                 try {
    126                                         return Base64.getDecoder().decode(data);
    127                                 } catch (IllegalArgumentException e) {
    128                                         MessageBay.errorMessage("Unable to create key out of data stored in label " + label + ".");
    129                                         return null;
    130                                 }
    131                         }
    132                 }
    133         }
     108//      protected static byte[] resolveKeyFromLabel(String label, String framename) {
     109//              String credentialsFrameName = UserSettings.ProfileName.get() + AuthenticatorBrowser.CREDENTIALS_FRAME;
     110//              Frame credentialsFrame = FrameIO.LoadFrame(credentialsFrameName);
     111//              Collection<Text> textItems = credentialsFrame.getTextItems();
     112//              textItems.removeIf(t -> !t.getText().equals("Secrets"));
     113//              textItems.removeIf(t -> !t.hasLink());
     114//              if (textItems.isEmpty()) {
     115//                      MessageBay.errorMessage("Unable to find label " + label + " to encrypt frame " + framename + ".");
     116//                      return null;
     117//              } else {
     118//                      Text linkToSecretsFrame = textItems.iterator().next();
     119//                      Frame secretsFrame = FrameIO.LoadFrame(linkToSecretsFrame.getParent().getFramesetName() + linkToSecretsFrame.getLink());
     120//                      Collection<Text> labels = secretsFrame.getTextItems();
     121//                      labels.removeIf(lbl -> !lbl.getText().equals(label));
     122//                      labels.removeIf(lbl -> lbl.getData() == null || lbl.getData().size() == 0);
     123//                      if (labels.isEmpty()) {
     124//                              MessageBay.errorMessage("Unable to find label " + label + " to encrypt frame " + framename + ".");
     125//                              return null;
     126//                      }
     127//                     
     128//                      Text labelItem = labels.iterator().next();
     129//                      String data = labelItem.getData().get(0);
     130//                      if (data.contains("{")) {
     131//                              MessageBay.errorMessage("You only have a fraction of the required key to access " + framename + ".");
     132//                              return null;
     133//                      } else {
     134//                              try {
     135//                                      return Base64.getDecoder().decode(data);
     136//                              } catch (IllegalArgumentException e) {
     137//                                      MessageBay.errorMessage("Unable to create key out of data stored in label " + label + ".");
     138//                                      return null;
     139//                              }
     140//                      }
     141//              }
     142//      }
    134143       
    135144        private static byte[] EncryptSymmetric(byte[] toEncrypt, SecretKey key) {
Note: See TracChangeset for help on using the changeset viewer.