/**
* @(#) EncryptUtil.java
*/
package edu.hust.util.security;
import java.security.*;
import javax.crypto.*;
import java.io.*;
/**
* HexStringUtil is a util tool for manipulating conversion between hex and string
*/
class HexStringUtil {
/**
* hex digits
*/
private static final String[] hexDigits = {
"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "a", "b", "c", "d", "e", "f"
};
/**
* Convert byte array to hex string
* @param b byte array
* @return hex string
*/
public static String byteArrayToHexString( byte[] b ) {
StringBuffer buf = new StringBuffer();
for( int i = 0; i < b.length; i++) {
buf.append( byteToHexString( b[i]));
}
return buf.toString();
}
/**
* Convert byte to hex String
* @param b byte
* @return hex String
*/
private static String byteToHexString( byte b ) {
int n = b;
// n < 0 then make n positive
if( n < 0 ) {
n += 256;
}
int d1 = n >> 4; // upper bit
int d2 = n % 16; // lower bit
return hexDigits[d1] + hexDigits[d2];
}
}
/**
* EncryptException is an exception class from exception, handles any exceptions that
* may happen in the encryption/descryption.
*/
class EncryptException extends Exception {
/**
* Construct a new EncryptException
*/
public EncryptException() {
super();
}
/**
* Construct a new EncryptException
* @param msg exception message
*/
public EncryptException( String msg ) {
super( msg );
}
/**
* Construct a new EncryptException
* @ex exception
*/
public EncryptException( Throwable ex ) {
super( ex );
}
}
/**
* EncryptUtil is a util tool for implementing private key encrypt/decrypt algorithm,
* which can handle encrypt and decrypt cases.
* @author quickpoint
* @version 1.0 06/22/2005
*/
public class EncryptUtil {
/**
* DES algorithm
*/
public static final String DES = "DES";
/**
* DESede algorithm
*/
public static final String DESede = "DESede";
/**
* BlowFish algorithm
*/
public static final String BLOWFISH = "BlowFish";
/**
* SecretKey
*/
private static SecretKey key = null;
///
// Encrypt
///
/**
* Encrypt with algorithm
* @param origin plain text
* @algorithm algorithm used in encrypt
* @return cipher text( in byte )
* @exception EncryptException throws when any exception happed in encryption
*/
public static byte[] encrypt( String origin, String algorithm )
throws EncryptException
{
try {
// add new secruity algorithm
Security.addProvider( new com.sun.crypto.provider.SunJCE());
KeyGenerator keygen = KeyGenerator.getInstance( algorithm );
// generate key
key = keygen.generateKey();
// doing encryption
Cipher cipher = Cipher.getInstance( algorithm );
cipher.init(Cipher.ENCRYPT_MODE, key );
byte[] cipherByte = cipher.doFinal( origin.getBytes());
return cipherByte;
} catch ( Exception ex ) {
throw new EncryptException( ex );
}
}
/**
* Encrypt with DES
* @param origin plain text
* @return cipher text( in byte )
* @exception EncryptException throws when any exception happed in encryption
*/
public static byte[] encryptWithDES( String origin)
throws EncryptException
{
return encrypt( origin, EncryptUtil.DES);
}
/**
* Encrypt with DESede
* @param origin plain text
* @return cipher text( in byte )
* @exception EncryptException throws when any exception happed in encryption
*/
public static byte[] encryptWithDESede( String origin )
throws EncryptException
{
return encrypt( origin, EncryptUtil.DESede);
}
/**
* Encrypt with BlowFish
* @param origin plain text
* @return cipher text( in byte )
* @exception EncryptException throws when any exception happed in encryption
*/
public static byte[] encryptWithBlowFish( String origin )
throws EncryptException
{
return encrypt( origin, EncryptUtil.BLOWFISH);
}
/**
* Encrypt with algorithm and convert to string form
* @param origin plain text
* @param algorithm algorithm used in encryption
* @return cipher text( in hex string ) or null
*/
public static String encryptToString( String origin, String algorithm ) {
try {
byte[] cipherByte = encrypt( origin, algorithm);
return HexStringUtil.byteArrayToHexString( cipherByte);
} catch ( EncryptException ex) {
return null;
}
}
/**
* Encrypt with DES and convert to string form
* @param origin plain text
* @return cipher text( in hex string ) or null
*/
public static String encryptToStringWithDES( String origin ) {
return encryptToString( origin, EncryptUtil.DES);
}
/**
* Encrypt with DESede and convert to string form
* @param origin plain text
* @return cipher text( in hex string ) or null
*/
public static String encryptToStringWithDESede( String origin ) {
return encryptToString( origin, EncryptUtil.DESede);
}
/**
* Encrypt with BlowFish and convert to string form
* @param origin plain text
* @return cipher text( in hex string ) or null
*/
public static String encryptToStringWithBlowFish( String origin ) {
return encryptToString( origin, EncryptUtil.BLOWFISH);
}
/
// Descrypt
/
/**
* Descrypt with algorithm
* @param cipherByte cipher byte
* @param encryptKey encrypt key
* @param algorithm algorithm used in descryption
* @return plain text( in byte )
* @exception EncryptException throws when any exception happened in descryption
*/
public static byte[] descrypt( byte[] cipherByte, SecretKey encryptKey, String algorithm )
throws EncryptException
{
try {
Security.addProvider( new com.sun.crypto.provider.SunJCE());
Cipher cipher = Cipher.getInstance( algorithm );
cipher.init( Cipher.DECRYPT_MODE, encryptKey );
byte[] plainByte = cipher.doFinal( cipherByte );
return plainByte;
} catch ( Exception ex ) {
throw new EncryptException( ex );
}
}
/**
* Descrypt with algorithm
* @param cipherByte cipher byte
* @param algorithm algorithm used in descryption
* @return plain text( in byte )
* @exception EncryptException throws when any exception happened in descryption
*/
public static byte[] descrypt( byte[] cipherByte, String algorithm )
throws EncryptException
{
return descrypt( cipherByte, key, algorithm );
}
/**
* Descrypt with DES
* @param cipherByte cipher byte
* @param encryptKey encrypt key
* @return plain text( in byte )
* @exception EncryptException throws when any exception happened in descryption
*/
public static byte[] descryptWithDES( byte[] cipherByte, SecretKey encryptKey )
throws EncryptException
{
return descrypt( cipherByte, encryptKey, EncryptUtil.DES );
}
/**
* Descrypt with MD5
* @param cipherByte cipher byte
* @return plain text( in byte )
* @exception EncryptException throws when any exception happened in descryption
*/
public static byte[] descryptWithDES( byte[] cipherByte )
throws EncryptException
{
return descrypt( cipherByte, EncryptUtil.DES);
}
/**
* Descrypt with DESede
* @param cipherByte cipher byte
* @param encryptKey encrypt key
* @return plain text( in byte )
* @exception EncryptException throws when any exception happened in descryption
*/
public static byte[] descryptWithDESede( byte[] cipherByte, SecretKey encryptKey )
throws EncryptException
{
return descrypt( cipherByte, encryptKey, EncryptUtil.DESede);
}
/**
* Descrypt with DESede
* @param cipherByte cipher byte
* @return plain text( in byte )
* @exception EncryptException throws when any exception happened in descryption
*/
public static byte[] descryptWithDESede( byte[] cipherByte )
throws EncryptException
{
return descrypt( cipherByte, EncryptUtil.DESede);
}
/**
* Descrypt with BlowFish
* @param cipherByte cipher byte
* @param encryptKey encrypt key
* @return plain text( in byte )
* @exception EncryptException throws when any exception happened in descryption
*/
public static byte[] descryptWithBlowFish( byte[] cipherByte, SecretKey encryptKey )
throws EncryptException
{
return descrypt( cipherByte, encryptKey, EncryptUtil.BLOWFISH);
}
/**
* Descrypt with BlowFish
* @param cipherByte cipher byte
* @return plain text( in byte )
* @exception EncryptException throws when any exception happened in descryption
*/
public static byte[] descryptWithBlowFish( byte[] cipherByte)
throws EncryptException
{
return descrypt( cipherByte, EncryptUtil.BLOWFISH);
}
/**
* Descrypt with algorithm and convert to string form
* @param cipherByte cipher byte
* @param encryptKey encrypt key
* @param algorithm algorithm used in descryption
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToString( byte[] cipherByte, SecretKey secretKey, String algorithm ) {
try {
byte[] plainByte = descrypt( cipherByte, secretKey, algorithm );
return HexStringUtil.byteArrayToHexString( plainByte );
} catch ( EncryptException ex ) {
return null;
}
}
/**
* Descrypt with algorithm and convert to string form
* @param cipherByte cipher byte
* @param algorithm algorithm used in descryption
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToString( byte[] cipherByte, String algorithm ) {
return descryptToString( cipherByte, key, algorithm );
}
/**
* Descrypt with algorithm and convert to string form
* @param cipherStr cipher string
* @param algorithm algorithm used in descryption
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToString( String cipherStr, String algorithm ) {
return descryptToString( cipherStr.getBytes(), algorithm );
}
/**
* Descrypt with DES and convert to string form
* @param cipherByte cipher byte
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToStringWithDES( byte[] cipherByte ) {
return descryptToString( cipherByte, EncryptUtil.DES);
}
/**
* Descrypt with DES and convert to string form
* @param cipherStr cipher string
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToStringWithDES( String cipherStr ) {
return descryptToStringWithDES( cipherStr.getBytes());
}
/**
* Descrypt with DESede and convert to string form
* @param cipherByte cipher byte
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToStringWithDESede( byte[] cipherByte ) {
return descryptToString( cipherByte, EncryptUtil.DESede);
}
/**
* Descrypt with DESede and convert to string form
* @param cipherStr cipher string
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToStringWithDESede( String cipherStr ) {
return descryptToStringWithDESede( cipherStr.getBytes());
}
/**
* Descrypt with BlowFish and convert to string form
* @param cipherByte cipher byte
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToStringWithBlowFish( byte[] cipherByte ) {
return descryptToString( cipherByte, EncryptUtil.BLOWFISH);
}
/**
* Descrypt with BlowFish and convert to string form
* @param cipherStr cipher string
* @return plain text( in string ) or null
* @exception EncryptException throws when any exception happened in descryption
*/
public static String descryptToStringWithBlowFish( String cipherStr ) {
return descryptToStringWithBlowFish( cipherStr.getBytes());
}
//
// SecretKey handler
//
/**
* Store secret key to file
* @param fileName name of file
*/
public static void storeKeyToFile( String fileName ) {
try {
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream( fileName ));
out.writeObject( key );
out.close();
} catch ( IOException ex ) {
ex.printStackTrace();
}
}
/**
* Store secret key to file
* @param fileName name of file
* @param secretKey secret key to be stored
*/
public static void storeKeyToFile( String fileName, SecretKey secretKey ) {
key = secretKey;
storeKeyToFile( fileName );
}
/**
* Restore secret key from file and assgign to variable key
* @param fileName name of file
* @return true if success ,or else return false
*/
public static boolean restoreKeyFromFile( String fileName ) {
key = attainKeyFromFile( fileName );
return ( null != key );
}
/**
* Attain secret key from file
* @param fileName name of file
* @return secret key or null
*/
private static SecretKey attainKeyFromFile( String fileName ) {
SecretKey secretKey = null;
try {
ObjectInputStream in = new ObjectInputStream(
new FileInputStream( fileName));
secretKey = (SecretKey)in.readObject();
in.close();
} catch (IOException ioex ) {
ioex.printStackTrace();
} catch ( ClassNotFoundException classNotFoundEx ) {
classNotFoundEx.printStackTrace();
}
return secretKey;
}
// main , just for test
public static void main( String[] args ) {
try {
String cipherText = "quickpoint";
String fileName = "key.txt";
byte[] cipherByte = encryptWithDES( cipherText);
storeKeyToFile( fileName );
boolean success = restoreKeyFromFile( fileName );
if( success ) {
byte[] plainByte = descryptWithDES( cipherByte );
System.out.println( new String( plainByte ) );
}
} catch (EncryptException ex ) {
ex.printStackTrace();
}
}
}