/* infoScoop OpenSource
* Copyright (C) 2010 Beacon IT Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* as published by the Free Software Foundation.
*
* 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program. If not, see
* <http://www.gnu.org/licenses/lgpl-3.0-standalone.html>.
*/
//package org.infoscoop.util;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class Crypt {
private static final Crypt thisInstance = new Crypt();
private static final long serialVersionUID = 7490854493720551678L;
private static Log log = LogFactory.getLog(Crypt.class);
public static final byte ENCRYPT = 0;
public static final byte DECRYPT = 1;
private static SecretKey secretKey;
private Crypt() {
DESKeySpec dk;
try {
dk = new DESKeySpec(new Long(serialVersionUID).toString().getBytes());
SecretKeyFactory kf = SecretKeyFactory.getInstance("DES");
secretKey = kf.generateSecret(dk);
} catch (Exception e) {
log.error("", e);
}
}
public static Crypt gerCryptInstance() {
return thisInstance;
}
public String doCrypt(byte mode, String str) throws Exception {
if (Crypt.DECRYPT == mode) {
return decryptByDES(str);
} else if (Crypt.ENCRYPT == mode) {
return encryptByDES(str);
}
return "";
}
private String encryptByDES(String str) throws Exception{
Cipher c;
try {
c = Cipher.getInstance("DES/ECB/PKCS5Padding");
c.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encrypted = c.doFinal(str.getBytes());
// convert into hexadecimal number, and return as character string.
String result = "";
for (int i = 0; i < encrypted.length; i++) {
result += byte2HexStr(encrypted[i]);
}
return result;
} catch (InvalidKeyException e) {
log.error("The information of the private key may be broken.", e);
throw e;
} catch (IllegalBlockSizeException e) {
log.error("The length of data is unjust.", e);
throw e;
}
}
private String decryptByDES(String str) throws Exception{
Cipher c;
try {
byte[] tmp = new byte[str.length()/2];
int index = 0;
while (index < str.length()) {
// convert hexadecimal number into decimal number.
int num = Integer.parseInt(str.substring(index, index + 2), 16);
// convert into signed byte.
if (num < 128) {
tmp[index/2] = new Byte(Integer.toString(num)).byteValue();
} else {
tmp[index/2] = new Byte(Integer.toString(((num^255)+1)*-1)).byteValue();
}
index += 2;
}
c = Cipher.getInstance("DES/ECB/PKCS5Padding");
c.init(Cipher.DECRYPT_MODE, secretKey);
return new String(c.doFinal(tmp));
} catch (InvalidKeyException e) {
log.error("The information of the private key may be broken.", e);
throw e;
} catch (IllegalBlockSizeException e) {
log.error("he length of data is unjust.", e);
throw e;
}
}
private String byte2HexStr(byte binary) {
StringBuffer sb= new StringBuffer();
int hex;
hex = (int)binary & 0x000000ff;
if (0 != (hex & 0xfffffff0)) {
sb.append(Integer.toHexString(hex));
} else {
sb.append("0" + Integer.toHexString(hex));
}
return sb.toString();
}
public static String getHash(String data){
return getHash(data, "SHA-256");
}
public static String getHash(String data, String algorithm) {// create a digest from character string
MessageDigest md = null;
try{
md = MessageDigest.getInstance(algorithm);
}catch(NoSuchAlgorithmException e){
log.error("", e);
return null;
}
byte[] dat = data.getBytes();
md.update(dat);// calculate a digest from a dat arrangement.
byte[] digest = md.digest();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < digest.length; i++) {
int d = digest[i];
if (d < 0) {// revise it because 128-255 become minus number value with byte type.
d += 256;
}
if (d < 16) {// Because it become one column by a hex digit, if it is 0-15, we add "0" to a head to become two columns.
sb.append("0");
}
sb.append(Integer.toString(d, 16));// display 1 byte of the digest value with hexadecimal two columns
}
return sb.toString();
}
}
|
