source: trunk/src/org/expeditee/auth/Mail.java@ 1243

package org.expeditee.auth;

import java.nio.file.Path;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import org.ngikm.cryptography.CryptographyConstants;

public class Mail implements CryptographyConstants {
        
        private static List<MailEntry> messages = new ArrayList<MailEntry>();
        
        /**
         * Add a piece of mail, used during initialisation.
         */
        public static void addEntry(MailEntry mail) {
                messages.add(mail);
        }
        
        public static void clear() {
                messages.clear();
        }
        
        public static void sendMail(MailEntry mail, PublicKey key, Path outbox) {
                try {
                        Cipher cipher = Cipher.getInstance(AsymmetricAlgorithm + AsymmetricAlgorithmParameters);
                        
                        // encrypt the necessary parts of the message
                        cipher.init(Cipher.ENCRYPT_MODE, key);
                        String time = Base64.getEncoder().encodeToString(cipher.doFinal(mail.timestamp.getBytes()));
                        cipher.init(Cipher.ENCRYPT_MODE, key);
                        String sender = Base64.getEncoder().encodeToString(cipher.doFinal(mail.sender.getBytes()));
                        cipher.init(Cipher.ENCRYPT_MODE, key);
                        String rec = Base64.getEncoder().encodeToString(cipher.doFinal(mail.receiver.getBytes()));
                        cipher.init(Cipher.ENCRYPT_MODE, key);
                        String message = Base64.getEncoder().encodeToString(cipher.doFinal(mail.message.getBytes()));
                        cipher.init(Cipher.ENCRYPT_MODE, key);
                        String message2 = Base64.getEncoder().encodeToString(cipher.doFinal(mail.message2.getBytes()));
                        
                        Map<String, String> options = new HashMap<String, String>(); 
                        for (String label: mail.options.keySet()) {
                                cipher.init(Cipher.ENCRYPT_MODE, key);
                                String labelEncrypted = Base64.getEncoder().encodeToString(cipher.doFinal(label.getBytes()));
                                cipher.init(Cipher.ENCRYPT_MODE, key);
                                String actionNameEncrypted = Base64.getEncoder().encodeToString(cipher.doFinal(mail.options.get(label).getBytes()));
                                options.put(labelEncrypted, actionNameEncrypted);
                        }
                        
                        // write to mail database
                        Connection c = DriverManager.getConnection("jdbc:sqlite:" + outbox.resolve("expmail.db"));
                        String sql = "INSERT INTO EXPMAIL (TIME,SND,REC,MSG,MSG2,OPTS,OPTSVAL) VALUES (?, ?, ?, ?, ?, ?, ?);";
                        PreparedStatement statement = c.prepareStatement(sql);
                        statement.setString(1, time);
                        statement.setString(2, sender);
                        statement.setString(3, rec);
                        statement.setString(4, message);
                        statement.setString(5, message2);
                        String opts = Arrays.toString(options.keySet().toArray());
                        statement.setString(6, opts);
                        String optsval = Arrays.toString(options.values().toArray());
                        statement.setString(7, optsval);
                        statement.execute();
                        statement.close();
                        c.close();                      
                } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException | SQLException e) {
                        e.printStackTrace();
                }
        }
        
        /**
         * Gets the mail messages that the specified user is able to read.
         * The caller supplies their username and private key.  
         * If the private key can decrypt a message, then it was encrypted using the users public key, and is therefore for them.
         */
        public static List<MailEntry> getEntries(String name, PrivateKey key) throws NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException {
                List<MailEntry> filtered = new ArrayList<MailEntry>();
                
                for (MailEntry mail: messages) {
                        // confirm this is a message for the requester of entries
                        String receiver = mail.receiver;
                        byte[] receiverBytes = Base64.getDecoder().decode(receiver);
                        String receiverDecrypted = null;
                        Cipher c = Cipher.getInstance(AsymmetricAlgorithm + AsymmetricAlgorithmParameters);
                        try {
                                c.init(Cipher.DECRYPT_MODE, key);
                                receiverDecrypted = new String(c.doFinal(receiverBytes));
                        } catch (InvalidKeyException | BadPaddingException e) {
                                // this is not a message for 'us'
                                continue;
                        }
                        
                        // add an unencrypted version of the message to the return list
                        if (receiverDecrypted.compareToIgnoreCase(name) == 0) {
                                c.init(Cipher.DECRYPT_MODE, key);
                                String timestamp = new String(c.doFinal(Base64.getDecoder().decode(mail.timestamp)));
                                c.init(Cipher.DECRYPT_MODE, key);
                                String sender = new String(c.doFinal(Base64.getDecoder().decode(mail.sender)));
                                c.init(Cipher.DECRYPT_MODE, key);
                                String message = new String(c.doFinal(Base64.getDecoder().decode(mail.message)));
                                c.init(Cipher.DECRYPT_MODE, key);
                                String message2 = new String(c.doFinal(Base64.getDecoder().decode(mail.message2)));
                                
                                Map<String, String> options = new HashMap<String, String>(); //mail.options;
                                for (String label: mail.options.keySet()) {
                                        c.init(Cipher.DECRYPT_MODE, key);
                                        String labelDecrypted = new String(c.doFinal(Base64.getDecoder().decode(label)));
                                        c.init(Cipher.DECRYPT_MODE, key);
                                        String actionNameDecrypted = new String(c.doFinal(Base64.getDecoder().decode(mail.options.get(label))));
                                        options.put(labelDecrypted, actionNameDecrypted);
                                }
                                
                                //String arguments = new String(c.doFinal(Base64.getDecoder().decode(mail.args)));
                                filtered.add(new MailEntry(timestamp, sender, receiverDecrypted, message, message2, options));
                        }
                }
                
                return filtered;
        }
        
        /**
         * Describes a piece of mail, either encrypted or decrypted.
         */
        public static class MailEntry {
                public String timestamp;
                public String sender;
                public String receiver;
                public String message;
                public String message2;
                public Map<String, String> options;
                
                public MailEntry(String timestamp, String sender, String rec, String message, String message2, Map<String, String> options) {
                        this.timestamp = timestamp;
                        this.sender = sender;
                        this.receiver = rec;
                        this.message = message;
                        this.message2 = message2;
                        this.options = options;
                }
        }
}