import java.lang.reflect.*;
/*******************************************************************************
* 算法.
******************************************************************************/
public class keyBean {
/*
* final是表示了只读,切能在同一个进程空间内的多个 Instance间共享
*/
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 };
// first)
public String digestHexStr;
* getkeyBeanofStr是类keyBean最主要的公共方法,入口参数是你想要进行keyBean变换的字符串
* 返回的是变换完的结果,这个结果是从公共成员digestHexStr取得的．
public String getkeyBeanofStr(String inbuf) {
keyBeanInit();
keyBeanUpdate(inbuf.getBytes(), inbuf.length());
keyBeanFinal();
digestHexStr = "";
digestHexStr ◆= byteHEX(digest[i]);
}
return digestHexStr;
// 这是keyBean这个类的标准构造函数,JavaBean要求有一个public的并且没有参数的构造函数
public keyBean() {
return;
/* keyBeanInit是一个初始化函数,初始化核心变量,装入标准的幻数 */
private void keyBeanInit() {
count[0] = 0L;
count[1] = 0L;
// /* Load magic initialization constants.
* 简单的位运算,可能出于效率的考虑把它们实现成了宏,在java中,我们把它们 实现成了private方法,名字保持了原来C中的.
private long F(long x, long y, long z) {
return (x y) | ((~x) z);
private long G(long x, long y, long z) {
return (x z) | (y (~z));
private long H(long x, long y, long z) {
return x ^ y ^ z;
private long I(long x, long y, long z) {
return y ^ (x | (~z));
* FF,GG,HH和II将调用F,G,H,I进行近一步变换 FF, GG, HH, and II transformations for
* recomputation.
private long FF(long a, long b, long c, long d, long x, long s, long ac) {
a ◆= F(b, c, d) ◆ x ◆ ac;
a ◆= b;
return a;
private long GG(long a, long b, long c, long d, long x, long s, long ac) {
a ◆= G(b, c, d) ◆ x ◆ ac;
private long HH(long a, long b, long c, long d, long x, long s, long ac) {
a ◆= H(b, c, d) ◆ x ◆ ac;
private long II(long a, long b, long c, long d, long x, long s, long ac) {
a ◆= I(b, c, d) ◆ x ◆ ac;
* keyBeanUpdate是keyBean的主计算过程,inbuf是要变换的字节串,inputlen是长度,这个
* 函数由getkeyBeanofStr调用,调用之前需要调用keyBeaninit,所以呢把它设计成private的
private void keyBeanUpdate(byte[] inbuf, int inputLen) {
int i, index, partLen;
// /* Update number of bits */
count[1]◆◆;
// Transform as many times as possible.
if (inputLen = partLen) {
keyBeanMemcpy(buffer, inbuf, index, 0, partLen);
keyBeanTransform(buffer);
keyBeanTransform(block);
index = 0;
} else
i = 0;
// /* Buffer remaining input */
keyBeanMemcpy(buffer, inbuf, index, i, inputLen - i);
* keyBeanFinal整理和填写输出结果
private void keyBeanFinal() {
int index, padLen;
// /* Save number of bits */
keyBeanUpdate(PADDING, padLen);
// /* Append length (before padding) */
// /* Store state in digest */
* keyBeanMemcpy是一个内部使用的byte数组的块拷贝函数,从input的inpos开始把len长度的
* 字节拷贝到output的outpos位置开始
private void keyBeanMemcpy(byte[] output, byte[] input, int outpos,
int inpos, int len) {
int i;
for (i = 0; i len; i◆◆)
output[outpos ◆ i] = input[inpos ◆ i];
* keyBeanTransform是keyBean核心变换程序,有keyBeanUpdate调用,block是分块的原始字节
private void keyBeanTransform(byte block[]) {
/* Round 1 */
state[0] ◆= a;
state[1] ◆= b;
private void Encode(byte[] output, long[] input, int len) {
int i, j;
output[j] = (byte) (input[i] 0xffL);
private void Decode(long[] output, byte[] input, int len) {
* byteHEX(),用来把一个byte类型的数转换成十六进制的ASCII表示,
public static String byteHEX(byte ib) {
'B', 'C', 'D', 'E', 'F' };
ob[1] = Digit[ib 0X0F];
String s = new String(ob);
return s;
public static void main(String args[]) {
keyBean m = new keyBean();
if (Array.getLength(args) == 0) { // 如果没有参数,执行标准的Test Suite
System.out.println("keyBean Test suite:");
System.out.println("keyBean(\"):" ◆ m.getkeyBeanofStr(""));
System.out.println("keyBean(\"a\"):" ◆ m.getkeyBeanofStr("a"));
System.out.println("keyBean(\"abc\"):" ◆ m.getkeyBeanofStr("abc"));
System.out.println("keyBean(\"message digest\"):"
◆ m.getkeyBeanofStr("message digest"));
System.out.println("keyBean(\"abcdefghijklmnopqrstuvwxyz\"):"
◆ m.getkeyBeanofStr("abcdefghijklmnopqrstuvwxyz"));
System.out
◆ m
System.out.println("keyBean(" ◆ args[0] ◆ ")="
◆ m.getkeyBeanofStr(args[0]));
程序加密?你说的是代码加密还是数据加密.我都说一下吧.
Java代码加密：
这点因为Java是开源的,想达到完全加密,基本是不可能的,因为在反编译的时候,虽然反编译回来的时候可能不是您原来的代码,但是意思是接近的,所以是不行的.
那么怎么增加反编译的难度（阅读难度）,那么可以采用多层继承（实现）方式来解决,这样即使反编译出来的代码,可读性太差,复用性太差了.
Java数据加密：
而我们需要可逆而且采用安全的方式是：对称加密和非堆成加密,我们常用的有AES、DES等单密钥和双密钥的方式.而且是各种语言通用的.
全部手动敲字,望采纳,下面是我用Javascript方式做的一系列在线加密/解密工具：
package com.happy.security.properties;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
public class DESEncryptUtil {
public static Key createKey() throws NoSuchAlgorithmException {//创建密钥
Security.insertProviderAt(new com.sun.crypto.provider.SunJCE(), 1);
KeyGenerator generator = KeyGenerator.getInstance("DES");
generator.init(new SecureRandom());
Key key = generator.generateKey();
return key;
public static Key getKey(InputStream is) {
try {
ObjectInputStream ois = new ObjectInputStream(is);
return (Key) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
private static byte[] doEncrypt(Key key, byte[] data) {//对数据进行加密?
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] raw = cipher.doFinal(data);
return raw;
public static InputStream doDecrypt(Key key, InputStream in) {//对数据进行解密?
cipher.init(Cipher.DECRYPT_MODE, key);
ByteArrayOutputStream bout = new ByteArrayOutputStream();
int count = 0;
while ((count = in.read(tmpbuf)) != -1) {
bout.write(tmpbuf, 0, count);
in.close();
byte[] orgData = bout.toByteArray();
byte[] raw = cipher.doFinal(orgData);
ByteArrayInputStream bin = new ByteArrayInputStream(raw);
return bin;
} catch (Exception e){
public static void main(String[] args) throws Exception{
System.out.println("===================");
Key key = DESEncryptUtil.createKey();
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(args[1]));
oos.writeObject(key);
oos.close();
System.out.println("成功生成密钥文件");
File file = new File(args[1]);
FileInputStream in = new FileInputStream(file);
while ((count = in.read(tmpbuf)) != -1){
byte[] raw = DESEncryptUtil.doEncrypt(key, orgData);
file = new File(file.getParent() ◆ "\\en_" ◆ file.getName());
FileOutputStream out = new FileOutputStream(file);
out.write(raw);
out.close();
System.out.println("成功加密,加密文件位:"◆file.getAbsolutePath());
FileInputStream fis = new FileInputStream(file);
InputStream raw = DESEncryptUtil.doDecrypt(key, fis);
while ((count = raw.read(tmpbuf)) != -1){
raw.close();
file = new File(file.getParent() ◆ "\\rs_" ◆ file.getName());
FileOutputStream fos = new FileOutputStream(file);
fos.write(orgData);
System.out.println("成功解密,解密文件位:"◆file.getAbsolutePath());
}else if(args.length==1 args[0].equals("-h")) {
System.out.println("\t文件加密解密\n");
System.out.println
基本的单向加密算法：
SHA(Secure Hash Algorithm,安全散列算法)
HMAC(Hash Message Authentication Code,散列消息鉴别码)
复杂的对称加密（DES、PBE）、非对称加密算法：
DES(Data Encryption Standard,数据加密算法)
PBE(Password-based encryption,基于密码验证)
RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)
DH(Diffie-Hellman算法,密钥一致协议)
DSA(Digital Signature Algorithm,数字签名)
ECC(Elliptic Curves Cryptography,椭圆曲线密码编码学)
代码参考：
/**
*
*?SHA加密
public?static?byte[]?encryptSHA(byte[]?data)?throws?Exception?{
MessageDigest?sha?=?MessageDigest.getInstance(KEY_SHA);
sha.update(data);
return?sha.digest();
*?初始化HMAC密钥
public?static?String?initMacKey()?throws?Exception?{
KeyGenerator?keyGenerator?=?KeyGenerator.getInstance(KEY_MAC);
SecretKey?secretKey?=?keyGenerator.generateKey();
*?HMAC加密
public?static?byte[]?encryptHMAC(byte[]?data,?String?key)?throws?Exception?{
Mac?mac?=?Mac.getInstance(secretKey.getAlgorithm());
mac.init(secretKey);
return?mac.doFinal(data);
package com.cube.limail.util;
import javax.crypto.SecretKey;/**
* 加密解密类
public class Eryptogram
{
private static String Algorithm ="DES";
//定义 加密算法,可用 DES,DESede,Blowfish
static boolean debug = false ;
* 构造子注解.
public Eryptogram ()
} /**
* 生成密钥
* @return byte[] 返回生成的密钥
* @throws exception 扔出异常.
public static byte [] getSecretKey () throws Exception
KeyGenerator keygen = KeyGenerator.getInstance (Algorithm );
SecretKey deskey = keygen.generateKey ();
System.out.println ("生成密钥:"◆bytesToHexString (deskey.getEncoded ()));
if (debug ) System.out.println ("生成密钥:"◆bytesToHexString (deskey.getEncoded ()));
return deskey.getEncoded ();
* 将指定的数据根据提供的密钥进行加密
* @param input 需要加密的数据
* @param key 密钥
* @return byte[] 加密后的数据
* @throws Exception
public static byte [] encryptData (byte [] input ,byte [] key ) throws Exception
SecretKey deskey = new javax.crypto.spec.SecretKeySpec (key ,Algorithm );
if (debug )
System.out.println ("加密前的字符串:"◆new String (input ));
} Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.ENCRYPT_MODE ,deskey );
byte [] cipherByte =c1.doFinal (input );
return cipherByte ;
* 将给定的已加密的数据通过指定的密钥进行解密
* @param input 待解密的数据
* @return byte[] 解密后的数据
public static byte [] decryptData (byte [] input ,byte [] key ) throws Exception
Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.DECRYPT_MODE ,deskey );
byte [] clearByte =c1.doFinal (input );
System.out.println ("解密后的字符串:"◆(new String (clearByte )));
} return clearByte ;
* @param byte[] b 输入要转换的字节码
String hs ="";
String stmp ="";
for (int n =0 ;n b.length ;n ◆◆)
stmp =(java.lang.Integer.toHexString (b [n ] 0XFF ));
if (stmp.length ()==1 ) hs =hs ◆"0"◆stmp ;
else hs =hs ◆stmp ;
if (n b.length -1 ) hs =hs ◆":";
} return hs.toUpperCase ();
* 字符串转成字节数组.
* @param hex 要转化的字符串.
* @return byte[] 返回转化后的字符串.
public static byte[] hexStringToByte(String hex) {
byte[] result = new byte[len];
char[] achar = hex.toCharArray();
for (int i = 0; i len; i◆◆) {
return result;
private static byte toByte(char c) {
return b;
* 字节数组转成字符串.
* @param String 要转化的字符串.
* @return 返回转化后的字节数组.
public static final String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArray.length);
String sTemp;
for (int i = 0; i bArray.length; i◆◆) {
sTemp = Integer.toHexString(0xFF bArray[i]);
sb.append(0);
sb.append(sTemp.toUpperCase());
return sb.toString();
* 从数据库中获取密钥.
* @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=dao.getRecordList("from Key k where k.deptid="◆deptid);
//if(list.size()0){
//value=((com.csc.sale.bean.Key)list.get(0)).getKey();
key=hexStringToByte(value);
//}
if (debug)
System.out.println("密钥:" ◆ value);
String en = null;
byte[] key=hexStringToByte(this.key);
en = bytesToHexString(encryptData(data.getBytes(),key));
return en;
String de = null;
de = new String(decryptData(hexStringToByte(data),key));
return de;
} 加密使用： byte[] key=Eryptogram.getSecretKey(deptid); //获得钥匙（字节数组）
byte[] tmp=Eryptogram.encryptData(password.getBytes(), key); //传入密码和钥匙,获得加密后的字节数组的密码
password=Eryptogram.bytesToHexString(tmp); //将字节数组转化为字符串,获得加密后的字符串密码解密与之差不多
-----------------------------------------------------
针对java加密防止反编译的解决方案
众所周知,java开发语言提供了很方便的开发平台,开发出来的程序很容易在不同的平台上被移植,现在越来越多的人使用它来开发软件,与.net语言并驾齐驱.
Java有它方便的一面,同时也给开发者带来了一个不小的烦恼,就是保护程序代码变得困难,因为java语言编译和代码执行的特殊性,目前,除了HASP外,还没有一个更好的解决办法或保护方案,但如果不采取有力的措施,则自己辛辛苦苦开发出来的程序很容易被人复制而据为己有,一般情况下,大多数的人都是用混编器（java obfuscator）来把开发出来的程序进行打乱,以想达到防止反编译的目的,但是,这种方法在网上很容易找到相关的软件来重新整理,那么这个混编器工具也只能控制一些本来就没有办法的人,而对于稍懂工具的人几乎是透明的,没有任何意义.再说硬件加密锁,大多数厂商提供的加密锁只能进行dll的连接或简单的api调用,只要简单地反编译,就很容易把api去掉,这样加密锁根本起不了作用,那到底是否还有更好的解决办法呢?
①.、以色列阿拉丁公司的HASP HL加密锁提供的外壳加密工具中,有一个叫做数据加密的功能,这个功能可以很好的防止反编译而去掉api的调用,大家知道：硬件加密锁的保护原理就是让加密过的软件和硬件紧密地连接在一起,调用不会轻易地被剔除,这样才能持久地保护您的软件不被盗版,同时,这种方式使用起来非常简单,很容易被程序员掌握,要对一个软件实现保护,大约只需几分钟的时间就可以了,下面简单介绍一下它的原理：
以上就是土嘎嘎小编为大家整理的java代码加密排行榜相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！