Changeset 1260 for trunk

Timestamp:

03/19/19 10:39:24 (5 years ago)

Author:

bln4

Message:

Actions for Davids presentation

File:

• trunk/src/org/expeditee/auth/sharing/Actions.java (modified) (4 diffs)

trunk/src/org/expeditee/auth/sharing/Actions.java

@@ -1 +1 @@
 package org.expeditee.auth.sharing;
 
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
+import java.util.Arrays;
 import java.util.Base64;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -8 +12 @@
 import java.util.Random;
 
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.SecretKeySpec;
+
 import org.expeditee.gui.DisplayController;
+import org.expeditee.gui.Frame;
+import org.expeditee.gui.FrameIO;
 import org.expeditee.items.Text;
+import org.ngikm.cryptography.CryptographyConstants;
 
 import com.codahale.shamir.Scheme;
 
-public class Actions {
+public class Actions implements CryptographyConstants {
         
         public static Text GenerateSecret(String label) {
@@ -21 +35 @@
         public static Text SplitSecret(Text key) {
                 return AuthSplitSecret(key);
+        }
+        
+        public static Text JoinSecret(Text key) {
+                return AuthJoinSecret(key);
         }
 
@@ -88 +106 @@
                 return key;
         }
+        
+        public static void AuthEncrypt(Text labelWithKey) {
+                // Obtain encryption key
+                String keyEncoded = labelWithKey.getData().get(0);
+                byte[] keyDecoded = Base64.getDecoder().decode(keyEncoded);
+                SecretKey key = new SecretKeySpec(keyDecoded, SymmetricAlgorithm);
+                
+                // Perform encryption
+                Frame toEncrypt = FrameIO.LoadFrame(labelWithKey.getLink());
+                Collection<Text> textItems = toEncrypt.getTextItems();
+                for (Text t: textItems) {
+                        byte[] encrypted = EncryptSymmetric(t.getText().getBytes(), key);
+                        t.setText(Base64.getEncoder().encodeToString(encrypted));
+                }
+                
+                // Save changes
+                FrameIO.SaveFrame(toEncrypt);
+        }
+        
+        public static void AuthDecrypt(Text labelWithKey) {
+                // Obtain encryption key
+                String keyEncoded = labelWithKey.getData().get(0);
+                byte[] keyDecoded = Base64.getDecoder().decode(keyEncoded);
+                SecretKey key = new SecretKeySpec(keyDecoded, SymmetricAlgorithm);
+                
+                // Perform decryption
+                Frame toEncrypt = FrameIO.LoadFrame(labelWithKey.getLink());
+                Collection<Text> textItems = toEncrypt.getTextItems();
+                for (Text t: textItems) {
+                        byte[] decrypted = DecryptSymmetric(Base64.getDecoder().decode(t.getText().getBytes()), key);
+                        t.setText(new String(decrypted));
+                }
+        }
+        
+        private static byte[] EncryptSymmetric(final byte[] toEncrypt, final SecretKey key) {
+                // toEncrypt = Base64.getDecoder().decode(toEncrypt);
+                try {
+                        final Cipher cipher = Cipher.getInstance(SymmetricAlgorithm + SymmetricAlgorithmParameters);
+                        cipher.init(Cipher.ENCRYPT_MODE, key);
+                        //could use modulus
+                        final int length = (int) ((Math.ceil(toEncrypt.length / 16f)) * 16);
+                        final byte[] toEncryptSizeAdjusted = Arrays.copyOf(toEncrypt, length);
+                        //System.err.println("(" + toEncryptSizeAdjusted.length + ")" + "Before Encryption Data: "
+                        //              + Arrays.toString(toEncryptSizeAdjusted));
+                        final byte[] result = cipher.doFinal(toEncryptSizeAdjusted);
+                        //System.err.println("(" + result.length + ")" + "Encrypted Data: " + Arrays.toString(result));
+                        return result;
+                } catch (final NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException
+                                | IllegalBlockSizeException | BadPaddingException e) {
+                        e.printStackTrace();
+                        return null;
+                }
+        }
+
+        private static byte[] DecryptSymmetric(final byte[] toDecrypt, final SecretKey key) {
+                try {
+                        final Cipher cipher = Cipher.getInstance(SymmetricAlgorithm + SymmetricAlgorithmParameters);
+                        cipher.init(Cipher.DECRYPT_MODE, key);
+                        final byte[] decryptedBytes = cipher.doFinal(toDecrypt);
+                        int indexOfZero = decryptedBytes.length - 1;
+                        for (int i = decryptedBytes.length - 1; i >= 0; i--) {
+                                if (decryptedBytes[i] != (byte) 0) {
+                                        indexOfZero = i + 1;
+                                        break;
+                                }
+                        }
+                        return Arrays.copyOf(decryptedBytes, indexOfZero);
+                } catch (final NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException
+                                | IllegalBlockSizeException | BadPaddingException e) {
+                        e.printStackTrace();
+                        return null;
+                }
+        }
 }