Cipher.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.elephant.impl.security;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.security.KeyPair;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.SecretKey;
import org.turro.crypto.AsymetricCipher;
import org.turro.crypto.SymetricCipher;
import org.turro.elephant.context.ElephantContext;
 
public class Cipher {
 
  public static final String
          SECRET_KEY_FILE = "/WEB-INF/elephant/security/secret.cipher",
          PAIR_KEY_FILE = "/WEB-INF/elephant/security/keypair.cipher";
 
  private static void initKeys() {
    File key = new File(ElephantContext.getRealPath(SECRET_KEY_FILE));
    if(!key.exists()) {
      SecretKey sk = SymetricCipher.getSecretKey();
      saveToFile(sk, key);
    }
    key = new File(ElephantContext.getRealPath(PAIR_KEY_FILE));
    if(!key.exists()) {
      try {
        KeyPair kp = AsymetricCipher.getKeyPair();
        saveToFile(kp, key);
      } catch (Exception ex) {
        Logger.getLogger(Cipher.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
  }
 
  public static byte[] symetricEncrypt(byte[] inpBytes) {
    initKeys();
    return SymetricCipher.encrypt(inpBytes, (SecretKey) 
            getFromFile(new File(ElephantContext.getRealPath(SECRET_KEY_FILE))));
  }
 
  public static byte[] symetricDecrypt(byte[] inpBytes) {
    initKeys();
    return SymetricCipher.decrypt(inpBytes, (SecretKey) 
            getFromFile(new File(ElephantContext.getRealPath(SECRET_KEY_FILE))));
  }
 
  public static byte[] asymetricEncrypt(byte[] inpBytes) {
    initKeys();
    KeyPair kp = (KeyPair) getFromFile(new File(ElephantContext.getRealPath(PAIR_KEY_FILE)));
    return AsymetricCipher.encrypt(inpBytes, kp.getPrivate());
  }
 
  public static byte[] asymetricDecrypt(byte[] inpBytes) throws Exception {
    initKeys();
    KeyPair kp = (KeyPair) getFromFile(new File(ElephantContext.getRealPath(PAIR_KEY_FILE)));
    return AsymetricCipher.decrypt(inpBytes, kp.getPublic());
  }
 
  private static Serializable getFromFile(File file) {
    Serializable obj = null;
 
    FileInputStream fis = null;
    ObjectInputStream ois = null;
 
    try {
      fis = new FileInputStream(file);
      ois = new ObjectInputStream(fis);
 
      obj = (Serializable) ois.readObject();
 
      fis.close();
      ois.close();
 
    } catch (ClassNotFoundException | IOException e) {
      Logger.getLogger(Cipher.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), e);
    }
 
    return obj;
  }
 
  private static void saveToFile(Serializable obj, File file) {
    file.delete();
 
    FileOutputStream fos = null;
    ObjectOutputStream oos = null;
 
    try {
      fos = new FileOutputStream(file);
      oos = new ObjectOutputStream(fos);
 
      oos.writeObject(obj);
 
      fos.close();
      oos.close();
 
    } catch (FileNotFoundException e) {
      Logger.getLogger(Cipher.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), e);
    } catch (IOException e) {
      Logger.getLogger(Cipher.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), e);
    }
  }
 
  private Cipher() {
  }
 
}