/*
    * Copyright 2006-2008 The Kuali Foundation
    * 
    * Licensed under the Educational Community License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    * http://www.opensource.org/licenses/ecl2.php
    * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.rice.core.service.impl;
  
  import java.io.UnsupportedEncodingException;
  import java.security.GeneralSecurityException;
  import java.security.MessageDigest;
  
  import javax.crypto.Cipher;
  import javax.crypto.KeyGenerator;
  import javax.crypto.SecretKey;
  import javax.crypto.SecretKeyFactory;
  import javax.crypto.spec.DESKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  import org.apache.commons.lang.StringUtils;
  import org.kuali.rice.core.config.ConfigContext;
  import org.kuali.rice.core.service.Demonstration;
  import org.kuali.rice.core.service.EncryptionService;
  
  /**
   * Implementation of encryption service for demonstration. 
   * 
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class DemonstrationGradeEncryptionServiceImpl implements EncryptionService, Demonstration {
      public final static String ALGORITHM = "DES/ECB/PKCS5Padding";
      public final static String HASH_ALGORITHM = "SHA"; 
  
      private final static String CHARSET = "UTF-8";
  
      private transient SecretKey desKey;
  
      private boolean isEnabled = false;
  
      public DemonstrationGradeEncryptionServiceImpl() throws Exception {
          if (desKey != null) {
              throw new RuntimeException("The secret key must be kept secret. Storing it in the Java source code is a really bad idea.");
          }
          String key = ConfigContext.getCurrentContextConfig().getProperty("encryption.key");
          if (!StringUtils.isEmpty(key)) {
              setSecretKey(key);
          }
      }
      
      public boolean isEnabled() {
          return isEnabled;
      }
  
      public String encrypt(Object valueToHide) throws GeneralSecurityException {
      	checkEnabled();
      	
          if (valueToHide == null) {
              return "";
          }
  
          // Initialize the cipher for encryption
          Cipher cipher = Cipher.getInstance(ALGORITHM);
          cipher.init(Cipher.ENCRYPT_MODE, desKey);
  
          try {
              // Our cleartext
              byte[] cleartext = valueToHide.toString().getBytes(CHARSET);
      
              // Encrypt the cleartext
              byte[] ciphertext = cipher.doFinal(cleartext);
      
              return new String(Base64.encodeBase64(ciphertext), CHARSET);
          } catch (Exception e) {
              throw new RuntimeException(e);
          }
  
      }
  
      public String decrypt(String ciphertext) throws GeneralSecurityException {
      	checkEnabled();
      	
          if (StringUtils.isBlank(ciphertext)) {
              return "";
          }
  
          // Initialize the same cipher for decryption
          Cipher cipher = Cipher.getInstance(ALGORITHM);
          cipher.init(Cipher.DECRYPT_MODE, desKey);
  
          try {
             // un-Base64 encode the encrypted data
             byte[] encryptedData = Base64.decodeBase64(ciphertext.getBytes(CHARSET));
 
             // Decrypt the ciphertext
             byte[] cleartext1 = cipher.doFinal(encryptedData);
             return new String(cleartext1, CHARSET);
         } catch (UnsupportedEncodingException e) {
             throw new RuntimeException(e);
         }
     }
 
     public byte[] encryptBytes(byte[] valueToHide) throws GeneralSecurityException {
     	checkEnabled();
     	
         if (valueToHide == null) {
             return new byte[0];
         }
 
         // Initialize the cipher for encryption
         Cipher cipher = Cipher.getInstance(ALGORITHM);
         cipher.init(Cipher.ENCRYPT_MODE, desKey);
 
         // Our cleartext
         byte[] cleartext = valueToHide;
 
         // Encrypt the cleartext
         byte[] ciphertext = cipher.doFinal(cleartext);
 
         return ciphertext;
     }
 
     public byte[] decryptBytes(byte[] ciphertext) throws GeneralSecurityException {
     	checkEnabled();
     	
         if (ciphertext == null) {
             return new byte[0];
         }
 
         // Initialize the same cipher for decryption
         Cipher cipher = Cipher.getInstance(ALGORITHM);
         cipher.init(Cipher.DECRYPT_MODE, desKey);
 
         // un-Base64 encode the encrypted data
         byte[] encryptedData = ciphertext;
 
         // Decrypt the ciphertext
         byte[] cleartext1 = cipher.doFinal(encryptedData);
         return cleartext1;
     }
     
     /**
      * 
      * This method generates keys. This method is implementation specific and should not be present in any general purpose interface
      * extracted from this class.
      * 
      * @return
      * @throws Exception
      */
     public static String generateEncodedKey() throws Exception {
         KeyGenerator keygen = KeyGenerator.getInstance("DES");
         SecretKey desKey = keygen.generateKey();
 
         // Create the cipher
         Cipher cipher = Cipher.getInstance(ALGORITHM);
         cipher.init((Cipher.WRAP_MODE), desKey);
         
         SecretKeyFactory desFactory = SecretKeyFactory.getInstance("DES");
         DESKeySpec desSpec = (DESKeySpec) desFactory.getKeySpec(desKey, javax.crypto.spec.DESKeySpec.class);
         byte[] rawDesKey = desSpec.getKey();
 
         return new String(Base64.encodeBase64(rawDesKey));
     }
 
     private SecretKey unwrapEncodedKey(String key) throws Exception {
         KeyGenerator keygen = KeyGenerator.getInstance("DES");
         SecretKey desKey = keygen.generateKey();
 
         // Create the cipher
         Cipher cipher = Cipher.getInstance(ALGORITHM);
         cipher.init((Cipher.UNWRAP_MODE), desKey);
 
         byte[] bytes = Base64.decodeBase64(key.getBytes());
 
         SecretKeyFactory desFactory = SecretKeyFactory.getInstance("DES");
 
         DESKeySpec keyspec = new DESKeySpec(bytes);
         SecretKey k = desFactory.generateSecret(keyspec);
 
         return k;
 
     }
 
     /**
      * Sets the secretKey attribute value.
      * 
      * @param secretKey The secretKey to set.
      * @throws Exception
      */
     public void setSecretKey(String secretKey) throws Exception {
     	if (!StringUtils.isEmpty(secretKey)) {
     		desKey = this.unwrapEncodedKey(secretKey);
     		isEnabled = true;
     		// Create the cipher
     		Cipher cipher = Cipher.getInstance(ALGORITHM);
     		cipher.init((Cipher.WRAP_MODE), desKey);
     	}
     }
 
     /** Hash the value by converting to a string, running the hash algorithm, and then base64'ng the results.
      * Returns a blank string if any problems occur or the input value is null or empty.
      * 
      * @see org.kuali.rice.kns.service.EncryptionService#hash(java.lang.Object)
      */
     public String hash(Object valueToHide) throws GeneralSecurityException {
         if ( valueToHide == null || StringUtils.isEmpty( valueToHide.toString() ) ) {
             return "";
         }
         try {
             MessageDigest md = MessageDigest.getInstance(HASH_ALGORITHM);
             return new String( Base64.encodeBase64( md.digest( valueToHide.toString().getBytes( CHARSET ) ) ), CHARSET );
         } catch ( UnsupportedEncodingException ex ) {
             // should never happen
         }
         return "";
     }
     
     /**
      * Performs a check to see if the encryption service is enabled.  If it is not then an
      * IllegalStateException will be thrown.
      */
     protected void checkEnabled() {
     	if (!isEnabled()) {
     		throw new IllegalStateException("Illegal use of encryption service.  Ecryption service is disabled, to enable please configure 'encryption.key'.");
     	}
     }
 
     
 
 }