/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited

  *

  * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0

  *

  * 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.acegisecurity.util;

 import java.io.UnsupportedEncodingException;

 import java.security.spec.KeySpec;

 import javax.crypto.Cipher;

 import javax.crypto.SecretKey;

 import javax.crypto.SecretKeyFactory;

 import javax.crypto.spec.DESedeKeySpec;

 import org.acegisecurity.AcegiSecurityException;

 import org.apache.commons.codec.binary.Base64;

 import org.springframework.util.Assert;

 /**

  * A static utility class that can encrypt and decrypt text.

  *

  * <p>This class is useful if you have simple needs and wish to use the DESede

  * encryption cipher. More sophisticated requirements will need to use the

  * Java crypto libraries directly.

  *

  * @author Alan Stewart

  * @author Ben Alex

  * @version $Id: EncryptionUtils.java 1784 2007-02-24 21:00:24Z luke_t $

  */

 public final class EncryptionUtils {

     /**

      * This is a static class that should not be instantiated.

      */

     private EncryptionUtils() {}

     /**

      * Converts a String into a byte array using UTF-8, falling back to the

      * platform's default character set if UTF-8 fails.

      *

      * @param input the input (required)

      * @return a byte array representation of the input string

      */

     public static byte[] stringToByteArray(String input) {

         Assert.hasLength(input, "Input required");

         try {

             return input.getBytes("UTF-8");

         } catch (UnsupportedEncodingException fallbackToDefault) {

             return input.getBytes();

         }

     }

     /**

      * Converts a byte array into a String using UTF-8, falling back to the

      * platform's default character set if UTF-8 fails.

      *

      * @param byteArray the byte array to convert (required)

      * @return a string representation of the byte array

      */

     public static String byteArrayToString(byte[] byteArray) {

         Assert.notNull(byteArray, "ByteArray required");

         Assert.isTrue(byteArray.length > 0, "ByteArray cannot be empty");

         try {

             return new String(byteArray, "UTF8");

         } catch (final UnsupportedEncodingException e) {

             return new String(byteArray);

         }

     }

     private static byte[] cipher(String key, byte[] passedBytes, int cipherMode) throws EncryptionException {

         try {

             final KeySpec keySpec = new DESedeKeySpec(stringToByteArray(key));

             final SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");

             final Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");

             final SecretKey secretKey = keyFactory.generateSecret(keySpec);

             cipher.init(cipherMode, secretKey);

             return cipher.doFinal(passedBytes);

         } catch (final Exception e) {

             throw new EncryptionException(e.getMessage(), e);

         }

     }

     /**

      * Encrypts the inputString using the key.

      *

      * @param key at least 24 character long key (required)

      * @param inputString the string to encrypt (required)

      * @return the encrypted version of the inputString

      * @throws EncryptionException in the event of an encryption failure

      */

     public static String encrypt(String key, String inputString) throws EncryptionException {

         isValidKey(key);

         final byte[] cipherText = cipher(key, stringToByteArray(inputString), Cipher.ENCRYPT_MODE);

         return byteArrayToString(Base64.encodeBase64(cipherText));

     }

     /**

      * Encrypts the inputBytes using the key.

      *

      * @param key at least 24 character long key (required)

      * @param inputBytes the bytes to encrypt (required)

      * @return the encrypted version of the inputBytes

      * @throws EncryptionException in the event of an encryption failure

      */

     public static byte[] encrypt(String key, byte[] inputBytes) throws EncryptionException {

         isValidKey(key);

         return Base64.encodeBase64(cipher(key, inputBytes, Cipher.ENCRYPT_MODE));

     }

     /**

      * Decrypts the inputString using the key.

      *

      * @param key the key used to originally encrypt the string (required)

      * @param inputString the encrypted string (required)

      * @return the decrypted version of inputString

      * @throws EncryptionException in the event of an encryption failure

      */

     public static String decrypt(String key, String inputString) throws EncryptionException {

         Assert.hasText(key, "A key is required to attempt decryption");

         final byte[] cipherText = cipher(key, Base64.decodeBase64(stringToByteArray(inputString)), Cipher.DECRYPT_MODE);

         return byteArrayToString(cipherText);

     }

     /**

      * Decrypts the inputBytes using the key.

      *

      * @param key the key used to originally encrypt the string (required)

      * @param inputBytes the encrypted bytes (required)

      * @return the decrypted version of inputBytes

      * @throws EncryptionException in the event of an encryption failure

      */

     public static byte[] decrypt(String key, byte[] inputBytes) throws EncryptionException {

         Assert.hasText(key, "A key is required to attempt decryption");

         return cipher(key, Base64.decodeBase64(inputBytes), Cipher.DECRYPT_MODE);

     }

     private static void isValidKey(String key) {

         Assert.hasText(key, "A key to perform the encryption is required");

         Assert.isTrue(key.length() >= 24, "Key must be at least 24 characters long");

     }

     public static class EncryptionException extends AcegiSecurityException {

         private static final long serialVersionUID = 1L;

         public EncryptionException(String message, Throwable t) {

             super(message, t);

         }

         public EncryptionException(String message) {

             super(message);

         }

     }

 }