正文
java代码解密 java des加解密
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
java aes加密 如何用php 进行解密，以下是java代码，求php 代码如何写 （主要是createkey 那个方法）
先看用什么方式的加密,拿AES来说,你需要问java要到混淆值、初始化向量与AES加密的方式如AES-192-CFB.然后直接调用openssl_decrypt方法进行解密.
openssl_decrypt('需要解密的字符串','AES-192-CFB','混淆值',0,'初始化向量'),true)
相关问答
Q1: 如何用JAVA实现字符串简单加密解密？
java加密字符串可以使用des加密算法，实例如下：
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
/**
* 加密解密
*
* @author shy.qiu
* @since
*/
public class CryptTest {
/**
* 进行MD5加密
*
* @param info
* 要加密的信息
* @return String 加密后的字符串
*/
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
// 得到一个md5的消息摘要
MessageDigest alga = MessageDigest.getInstance("MD5");
// 添加要进行计算摘要的信息
alga.update(info.getBytes());
// 得到该摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
/**
* 进行SHA加密
*
* @param info
* 要加密的信息
* @return String 加密后的字符串
*/
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
// 得到一个SHA-1的消息摘要
MessageDigest alga = MessageDigest.getInstance("SHA-1");
// 添加要进行计算摘要的信息
alga.update(info.getBytes());
// 得到该摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 将摘要转为字符串
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 = KeyGenerator.getInstance(algorithm);
// 生成一个密钥
deskey = keygen.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 返回密匙
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 = Cipher.getInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
// 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE, key, sr);
// 对要加密的内容进行编码处理,
cipherByte = c1.doFinal(info.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
// 返回密文的十六进制形式
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 = Cipher.getInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
c1.init(Cipher.DECRYPT_MODE, key, sr);
// 对要解密的内容进行编码处理
cipherByte = c1.doFinal(hex2byte(sInfo));
} catch (Exception e) {
e.printStackTrace();
}
// return byte2hex(cipherByte);
return new String(cipherByte);
}
// /////////////////////////////////////////////////////////////////////////////
/**
* 创建密匙组，并将公匙，私匙放入到指定文件中
*
* 默认放入mykeys.bat文件中
*/
public void createPairKey() {
try {
// 根据特定的算法一个密钥对生成器
KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");
// 加密随机数生成器 (RNG)
SecureRandom random = new SecureRandom();
// 重新设置此随机对象的种子
random.setSeed(1000);
// 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器
keygen.initialize(512, random);// keygen.initialize(512);
// 生成密钥组
KeyPair keys = keygen.generateKeyPair();
// 得到公匙
PublicKey pubkey = keys.getPublic();
// 得到私匙
PrivateKey prikey = keys.getPrivate();
// 将公匙私匙写入到文件当中
doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
* 利用私匙对信息进行签名 把签名后的信息放入到指定的文件中
*
* @param info
* 要签名的信息
* @param signfile
* 存入的文件
*/
public void signToInfo(String info, String signfile) {
// 从文件当中读取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
// 从文件中读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);
try {
// Signature 对象可用来生成和验证数字签名
Signature signet = Signature.getInstance("DSA");
// 初始化签署签名的私钥
signet.initSign(myprikey);
// 更新要由字节签名或验证的数据
signet.update(info.getBytes());
// 签署或验证所有更新字节的签名，返回签名
byte[] signed = signet.sign();
// 将数字签名,公匙,信息放入文件中
doObjToFile(signfile, new Object[] { signed, mypubkey, info });
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 读取数字签名文件 根据公匙，签名，信息验证信息的合法性
*
* @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 = Signature.getInstance("DSA");
// 初始化验证签名的公钥
signetcheck.initVerify(mypubkey);
// 使用指定的 byte 数组更新要签名或验证的数据
signetcheck.update(info.getBytes());
System.out.println(info);
// 验证传入的签名
return signetcheck.verify(signed);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将二进制转化为16进制字符串
*
* @param b
* 二进制字节数组
* @return String
*/
public String byte2hex(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;
}
}
return hs.toUpperCase();
}
/**
* 十六进制字符串转化为2进制
*
* @param hex
* @return
*/
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp = hex.getBytes();
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 = Byte.decode("0x" + new String(new byte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0 4);
byte _b1 = Byte.decode("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 objs.length; i++) {
oos.writeObject(objs[i]);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 返回在文件中指定位置的对象
*
* @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 = ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
/**
* 测试
*
* @param args
*/
public static void main(String[] args) {
CryptTest jiami = new CryptTest();
// 执行MD5加密"Hello world!"
System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));
// 生成一个DES算法的密匙
SecretKey key = jiami.createSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 = jiami.encryptToDES(key, "Hello");
System.out.println("使用des加密信息Hello为:" + str1);
// 使用这个密匙解密
String str2 = jiami.decryptByDES(key, str1);
System.out.println("解密后为：" + str2);
// 创建公匙和私匙
jiami.createPairKey();
// 对Hello world!使用私匙进行签名
jiami.signToInfo("Hello", "mysign.bat");
// 利用公匙对签名进行验证。
if (jiami.validateSign("mysign.bat")) {
System.out.println("Success!");
} else {
System.out.println("Fail!");
}
}
}
Q2: java实现ase加密解密
这个算法java SDK自带的额 参考代码如下java代码解密：
/**解密
* @param content 待解密内容
* @param password 解密密钥
* @return
*/
public static byte[] decrypt(byte[] content, String password) {
try {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(password.getBytes()));
SecretKey secretKey = kgen.generateKey();
byte[] enCodeFormat = secretKey.getEncoded();
SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
Cipher cipher = Cipher.getInstance("AES");// 创建密码器
cipher.init(Cipher.DECRYPT_MODE, key);// 初始化
byte[] result = cipher.doFinal(content);
return result; // 加密
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
/**
* 加密
*
* @param content 需要加密的内容
* @param password 加密密码
* @return
*/
public static byte[] encrypt(String content, String password) {
try {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(password.getBytes()));
SecretKey secretKey = kgen.generateKey();
byte[] enCodeFormat = secretKey.getEncoded();
SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
Cipher cipher = Cipher.getInstance("AES");// 创建密码器
byte[] byteContent = content.getBytes("utf-8");
cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化
byte[] result = cipher.doFinal(byteContent);
return result; // 加密
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
图像界面的话就不说java代码解密了
Q3: 如何有效防止Java程序源码被人偷窥？
; Java程序java代码解密的源代码很容易被别人偷看 只要有一个反编译器 任何人都可以分析别人的代码 本文讨论如何在不修改原有程序的情况下 通过加密技术保护源代码
一 为什么要加密?
对于传统的C或C++之类的语言来说 要在Web上保护源代码是很容易的 只要不发布它就可以 遗憾的是 Java程序的源代码很容易被别人偷看 只要有一个反编译器 任何人都可以分析别人的代码 Java的灵活性使得源代码很容易被窃取 但与此同时 它也使通过加密保护代码变得相对容易 java代码解密我们唯一需要java代码解密了解的就是Java的ClassLoader对象 当然 在加密过程中 有关Java Cryptography Extension(JCE)的知识也是必不可少的
有几种技术可以 模糊 Java类文件 使得反编译器处理类文件的效果大打折扣 然而 修改反编译器使之能够处理这些经过模糊处理的类文件并不是什么难事 所以不能简单地依赖模糊技术来保证源代码的安全
我们可以用流行的加密工具加密应用 比如PGP(Pretty Good Privacy)或GPG(GNU Privacy Guard) 这时 最终用户在运行应用之前必须先进行解密 但解密之后 最终用户就有了一份不加密的类文件 这和事先不进行加密没有什么差别
Java运行时装入字节码的机制隐含地意味着可以对字节码进行修改 JVM每次装入类文件时都需要一个称为ClassLoader的对象 这个对象负责把新的类装入正在运行的JVM JVM给ClassLoader一个包含了待装入类(比如java lang Object)名字的字符串 然后由ClassLoader负责找到类文件 装入原始数据 并把它转换成一个Class对象
我们可以通过定制ClassLoader 在类文件执行之前修改它 这种技术的应用非常广泛??在这里 它的用途是在类文件装入之时进行解密 因此可以看成是一种即时解密器 由于解密后的字节码文件永远不会保存到文件系统 所以窃密者很难得到解密后的代码
由于把原始字节码转换成Class对象的过程完全由系统负责 所以创建定制ClassLoader对象其实并不困难 只需先获得原始数据 接着就可以进行包含解密在内的任何转换
Java 在一定程度上简化了定制ClassLoader的构建 在Java 中 loadClass的缺省实现仍旧负责处理所有必需的步骤 但为了顾及各种定制的类装入过程 它还调用一个新的findClass方法
这为我们编写定制的ClassLoader提供了一条捷径 减少了麻烦 只需覆盖findClass 而不是覆盖loadClass 这种方法避免了重复所有装入器必需执行的公共步骤 因为这一切由loadClass负责
不过 本文的定制ClassLoader并不使用这种方法 原因很简单 如果由默认的ClassLoader先寻找经过加密的类文件 它可以找到;但由于类文件已经加密 所以它不会认可这个类文件 装入过程将失败 因此 我们必须自己实现loadClass 稍微增加了一些工作量
二 定制类装入器
每一个运行着的JVM已经拥有一个ClassLoader 这个默认的ClassLoader根据CLASSPATH环境变量的值 在本地文件系统中寻找合适的字节码文件
应用定制ClassLoader要求对这个过程有较为深入的认识 我们首先必须创建一个定制ClassLoader类的实例 然后显式地要求它装入另外一个类 这就强制JVM把该类以及所有它所需要的类关联到定制的ClassLoader Listing 显示了如何用定制ClassLoader装入类文件
【Listing 利用定制的ClassLoader装入类文件】
以下是引用片段
// 首先创建一个ClassLoader对象 ClassLoader myClassLoader = new myClassLoader(); // 利用定制ClassLoader对象装入类文件 // 并把它转换成Class对象 Class myClass = myClassLoader loadClass( mypackage MyClass ); // 最后 创建该类的一个实例 Object newInstance = myClass newInstance(); // 注意 MyClass所需要的所有其他类 都将通过 // 定制的ClassLoader自动装入
如前所述 定制ClassLoader只需先获取类文件的数据 然后把字节码传递给运行时系统 由后者完成余下的任务
ClassLoader有几个重要的方法 创建定制的ClassLoader时 我们只需覆盖其中的一个 即loadClass 提供获取原始类文件数据的代码 这个方法有两个参数 类的名字 以及一个表示JVM是否要求解析类名字的标记(即是否同时装入有依赖关系的类) 如果这个标记是true 我们只需在返回JVM之前调用resolveClass
【Listing ClassLoader loadClass()的一个简单实现】
以下是引用片段
public Class loadClass( String name boolean resolve ) throws ClassNotFoundException { try { // 我们要创建的Class对象 Class clasz = null; // 必需的步骤 如果类已经在系统缓冲之中 // 我们不必再次装入它 clasz = findLoadedClass( name ); if (clasz != null) return clasz; // 下面是定制部分 byte classData[] = /* 通过某种方法获取字节码数据 */; if (classData != null) { // 成功读取字节码数据 现在把它转换成一个Class对象 clasz = defineClass( name classData classData length ); } // 必需的步骤 如果上面没有成功 // 我们尝试用默认的ClassLoader装入它 if (clasz == null) clasz = findSystemClass( name ); // 必需的步骤 如有必要 则装入相关的类 if (resolve clasz != null) resolveClass( clasz ); // 把类返回给调用者 return clasz; } catch( IOException ie ) { throw new ClassNotFoundException( ie toString() ); } catch( GeneralSecurityException gse ) { throw new ClassNotFoundException( gse toString() ); } }
Listing 显示了一个简单的loadClass实现 代码中的大部分对所有ClassLoader对象来说都一样 但有一小部分(已通过注释标记)是特有的 在处理过程中 ClassLoader对象要用到其他几个辅助方法
findLoadedClass 用来进行检查 以便确认被请求的类当前还不存在 loadClass方法应该首先调用它
defineClass 获得原始类文件字节码数据之后 调用defineClass把它转换成一个Class对象 任何loadClass实现都必须调用这个方法
findSystemClass 提供默认ClassLoader的支持 如果用来寻找类的定制方法不能找到指定的类(或者有意地不用定制方法) 则可以调用该方法尝试默认的装入方式 这是很有用的 特别是从普通的JAR文件装入标准Java类时
resolveClass 当JVM想要装入的不仅包括指定的类 而且还包括该类引用的所有其他类时 它会把loadClass的resolve参数设置成true 这时 我们必须在返回刚刚装入的Class对象给调用者之前调用resolveClass
三 加密 解密
Java加密扩展即Java Cryptography Extension 简称JCE 它是Sun的加密服务软件 包含了加密和密匙生成功能 JCE是JCA(Java Cryptography Architecture)的一种扩展
JCE没有规定具体的加密算法 但提供了一个框架 加密算法的具体实现可以作为服务提供者加入 除了JCE框架之外 JCE软件包还包含了SunJCE服务提供者 其中包括许多有用的加密算法 比如DES(Data Encryption Standard)和Blowfish
为简单计 在本文中我们将用DES算法加密和解密字节码 下面是用JCE加密和解密数据必须遵循的基本步骤
步骤 生成一个安全密匙 在加密或解密任何数据之前需要有一个密匙 密匙是随同被加密的应用一起发布的一小段数据 Listing 显示了如何生成一个密匙 【Listing 生成一个密匙】
以下是引用片段
// DES算法要求有一个可信任的随机数源 SecureRandom sr = new SecureRandom(); // 为我们选择的DES算法生成一个KeyGenerator对象 KeyGenerator kg = KeyGenerator getInstance( DES ); kg init( sr ); // 生成密匙 SecretKey key = kg generateKey(); // 获取密匙数据 byte rawKeyData[] = key getEncoded(); /* 接下来就可以用密匙进行加密或解密 或者把它保存 为文件供以后使用 */ doSomething( rawKeyData ); 步骤 加密数据 得到密匙之后 接下来就可以用它加密数据 除了解密的ClassLoader之外 一般还要有一个加密待发布应用的独立程序(见Listing ) 【Listing 用密匙加密原始数据】
以下是引用片段
// DES算法要求有一个可信任的随机数源 SecureRandom sr = new SecureRandom(); byte rawKeyData[] = /* 用某种方法获得密匙数据 */; // 从原始密匙数据创建DESKeySpec对象 DESKeySpec dks = new DESKeySpec( rawKeyData ); // 创建一个密匙工厂 然后用它把DESKeySpec转换成 // 一个SecretKey对象 SecretKeyFactory keyFactory = SecretKeyFactory getInstance( DES ); SecretKey key = keyFactory generateSecret( dks ); // Cipher对象实际完成加密操作 Cipher cipher = Cipher getInstance( DES ); // 用密匙初始化Cipher对象 cipher init( Cipher ENCRYPT_MODE key sr ); // 现在 获取数据并加密 byte data[] = /* 用某种方法获取数据 */ // 正式执行加密操作 byte encryptedData[] = cipher doFinal( data ); // 进一步处理加密后的数据 doSomething( encryptedData ); 步骤 解密数据 运行经过加密的应用时 ClassLoader分析并解密类文件 操作步骤如Listing 所示 【Listing 用密匙解密数据】
// DES算法要求有一个可信任的随机数源 SecureRandom sr = new SecureRandom(); byte rawKeyData[] = /* 用某种方法获取原始密匙数据 */; // 从原始密匙数据创建一个DESKeySpec对象 DESKeySpec dks = new DESKeySpec( rawKeyData ); // 创建一个密匙工厂 然后用它把DESKeySpec对象转换成 // 一个SecretKey对象 SecretKeyFactory keyFactory = SecretKeyFactory getInstance( DES ); SecretKey key = keyFactory generateSecret( dks ); // Cipher对象实际完成解密操作 Cipher cipher = Cipher getInstance( DES ); // 用密匙初始化Cipher对象 cipher init( Cipher DECRYPT_MODE key sr ); // 现在 获取数据并解密 byte encryptedData[] = /* 获得经过加密的数据 */ // 正式执行解密操作 byte decryptedData[] = cipher doFinal( encryptedData ); // 进一步处理解密后的数据 doSomething( decryptedData );
四 应用实例
前面介绍了如何加密和解密数据 要部署一个经过加密的应用 步骤如下
步骤 创建应用 我们的例子包含一个App主类 两个辅助类(分别称为Foo和Bar) 这个应用没有什么实际功用 但只要我们能够加密这个应用 加密其他应用也就不在话下
步骤 生成一个安全密匙 在命令行 利用GenerateKey工具(参见GenerateKey java)把密匙写入一个文件 % java GenerateKey key data
步骤 加密应用 在命令行 利用EncryptClasses工具(参见EncryptClasses java)加密应用的类 % java EncryptClasses key data App class Foo class Bar class
该命令把每一个 class文件替换成它们各自的加密版本
步骤 运行经过加密的应用 用户通过一个DecryptStart程序运行经过加密的应用 DecryptStart程序如Listing 所示 【Listing DecryptStart java 启动被加密应用的程序】
以下是引用片段
import java io *; import java security *; import java lang reflect *; import javax crypto *; import javax crypto spec *; public class DecryptStart extends ClassLoader { // 这些对象在构造函数中设置 // 以后loadClass()方法将利用它们解密类 private SecretKey key; private Cipher cipher; // 构造函数 设置解密所需要的对象 public DecryptStart( SecretKey key ) throws GeneralSecurityException IOException { this key = key; String algorithm = DES ; SecureRandom sr = new SecureRandom(); System err println( [DecryptStart: creating cipher] ); cipher = Cipher getInstance( algorithm ); cipher init( Cipher DECRYPT_MODE key sr ); } // main过程 我们要在这里读入密匙 创建DecryptStart的 // 实例 它就是我们的定制ClassLoader // 设置好ClassLoader以后 我们用它装入应用实例 // 最后 我们通过Java Reflection API调用应用实例的main方法 static public void main( String args[] ) throws Exception { String keyFilename = args[ ]; String appName = args[ ]; // 这些是传递给应用本身的参数 String realArgs[] = new String[args length ]; System arraycopy( args realArgs args length ); // 读取密匙 System err println( [DecryptStart: reading key] ); byte rawKey[] = Util readFile( keyFilename ); DESKeySpec dks = new DESKeySpec( rawKey ); SecretKeyFactory keyFactory = SecretKeyFactory getInstance( DES ); SecretKey key = keyFactory generateSecret( dks ); // 创建解密的ClassLoader DecryptStart dr = new DecryptStart( key ); // 创建应用主类的一个实例 // 通过ClassLoader装入它 System err println( [DecryptStart: loading +appName+ ] ); Class clasz = dr loadClass( appName ); // 最后 通过Reflection API调用应用实例 // 的main()方法 // 获取一个对main()的引用 String proto[] = new String[ ]; Class mainArgs[] = { (new String[ ]) getClass() }; Method main = clasz getMethod( main mainArgs ); // 创建一个包含main()方法参数的数组 Object argsArray[] = { realArgs }; System err println( [DecryptStart: running +appName+ main()] ); // 调用main() main invoke( null argsArray ); } public Class loadClass( String name boolean resolve ) throws ClassNotFoundException { try { // 我们要创建的Class对象 Class clasz = null; // 必需的步骤 如果类已经在系统缓冲之中 // 我们不必再次装入它 clasz = findLoadedClass( name ); if (clasz != null) return clasz; // 下面是定制部分 try { // 读取经过加密的类文件 byte classData[] = Util readFile( name+ class ); if (classData != null) { // 解密 byte decryptedClassData[] = cipher doFinal( classData ); // 再把它转换成一个类 clasz = defineClass( name decryptedClassData decryptedClassData length ); System err println( [DecryptStart: decrypting class +name+ ] ); } } catch( FileNotFoundException fnfe ) // 必需的步骤 如果上面没有成功 // 我们尝试用默认的ClassLoader装入它 if (clasz == null) clasz = findSystemClass( name ); // 必需的步骤 如有必要 则装入相关的类 if (resolve clasz != null) resolveClass( clasz ); // 把类返回给调用者 return clasz; } catch( IOException ie ) { throw new ClassNotFoundException( ie toString() ); } catch( GeneralSecurityException gse ) { throw new ClassNotFoundException( gse toString() ); } } } 对于未经加密的应用 正常执行方式如下 % java App arg arg arg
对于经过加密的应用 则相应的运行方式为 % java DecryptStart key data App arg arg arg
DecryptStart有两个目的 一个DecryptStart的实例就是一个实施即时解密操作的定制ClassLoader;同时 DecryptStart还包含一个main过程 它创建解密器实例并用它装入和运行应用 示例应用App的代码包含在App java Foo java和Bar java内 Util java是一个文件I/O工具 本文示例多处用到了它 完整的代码请从本文最后下载
五 注意事项
我们看到 要在不修改源代码的情况下加密一个Java应用是很容易的 不过 世上没有完全安全的系统 本文的加密方式提供了一定程度的源代码保护 但对某些攻击来说它是脆弱的
虽然应用本身经过了加密 但启动程序DecryptStart没有加密 攻击者可以反编译启动程序并修改它 把解密后的类文件保存到磁盘 降低这种风险的办法之一是对启动程序进行高质量的模糊处理 或者 启动程序也可以采用直接编译成机器语言的代码 使得启动程序具有传统执行文件格式的安全性
另外还要记住的是 大多数JVM本身并不安全 狡猾的黑客可能会修改JVM 从ClassLoader之外获取解密后的代码并保存到磁盘 从而绕过本文的加密技术 Java没有为此提供真正有效的补救措施
lishixinzhi/Article/program/Java/hx/201311/25751
Q4: java加密解密代码
package com.cube.limail.util;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;/**
* 加密解密类
*/
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 = 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 ("加密前的二进串:"+byte2hex (input ));
System.out.println ("加密前的字符串:"+new String (input ));
} Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.ENCRYPT_MODE ,deskey );
byte [] cipherByte =c1.doFinal (input );
if (debug ) System.out.println ("加密后的二进串:"+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 javax.crypto.spec.SecretKeySpec (key ,Algorithm );
if (debug ) System.out.println ("解密前的信息:"+byte2hex (input ));
Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.DECRYPT_MODE ,deskey );
byte [] clearByte =c1.doFinal (input );
if (debug )
{
System.out.println ("解密后的二进串:"+byte2hex (clearByte ));
System.out.println ("解密后的字符串:"+(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 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) {
int len = (hex.length() / 2);
byte[] result = new byte[len];
char[] achar = hex.toCharArray();
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(bArray.length);
String sTemp;
for (int i = 0; i bArray.length; i++) {
sTemp = Integer.toHexString(0xFF bArray[i]);
if (sTemp.length() 2)
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();
value = "CB7A92E3D3491964";
key=hexStringToByte(value);
//}
if (debug)
System.out.println("密钥:" + value);
return key;
}
public String encryptData2(String data) {
String en = null;
try {
byte[] key=hexStringToByte(this.key);
en = bytesToHexString(encryptData(data.getBytes(),key));
} catch (Exception e) {
e.printStackTrace();
}
return en;
}
public String decryptData2(String data) {
String de = null;
try {
byte[] key=hexStringToByte(this.key);
de = new String(decryptData(hexStringToByte(data),key));
} catch (Exception e) {
e.printStackTrace();
}
return de;
}
} 加密使用： byte[] key=Eryptogram.getSecretKey(deptid); //获得钥匙（字节数组）
byte[] tmp=Eryptogram.encryptData(password.getBytes(), key); //传入密码和钥匙，获得加密后的字节数组的密码
password=Eryptogram.bytesToHexString(tmp); //将字节数组转化为字符串，获得加密后的字符串密码解密与之差不多
Q5: java密码加密与解密
以下两个类可以很方便的完成字符串的加密和解密
加密 CryptHelper encrypt（password）
解密 CrypHelper decrypt（password）
代码如下
CryptUtils java
[java]
package gdie lab crypt;
import java io IOException;
import javax crypto Cipher;
import javax crypto KeyGenerator;
import javax crypto SecretKey;
import apache xerces internal impl dv util Base ;
public class CryptUtils {
private static String Algorithm = DES ;
private static byte[] DEFAULT_KEY=new byte[] { };
private static String VALUE_ENCODING= UTF ;
/**
* 生成密钥
*
* @return byte[] 返回生成的密钥
* @throws exception
* 扔出异常
*/
public static byte[] getSecretKey（） throws Exception {
KeyGenerator keygen = KeyGenerator getInstance（Algorithm）
SecretKey deskey = keygen generateKey（）
// if （debug ） System out println （ 生成密钥 +byte hex （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 （ 加密前的二进串 +byte hex （input ））
// System out println （ 加密前的字符串 +new String （input ））
//
// }
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher ENCRYPT_MODE deskey）
byte[] cipherByte = c doFinal（input）
// if （debug ） System out println （ 加密后的二进串 +byte hex （cipherByte ））
return cipherByte;
}
public static byte[] encryptData（byte[] input） throws Exception {
return encryptData（input DEFAULT_KEY）
}
/**
* 将给定的已加密的数据通过指定的密钥进行解密
*
* @param input
* 待解密的数据
* @param key
* 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte[] decryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ） System out println （ 解密前的信息 +byte hex （input ））
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher DECRYPT_MODE deskey）
byte[] clearByte = c doFinal（input）
// if （debug ）
// {
// System out println （ 解密后的二进串 +byte hex （clearByte ））
// System out println （ 解密后的字符串 +（new String （clearByte ）））
//
// }
return clearByte;
}
public static byte[] decryptData（byte[] input） throws Exception {
return decryptData（input DEFAULT_KEY）
}
/**
* 字节码转换成 进制字符串
*
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的 进制字符串
*/
public static String byte hex（byte[] bytes） {
StringBuilder hs = new StringBuilder（）
for（byte b : bytes）
hs append（String format（ % $ X b））
return hs toString（）
}
public static byte[] hex byte（String content） {
int l=content length（）》 ;
byte[] result=new byte[l];
for（int i= ;il;i++） {
int j=i《 ;
String s=content substring（j j+ ）
result[i]=Integer valueOf（s ） byteValue（）
}
return result;
}
/**
* 将字节数组转换为base 编码字符串
* @param buffer
* @return
*/
public static String bytesToBase （byte[] buffer） {
//BASE Encoder en=new BASE Encoder（）
return Base encode（buffer）
// return encoder encode（buffer）
}
/**
* 将base 编码的字符串解码为字节数组
* @param value
* @return
* @throws IOException
*/
public static byte[] base ToBytes（String value） throws IOException {
//return Base decodeToByteArray（value）
// System out println（decoder decodeBuffer（value））
// return decoder decodeBuffer（value）
return Base decode（value）
}
/**
* 加密给定的字符串
* @param value
* @return 加密后的base 字符串
*/
public static String encryptString（String value） {
return encryptString（value DEFAULT_KEY）
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 以BASE 形式存在的密钥
* @return 加密后的base 字符串
* @throws IOException
*/
public static String encryptString（String value String key） throws IOException {
return encryptString（value base ToBytes（key））
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 字节数组形式的密钥
* @return 加密后的base 字符串
*/
public static String encryptString（String value byte[] key） {
try {
byte[] data=value getBytes（VALUE_ENCODING）
data=CryptUtils encryptData（data key）
return bytesToBase （data）
} catch （Exception e） {
// TODO Auto generated catch block
e printStackTrace（）
return null;
}
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @return 明文
*/
public static String decryptString（String value） {
return decryptString（value DEFAULT_KEY）
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key base 形式存在的密钥
* @return 明文
* @throws IOException
*/
public static String decryptString（String value String key） throws IOException {
String s=decryptString（value base ToBytes（key））
return s;
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key 字节数据形式存在的密钥
* @return 明文
*/
public static String decryptString（String value byte[] key） {
try {
byte[] data=base ToBytes（value）
data=CryptUtils decryptData（data key）
return new String（data VALUE_ENCODING）
}catch（Exception e） {
e printStackTrace（）
return null;
}
}
}
package gdie lab crypt;
import java io IOException;
import javax crypto Cipher;
import javax crypto KeyGenerator;
import javax crypto SecretKey;
import apache xerces internal impl dv util Base ;
public class CryptUtils {
private static String Algorithm = DES ;
private static byte[] DEFAULT_KEY=new byte[] { };
private static String VALUE_ENCODING= UTF ;
/**
* 生成密钥
*
* @return byte[] 返回生成的密钥
* @throws exception
* 扔出异常
*/
public static byte[] getSecretKey（） throws Exception {
KeyGenerator keygen = KeyGenerator getInstance（Algorithm）
SecretKey deskey = keygen generateKey（）
// if （debug ） System out println （ 生成密钥 +byte hex （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 （ 加密前的二进串 +byte hex （input ））
// System out println （ 加密前的字符串 +new String （input ））
//
// }
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher ENCRYPT_MODE deskey）
byte[] cipherByte = c doFinal（input）
// if （debug ） System out println （ 加密后的二进串 +byte hex （cipherByte ））
return cipherByte;
}
public static byte[] encryptData（byte[] input） throws Exception {
return encryptData（input DEFAULT_KEY）
}
/**
* 将给定的已加密的数据通过指定的密钥进行解密
*
* @param input
* 待解密的数据
* @param key
* 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte[] decryptData（byte[] input byte[] key） throws Exception {
SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）
// if （debug ） System out println （ 解密前的信息 +byte hex （input ））
Cipher c = Cipher getInstance（Algorithm）
c init（Cipher DECRYPT_MODE deskey）
byte[] clearByte = c doFinal（input）
// if （debug ）
// {
// System out println （ 解密后的二进串 +byte hex （clearByte ））
// System out println （ 解密后的字符串 +（new String （clearByte ）））
//
// }
return clearByte;
}
public static byte[] decryptData（byte[] input） throws Exception {
return decryptData（input DEFAULT_KEY）
}
/**
* 字节码转换成 进制字符串
*
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的 进制字符串
*/
public static String byte hex（byte[] bytes） {
StringBuilder hs = new StringBuilder（）
for（byte b : bytes）
hs append（String format（ % $ X b））
return hs toString（）
}
public static byte[] hex byte（String content） {
int l=content length（）》 ;
byte[] result=new byte[l];
for（int i= ;il;i++） {
int j=i《 ;
String s=content substring（j j+ ）
result[i]=Integer valueOf（s ） byteValue（）
}
return result;
}
/**
* 将字节数组转换为base 编码字符串
* @param buffer
* @return
*/
public static String bytesToBase （byte[] buffer） {
//BASE Encoder en=new BASE Encoder（）
return Base encode（buffer）
// return encoder encode（buffer）
}
/**
* 将base 编码的字符串解码为字节数组
* @param value
* @return
* @throws IOException
*/
public static byte[] base ToBytes（String value） throws IOException {
//return Base decodeToByteArray（value）
// System out println（decoder decodeBuffer（value））
// return decoder decodeBuffer（value）
return Base decode（value）
}
/**
* 加密给定的字符串
* @param value
* @return 加密后的base 字符串
*/
public static String encryptString（String value） {
return encryptString（value DEFAULT_KEY）
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 以BASE 形式存在的密钥
* @return 加密后的base 字符串
* @throws IOException
*/
public static String encryptString（String value String key） throws IOException {
return encryptString（value base ToBytes（key））
}
/**
* 根据给定的密钥加密字符串
* @param value 待加密的字符串
* @param key 字节数组形式的密钥
* @return 加密后的base 字符串
*/
public static String encryptString（String value byte[] key） {
try {
byte[] data=value getBytes（VALUE_ENCODING）
data=CryptUtils encryptData（data key）
return bytesToBase （data）
} catch （Exception e） {
// TODO Auto generated catch block
e printStackTrace（）
return null;
}
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @return 明文
*/
public static String decryptString（String value） {
return decryptString（value DEFAULT_KEY）
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key base 形式存在的密钥
* @return 明文
* @throws IOException
*/
public static String decryptString（String value String key） throws IOException {
String s=decryptString（value base ToBytes（key））
return s;
}
/**
* 解密字符串
* @param value base 形式存在的密文
* @param key 字节数据形式存在的密钥
* @return 明文
*/
public static String decryptString（String value byte[] key） {
try {
byte[] data=base ToBytes（value）
data=CryptUtils decryptData（data key）
return new String（data VALUE_ENCODING）
}catch（Exception e） {
e printStackTrace（）
return null;
}
}
}
CryptHelper java
[java]
package gdie lab crypt;
import javax crypto Cipher;
import javax crypto SecretKey;
import javax crypto SecretKeyFactory;
import javax crypto spec DESKeySpec;
import javax crypto spec IvParameterSpec;
import springframework util DigestUtils;
public class CryptHelper{
private static String CRYPT_KEY = zhongqian ;
//加密
private static Cipher ecip;
//解密
private static Cipher dcip;
static {
try {
String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）
KEY = KEY substring（ ）
byte[] bytes = KEY getBytes（）
DESKeySpec ks = new DESKeySpec（bytes）
SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）
SecretKey sk = skf generateSecret（ks）
IvParameterSpec iv = new IvParameterSpec（bytes）
ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）
ecip init（Cipher ENCRYPT_MODE sk iv ）
dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）
dcip init（Cipher DECRYPT_MODE sk iv ）
}catch（Exception ex） {
ex printStackTrace（）
}
}
public static String encrypt（String content） throws Exception {
byte[] bytes = ecip doFinal（content getBytes（ ascii ））
return CryptUtils byte hex（bytes）
}
public static String decrypt（String content） throws Exception {
byte[] bytes = CryptUtils hex byte（content）
bytes = dcip doFinal（bytes）
return new String（bytes ascii ）
}
//test
public static void main（String[] args） throws Exception {
String password = gly ;
String en = encrypt（password）
System out println（en）
System out println（decrypt（en））
}
}
package gdie lab crypt;
import javax crypto Cipher;
import javax crypto SecretKey;
import javax crypto SecretKeyFactory;
import javax crypto spec DESKeySpec;
import javax crypto spec IvParameterSpec;
import springframework util DigestUtils;
public class CryptHelper{
private static String CRYPT_KEY = zhongqian ;
//加密
private static Cipher ecip;
//解密
private static Cipher dcip;
static {
try {
String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）
KEY = KEY substring（ ）
byte[] bytes = KEY getBytes（）
DESKeySpec ks = new DESKeySpec（bytes）
SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）
SecretKey sk = skf generateSecret（ks）
IvParameterSpec iv = new IvParameterSpec（bytes）
ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）
ecip init（Cipher ENCRYPT_MODE sk iv ）
dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）
dcip init（Cipher DECRYPT_MODE sk iv ）
}catch（Exception ex） {
ex printStackTrace（）
}
}
public static String encrypt（String content） throws Exception {
byte[] bytes = ecip doFinal（content getBytes（ ascii ））
return CryptUtils byte hex（bytes）
}
public static String decrypt（String content） throws Exception {
byte[] bytes = CryptUtils hex byte（content）
bytes = dcip doFinal（bytes）
return new String（bytes ascii ）
}
//test
public static void main（String[] args） throws Exception {
String password = gly ;
String en = encrypt（password）
System out println（en）
System out println（decrypt（en））
}
lishixinzhi/Article/program/Java/hx/201311/26449
java代码解密的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java des加解密、java代码解密的信息别忘了在本站进行查找喔。
