package comcubelimailutil;
import javaxcryptoCipher;
import javaxcryptoKeyGenerator;
import javaxcryptoSecretKey;/
加密解密类
/
public class Eryptogram
{
private static String Algorithm ="DES";
private String key="CB7A92E3D3491964";
//定义 加密算法,可用 DES,DESede,Blowfish
static boolean debug = false ;
/
构造子注解
/
public Eryptogram ()
{
} /
生成密钥
@return byte[] 返回生成的密钥
@throws exception 扔出异常
/
public static byte [] getSecretKey () throws Exception
{
KeyGenerator keygen = KeyGeneratorgetInstance (Algorithm );
SecretKey deskey = keygengenerateKey ();
Systemoutprintln ("生成密钥:"+bytesToHexString (deskeygetEncoded ()));
if (debug ) Systemoutprintln ("生成密钥:"+bytesToHexString (deskeygetEncoded ()));
return deskeygetEncoded ();
} /
将指定的数据根据提供的密钥进行加密
@param input 需要加密的数据
@param key 密钥
@return byte[] 加密后的数据
@throws Exception
/
public static byte [] encryptData (byte [] input ,byte [] key ) throws Exception
{
SecretKey deskey = new javaxcryptospecSecretKeySpec (key ,Algorithm );
if (debug )
{
Systemoutprintln ("加密前的二进串:"+byte2hex (input ));
Systemoutprintln ("加密前的字符串:"+new String (input ));
} Cipher c1 = CiphergetInstance (Algorithm );
c1init (CipherENCRYPT_MODE ,deskey );
byte [] cipherByte =c1doFinal (input );
if (debug ) Systemoutprintln ("加密后的二进串:"+byte2hex (cipherByte ));
return cipherByte ;
} /
将给定的已加密的数据通过指定的密钥进行解密
@param input 待解密的数据
@param key 密钥
@return byte[] 解密后的数据
@throws Exception
/
public static byte [] decryptData (byte [] input ,byte [] key ) throws Exception
{
SecretKey deskey = new javaxcryptospecSecretKeySpec (key ,Algorithm );
if (debug ) Systemoutprintln ("解密前的信息:"+byte2hex (input ));
Cipher c1 = CiphergetInstance (Algorithm );
c1init (CipherDECRYPT_MODE ,deskey );
byte [] clearByte =c1doFinal (input );
if (debug )
{
Systemoutprintln ("解密后的二进串:"+byte2hex (clearByte ));
Systemoutprintln ("解密后的字符串:"+(new String (clearByte )));
} return clearByte ;
} /
字节码转换成16进制字符串
@param byte[] b 输入要转换的字节码
@return String 返回转换后的16进制字符串
/
public static String byte2hex (byte [] b )
{
String hs ="";
String stmp ="";
for (int n =0 ;n <blength ;n ++)
{
stmp =(javalangIntegertoHexString (b [n ] & 0XFF ));
if (stmplength ()==1 ) hs =hs +"0"+stmp ;
else hs =hs +stmp ;
if (n <blength -1 ) hs =hs +":";
} return hstoUpperCase ();
}
/
字符串转成字节数组
@param hex 要转化的字符串
@return byte[] 返回转化后的字符串
/
public static byte[] hexStringToByte(String hex) {
int len = (hexlength() / 2);
byte[] result = new byte[len];
char[] achar = hextoCharArray();
for (int i = 0; i < len; i++) {
int pos = i 2;
result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
}
return result;
}
private static byte toByte(char c) {
byte b = (byte) "0123456789ABCDEF"indexOf(c);
return b;
}
/
字节数组转成字符串
@param String 要转化的字符串
@return 返回转化后的字节数组
/
public static final String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArraylength);
String sTemp;
for (int i = 0; i < bArraylength; i++) {
sTemp = IntegertoHexString(0xFF & bArray[i]);
if (sTemplength() < 2)
sbappend(0);
sbappend(sTemptoUpperCase());
}
return sbtoString();
}
/
从数据库中获取密钥
@param deptid 企业id
@return 要返回的字节数组
@throws Exception 可能抛出的异常
/
public static byte[] getSecretKey(long deptid) throws Exception {
byte[] key=null;
String value=null;
//CommDao dao=new CommDao();
// List list=daogetRecordList("from Key k where kdeptid="+deptid);
//if(listsize()>0){
//value=((comcscsalebeanKey)listget(0))getKey();
value = "CB7A92E3D3491964";
key=hexStringToByte(value);
//}
if (debug)
Systemoutprintln("密钥:" + value);
return key;
}
public String encryptData2(String data) {
String en = null;
try {
byte[] key=hexStringToByte(thiskey);
en = bytesToHexString(encryptData(datagetBytes(),key));
} catch (Exception e) {
eprintStackTrace();
}
return en;
}
public String decryptData2(String data) {
String de = null;
try {
byte[] key=hexStringToByte(thiskey);
de = new String(decryptData(hexStringToByte(data),key));
} catch (Exception e) {
eprintStackTrace();
}
return de;
}
} 加密使用： byte[] key=EryptogramgetSecretKey(deptid); //获得钥匙（字节数组）
byte[] tmp=EryptogramencryptData(passwordgetBytes(), key); //传入密码和钥匙，获得加密后的字节数组的密码
password=EryptogrambytesToHexString(tmp); //将字节数组转化为字符串，获得加密后的字符串密码解密与之差不多
Cipher c=CiphergetInstance("AES");
cinit(cENCRYPT_MODE,new SecretKeySpec("1111111111111111"getBytes(),"AES"));
FileOutputStream fos=new FileOutputStream("/1dat");
foswrite(cdoFinal("我神不是人啊~~"getBytes()));
cinit(cDECRYPT_MODE,new SecretKeySpec("1111111111111111"getBytes(),"AES"));
FileInputStream fin=new FileInputStream("/1dat");
byte b[]=new byte[1024];
Systemoutprintln(new String(cdoFinal(b,0,finread(b))));
Java是一种跨平台的、解释型语言。Java 源代码编译中间“字节码”存储于class文件中。Class文件是一种字节码形式的中间代码，该字节码中包括了很多源代码的信息，例如变量名、方法名等。因此，Java中间代码的反编译就变得非常轻易。目前市场上有许多免费的、商用的反编译软件，都能够生成高质量的反编译后的源代码。所以，对开发人员来说，如何保护Java程序就变成了一个非常重要的挑战。本文首先讨论了保护Java程序的基本方法，然后对代码混淆问题进行深入研究，最后结合一个实际的应用程序，分析如何在实践中保护Java程序。
反编译成为保护Java程序的最大挑战通常C、C++等编程语言开发的程序都被编译成目标代码，这些目标代码都是本机器的二进制可执行代码。通常所有的源文件被编译、链接成一个可执行文件。在这些可执行文件中，编译器删除了程序中的变量名称、方法名称等信息，这些信息往往是由内存地址表示，例如假如需要使用一个变量，往往是通过这个变量的地址来访问的。因此，反编译这些本地的目标代码就是非常困难的。
Java语言的出现，使得反编译变得非常轻易而有效。原因如下：1由于跨平台的需求，Java的指令集比较简单而通用，较轻易得出程序的语义信息；2Java编译器将每一个类编译成一个单独的文件，这也简化了反编译的工作；3Java 的Class文件中，仍然保留所有的方法名称、变量名称，并且通过这些名称来访问变量和方法，这些符号往往带有许多语义信息。由于Java程序自身的特点，对于不经过处理的Java程序反编译的效果非常好。
目前，市场上有许多Java的反编译工具，有免费的，也有商业使用的，还有的是开放源代码的。这些工具的反编译速度和效果都非常不错。好的反编译软件，能够反编译出非常接近源代码的程序。因此，通过反编译器，黑客能够对这些程序进行更改，或者复用其中的程序。因此，如何保护Java程序不被反编译，是非常重要的一个问题。
常用的保护技术由于Java字节码的抽象级别较高，因此它们较轻易被反编译。本节介绍了几种常用的方法，用于保护Java字节码不被反编译。通常，这些方法不能够绝对防止程序被反编译，而是加大反编译的难度而已，因为这些方法都有自己的使用环境和弱点。
隔离Java程序最简单的方法就是让用户不能够访问到Java Class程序，这种方法是最根本的方法，具体实现有多种方式。例如，开发人员可以将要害的Java Class放在服务器端，客户端通过访问服务器的相关接口来获得服务，而不是直接访问Class文件。这样黑客就没有办法反编译Class文件。目前，通过接口提供服务的标准和协议也越来越多，例如 >
/
SHA-1加密函数
/
public class SsytemSha1 {
private final int[] abcde = {
0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
};
// 摘要数据存储数组
private int[] digestInt = new int[5];
// 计算过程中的临时数据存储数组
private int[] tmpData = new int[80];
// 计算sha-1摘要
private int process_input_bytes(byte[] bytedata) {
// 初试化常量
Systemarraycopy(abcde, 0, digestInt, 0, abcdelength);
// 格式化输入字节数组，补10及长度数据
byte[] newbyte = byteArrayFormatData(bytedata);
// 获取数据摘要计算的数据单元个数
int MCount = newbytelength / 64;
// 循环对每个数据单元进行摘要计算
for (int pos = 0; pos < MCount; pos++) {
// 将每个单元的数据转换成16个整型数据，并保存到tmpData的前16个数组元素中
for (int j = 0; j < 16; j++) {
tmpData[j] = byteArrayToInt(newbyte, (pos 64) + (j 4));
}
// 摘要计算函数
encrypt();
}
return 20;
}
// 格式化输入字节数组格式
private byte[] byteArrayFormatData(byte[] bytedata) {
// 补0数量
int zeros = 0;
// 补位后总位数
int size = 0;
// 原始数据长度
int n = bytedatalength;
// 模64后的剩余位数
int m = n % 64;
// 计算添加0的个数以及添加10后的总长度
if (m < 56) {
zeros = 55 - m;
size = n - m + 64;
} else if (m == 56) {
zeros = 63;
size = n + 8 + 64;
} else {
zeros = 63 - m + 56;
size = (n + 64) - m + 64;
}
// 补位后生成的新数组内容
byte[] newbyte = new byte[size];
// 复制数组的前面部分
Systemarraycopy(bytedata, 0, newbyte, 0, n);
// 获得数组Append数据元素的位置
int l = n;
// 补1 *** 作
newbyte[l++] = (byte) 0x80;
// 补0 *** 作
for (int i = 0; i < zeros; i++) {
newbyte[l++] = (byte) 0x00;
}
// 计算数据长度，补数据长度位共8字节，长整型
long N = (long) n 8;
byte h8 = (byte) (N & 0xFF);
byte h7 = (byte) ((N >> 8) & 0xFF);
byte h6 = (byte) ((N >> 16) & 0xFF);
byte h5 = (byte) ((N >> 24) & 0xFF);
byte h4 = (byte) ((N >> 32) & 0xFF);
byte h3 = (byte) ((N >> 40) & 0xFF);
byte h2 = (byte) ((N >> 48) & 0xFF);
byte h1 = (byte) (N >> 56);
newbyte[l++] = h1;
newbyte[l++] = h2;
newbyte[l++] = h3;
newbyte[l++] = h4;
newbyte[l++] = h5;
newbyte[l++] = h6;
newbyte[l++] = h7;
newbyte[l++] = h8;
return newbyte;
}
private int f1(int x, int y, int z) {
return (x & y) | (~x & z);
}
private int f2(int x, int y, int z) {
return x ^ y ^ z;
}
private int f3(int x, int y, int z) {
return (x & y) | (x & z) | (y & z);
}
private int f4(int x, int y) {
return (x << y) | x >>> (32 - y);
}
// 单元摘要计算函数
private void encrypt() {
for (int i = 16; i <= 79; i++) {
tmpData[i] = f4(tmpData[i - 3] ^ tmpData[i - 8] ^ tmpData[i - 14] ^
tmpData[i - 16], 1);
}
int[] tmpabcde = new int[5];
for (int i1 = 0; i1 < tmpabcdelength; i1++) {
tmpabcde[i1] = digestInt[i1];
}
for (int j = 0; j <= 19; j++) {
int tmp = f4(tmpabcde[0], 5) +
f1(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4] +
tmpData[j] + 0x5a827999;
tmpabcde[4] = tmpabcde[3];
tmpabcde[3] = tmpabcde[2];
tmpabcde[2] = f4(tmpabcde[1], 30);
tmpabcde[1] = tmpabcde[0];
tmpabcde[0] = tmp;
}
for (int k = 20; k <= 39; k++) {
int tmp = f4(tmpabcde[0], 5) +
f2(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4] +
tmpData[k] + 0x6ed9eba1;
tmpabcde[4] = tmpabcde[3];
tmpabcde[3] = tmpabcde[2];
tmpabcde[2] = f4(tmpabcde[1], 30);
tmpabcde[1] = tmpabcde[0];
tmpabcde[0] = tmp;
}
for (int l = 40; l <= 59; l++) {
int tmp = f4(tmpabcde[0], 5) +
f3(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4] +
tmpData[l] + 0x8f1bbcdc;
tmpabcde[4] = tmpabcde[3];
tmpabcde[3] = tmpabcde[2];
tmpabcde[2] = f4(tmpabcde[1], 30);
tmpabcde[1] = tmpabcde[0];
tmpabcde[0] = tmp;
}
for (int m = 60; m <= 79; m++) {
int tmp = f4(tmpabcde[0], 5) +
f2(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4] +
tmpData[m] + 0xca62c1d6;
tmpabcde[4] = tmpabcde[3];
tmpabcde[3] = tmpabcde[2];
tmpabcde[2] = f4(tmpabcde[1], 30);
tmpabcde[1] = tmpabcde[0];
tmpabcde[0] = tmp;
}
for (int i2 = 0; i2 < tmpabcdelength; i2++) {
digestInt[i2] = digestInt[i2] + tmpabcde[i2];
}
for (int n = 0; n < tmpDatalength; n++) {
tmpData[n] = 0;
}
}
// 4字节数组转换为整数
private int byteArrayToInt(byte[] bytedata, int i) {
return ((bytedata[i] & 0xff) << 24) | ((bytedata[i + 1] & 0xff) << 16) |
((bytedata[i + 2] & 0xff) << 8) | (bytedata[i + 3] & 0xff);
}
// 整数转换为4字节数组
private void intToByteArray(int intValue, byte[] byteData, int i) {
byteData[i] = (byte) (intValue >>> 24);
byteData[i + 1] = (byte) (intValue >>> 16);
byteData[i + 2] = (byte) (intValue >>> 8);
byteData[i + 3] = (byte) intValue;
}
// 将字节转换为十六进制字符串
private static String byteToHexString(byte ib) {
char[] Digit = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
'D', 'E', 'F'
};
char[] ob = new char[2];
ob[0] = Digit[(ib >>> 4) & 0X0F];
ob[1] = Digit[ib & 0X0F];
String s = new String(ob);
return s;
}
// 将字节数组转换为十六进制字符串
private static String byteArrayToHexString(byte[] bytearray) {
String strDigest = "";
for (int i = 0; i < bytearraylength; i++) {
strDigest += byteToHexString(bytearray[i]);
}
return strDigest;
}
// 计算sha-1摘要，返回相应的字节数组
public byte[] getDigestOfBytes(byte[] byteData) {
process_input_bytes(byteData);
byte[] digest = new byte[20];
for (int i = 0; i < digestIntlength; i++) {
intToByteArray(digestInt[i], digest, i 4);
}
return digest;
}
// 计算sha-1摘要，返回相应的十六进制字符串
public String getDigestOfString(byte[] byteData) {
return byteArrayToHexString(getDigestOfBytes(byteData));
}
public static void main(String[] args) { //测试通过
String data = "123";
String digest = new SsytemSha1()getDigestOfString(datagetBytes());
}
}
java加密字符串可以使用des加密算法，实例如下：
package test;
import javaioFileInputStream;
import javaioFileOutputStream;
import javaioIOException;
import javaioObjectInputStream;
import javaioObjectOutputStream;
import javasecurity;
import javaxcryptoCipher;
import javaxcryptoKeyGenerator;
import javaxcryptoSecretKey;
/
加密解密
@author shyqiu
@since
/
public class CryptTest {
/
进行MD5加密
@param info
要加密的信息
@return String 加密后的字符串
/
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
// 得到一个md5的消息摘要
MessageDigest alga = MessageDigestgetInstance("MD5");
// 添加要进行计算摘要的信息
algaupdate(infogetBytes());
// 得到该摘要
digesta = algadigest();
} catch (NoSuchAlgorithmException e) {
eprintStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
/
进行SHA加密
@param info
要加密的信息
@return String 加密后的字符串
/
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
// 得到一个SHA-1的消息摘要
MessageDigest alga = MessageDigestgetInstance("SHA-1");
// 添加要进行计算摘要的信息
algaupdate(infogetBytes());
// 得到该摘要
digesta = algadigest();
} catch (NoSuchAlgorithmException e) {
eprintStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
// //////////////////////////////////////////////////////////////////////////
/
创建密匙
@param algorithm
加密算法,可用 DES,DESede,Blowfish
@return SecretKey 秘密（对称）密钥
/
public SecretKey createSecretKey(String algorithm) {
// 声明KeyGenerator对象
KeyGenerator keygen;
// 声明 密钥对象
SecretKey deskey = null;
try {
// 返回生成指定算法的秘密密钥的 KeyGenerator 对象
keygen = KeyGeneratorgetInstance(algorithm);
// 生成一个密钥
deskey = keygengenerateKey();
} catch (NoSuchAlgorithmException e) {
eprintStackTrace();
}
// 返回密匙
return deskey;
}
/
根据密匙进行DES加密
@param key
密匙
@param info
要加密的信息
@return String 加密后的信息
/
public String encryptToDES(SecretKey key, String info) {
// 定义 加密算法,可用 DES,DESede,Blowfish
String Algorithm = "DES";
// 加密随机数生成器 (RNG),(可以不写)
SecureRandom sr = new SecureRandom();
// 定义要生成的密文
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = CiphergetInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
// 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1init(CipherENCRYPT_MODE, key, sr);
// 对要加密的内容进行编码处理,
cipherByte = c1doFinal(infogetBytes());
} catch (Exception e) {
eprintStackTrace();
}
// 返回密文的十六进制形式
return byte2hex(cipherByte);
}
/
根据密匙进行DES解密
@param key
密匙
@param sInfo
要解密的密文
@return String 返回解密后信息
/
public String decryptByDES(SecretKey key, String sInfo) {
// 定义 加密算法,
String Algorithm = "DES";
// 加密随机数生成器 (RNG)
SecureRandom sr = new SecureRandom();
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = CiphergetInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
c1init(CipherDECRYPT_MODE, key, sr);
// 对要解密的内容进行编码处理
cipherByte = c1doFinal(hex2byte(sInfo));
} catch (Exception e) {
eprintStackTrace();
}
// return byte2hex(cipherByte);
return new String(cipherByte);
}
// /////////////////////////////////////////////////////////////////////////////
/
创建密匙组，并将公匙，私匙放入到指定文件中
默认放入mykeysbat文件中
/
public void createPairKey() {
try {
// 根据特定的算法一个密钥对生成器
KeyPairGenerator keygen = KeyPairGeneratorgetInstance("DSA");
// 加密随机数生成器 (RNG)
SecureRandom random = new SecureRandom();
// 重新设置此随机对象的种子
randomsetSeed(1000);
// 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器
keygeninitialize(512, random);// keygeninitialize(512);
// 生成密钥组
KeyPair keys = keygengenerateKeyPair();
// 得到公匙
PublicKey pubkey = keysgetPublic();
// 得到私匙
PrivateKey prikey = keysgetPrivate();
// 将公匙私匙写入到文件当中
doObjToFile("mykeysbat", new Object[] { prikey, pubkey });
} catch (NoSuchAlgorithmException e) {
eprintStackTrace();
}
}
/
利用私匙对信息进行签名 把签名后的信息放入到指定的文件中
@param info
要签名的信息
@param signfile
存入的文件
/
public void signToInfo(String info, String signfile) {
// 从文件当中读取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeysbat", 1);
// 从文件中读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeysbat", 2);
try {
// Signature 对象可用来生成和验证数字签名
Signature signet = SignaturegetInstance("DSA");
// 初始化签署签名的私钥
signetinitSign(myprikey);
// 更新要由字节签名或验证的数据
signetupdate(infogetBytes());
// 签署或验证所有更新字节的签名，返回签名
byte[] signed = signetsign();
// 将数字签名,公匙,信息放入文件中
doObjToFile(signfile, new Object[] { signed, mypubkey, info });
} catch (Exception e) {
eprintStackTrace();
}
}
/
读取数字签名文件 根据公匙，签名，信息验证信息的合法性
@return true 验证成功 false 验证失败
/
public boolean validateSign(String signfile) {
// 读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);
// 读取签名
byte[] signed = (byte[]) getObjFromFile(signfile, 1);
// 读取信息
String info = (String) getObjFromFile(signfile, 3);
try {
// 初始一个Signature对象,并用公钥和签名进行验证
Signature signetcheck = SignaturegetInstance("DSA");
// 初始化验证签名的公钥
signetcheckinitVerify(mypubkey);
// 使用指定的 byte 数组更新要签名或验证的数据
signetcheckupdate(infogetBytes());
Systemoutprintln(info);
// 验证传入的签名
return signetcheckverify(signed);
} catch (Exception e) {
eprintStackTrace();
return false;
}
}
/
将二进制转化为16进制字符串
@param b
二进制字节数组
@return String
/
public String byte2hex(byte[] b) {
String hs = "";
String stmp = "";
for (int n = 0; n < blength; n++) {
stmp = (javalangIntegertoHexString(b[n] & 0XFF));
if (stmplength() == 1) {
hs = hs + "0" + stmp;
} else {
hs = hs + stmp;
}
}
return hstoUpperCase();
}
/
十六进制字符串转化为2进制
@param hex
@return
/
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp = hexgetBytes();
for (int i = 0; i < 8; i++) {
ret[i] = uniteBytes(tmp[i 2], tmp[i 2 + 1]);
}
return ret;
}
/
将两个ASCII字符合成一个字节； 如："EF"--> 0xEF
@param src0
byte
@param src1
byte
@return byte
/
public static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Bytedecode("0x" + new String(new byte[] { src0 }))
byteValue();
_b0 = (byte) (_b0 << 4);
byte _b1 = Bytedecode("0x" + new String(new byte[] { src1 }))
byteValue();
byte ret = (byte) (_b0 ^ _b1);
return ret;
}
/
将指定的对象写入指定的文件
@param file
指定写入的文件
@param objs
要写入的对象
/
public void doObjToFile(String file, Object[] objs) {
ObjectOutputStream oos = null;
try {
FileOutputStream fos = new FileOutputStream(file);
oos = new ObjectOutputStream(fos);
for (int i = 0; i < objslength; i++) {
ooswriteObject(objs[i]);
}
} catch (Exception e) {
eprintStackTrace();
} finally {
try {
oosclose();
} catch (IOException e) {
eprintStackTrace();
}
}
}
/
返回在文件中指定位置的对象
@param file
指定的文件
@param i
从1开始
@return
/
public Object getObjFromFile(String file, int i) {
ObjectInputStream ois = null;
Object obj = null;
try {
FileInputStream fis = new FileInputStream(file);
ois = new ObjectInputStream(fis);
for (int j = 0; j < i; j++) {
obj = oisreadObject();
}
} catch (Exception e) {
eprintStackTrace();
} finally {
try {
oisclose();
} catch (IOException e) {
eprintStackTrace();
}
}
return obj;
}
/
测试
@param args
/
public static void main(String[] args) {
CryptTest jiami = new CryptTest();
// 执行MD5加密"Hello world!"
Systemoutprintln("Hello经过MD5:" + jiamiencryptToMD5("Hello"));
// 生成一个DES算法的密匙
SecretKey key = jiamicreateSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 = jiamiencryptToDES(key, "Hello");
Systemoutprintln("使用des加密信息Hello为:" + str1);
// 使用这个密匙解密
String str2 = jiamidecryptByDES(key, str1);
Systemoutprintln("解密后为：" + str2);
// 创建公匙和私匙
jiamicreatePairKey();
// 对Hello world!使用私匙进行签名
jiamisignToInfo("Hello", "mysignbat");
// 利用公匙对签名进行验证。
if (jiamivalidateSign("mysignbat")) {
Systemoutprintln("Success!");
} else {
Systemoutprintln("Fail!");
}
}
}
加多一个判断，当输入的长度小于指定长度的时候，出错；
如果超出指定长度，则取前几位，譬如指定6位，输入123， 出错；输入123456789，那就只处理123456，忽略后面的789
import javautilHashMap;
import javautilMap;
import javautilScanner;
public class Test {
public static void main(String[] args) throws Exception {
Systemoutprint("请输入加密（解密）和要处理的数字个数：1为加密，2为解密； ");
Scanner scanner = new Scanner(Systemin);
String[] input1 = scannernextLine()split("\\s+");
String choice = input1[0];
int count = IntegerparseInt(input1[1]);
Systemoutprint("请输入要处理的数字，用空格隔开：");
String input = scannernextLine()replaceAll("\\s+", "");
if(inputlength() < count){
throw new Exception("不足" + count + "位数字，请检查输入");
}else if(inputlength() > count){
Systemoutprintln("太多数字，将处理前" + count + "个数字：" +
inputsubstring(0, 6));
input = inputsubstring(0, 6);
}
if(choiceequals("1")){
if(inputlength() < count){
}
String encode = EncodeUtilencode(input);
Systemoutprintln("加密后的数字是: " + encode);
}else{
String decode = EncodeUtildecode(input);
Systemoutprintln("解密后的数字: " + decode);
}
}
}
class EncodeUtil{
private static Map<String, String> encodeMap = null;
private static Map<String, String> decodeMap = null;
public final static String encode(String strToEncode){
if(encodeMap == null){
encodeMap = new HashMap<String, String>();
encodeMapput("0", "7");
encodeMapput("1", "5");
encodeMapput("2", "9");
encodeMapput("3", "1");
encodeMapput("4", "3");
encodeMapput("5", "6");
encodeMapput("6", "8");
encodeMapput("7", "0");
encodeMapput("8", "2");
encodeMapput("9", "4");
}
StringBuilder sb = new StringBuilder();
for(int i = 0; i < strToEncodelength(); i++){
sbappend(encodeMapget(StringvalueOf(strToEncodecharAt(i))));
}
return sbtoString();
}
public final static String decode(String strToDecode){
if(decodeMap == null){
decodeMap = new HashMap<String, String>();
decodeMapput("7", "0");
decodeMapput("5", "1");
decodeMapput("9", "2");
decodeMapput("1", "3");
decodeMapput("3", "4");
decodeMapput("6", "5");
decodeMapput("8", "6");
decodeMapput("0", "7");
decodeMapput("2", "8");
decodeMapput("4", "9");
}
StringBuilder sb = new StringBuilder();
for(int i = 0; i < strToDecodelength(); i++){
sbappend(decodeMapget(StringvalueOf(strToDecodecharAt(i))));
}
return sbtoString();
}
}
------------------测试
C:\Program Files\IBM\RAD 7\jdk\bin>java Test
请输入加密（解密）和要处理的数字个数：1为加密，2为解密； 1 6
请输入要处理的数字，用空格隔开：1 2 3
Exception in thread "main" javalangException: 不足6位数字，请检查输入
at Testmain(Testjava:19)
C:\Program Files\IBM\RAD 7\jdk\bin>java Test
请输入加密（解密）和要处理的数字个数：1为加密，2为解密； 1 6
请输入要处理的数字，用空格隔开：1 2 3 4 5 6 7
太多数字，将处理前6个数字：123456
加密后的数字是: 591368
C:\Program Files\IBM\RAD 7\jdk\bin>java Test
请输入加密（解密）和要处理的数字个数：1为加密，2为解密； 1 6
请输入要处理的数字，用空格隔开：1 9 9 7 7 1
加密后的数字是: 544005
C:\Program Files\IBM\RAD 7\jdk\bin>java Test
请输入加密（解密）和要处理的数字个数：1为加密，2为解密； 2 6
请输入要处理的数字，用空格隔开：5 4 4 0 0 5
解密后的数字: 199771
最简单的，用异或运算。
你也可以自己写个加密方法啊。
比如说：利用unicode字符加密啊。假设一个数字a它的unicode值是1234，你自己设计个函数，比如说y=2x^3+3，得到一个新的unicode字符，然后把这个unicode字符转换为字母，这个字母可能是汉字，但更可能是外国符文，反正一般人不会认出来的。你解密的时候，倒推一下就行了。
以上就是关于java加密解密代码全部的内容，包括:java加密解密代码、Java软件如何加密、如何用java程序实现加密的序列号等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）