class文件加密

① java反編譯後是全路徑怎麼處理

最簡單的方法就是讓用戶不能夠訪問到Java Class程序，這種方法是最根本的方法，具體實現有多種方式。例如，開發人員可以將關鍵的Java Class放在伺服器端，客戶端通過訪問伺服器的相關介面來獲得服務，而不是直接訪問Class文件。這樣黑客就沒有辦法反編譯Class文件。

2.對Class文件進行加密
為了防止 Class 文件被直接反編譯，許多開發人員將一些關鍵的 Class 文件進行加密，例如對注冊碼、序列號管理相關的類等。在使用這些被加密的類之前，程序首先需要對這些類進行解密，而後再將這些類裝載到JVM當中。這些類的解密可以由硬體完成，也可以使用軟體完成。

② javaclass類加密後 如何部署到tomcat

1.使用加密程序對classes下所有文件加密，加密之後所有的class文件後綴變為uikoo9，可以自己修改源代碼
2.將原classes文件夾刪除，將加密後的classes文件夾復制進去
3.修改context.xml
4.tomcat\lib下添加loader.class
5.啟動tomcat！

③ 為什麼反編譯點class文件不能被編輯啊

由於Java位元組碼的抽象級別較高，因此它們較容易被反編譯。下面介紹了幾種常用的方法，用於保護Java位元組碼不被反編譯。
1.隔離Java程序
2.對Class文件進行加密
3.轉換成本地代碼
4.代碼混淆

④ JAVA程序加密，怎麼做才安全

程序加密？你說的是代碼加密還是數據加密。我都說一下吧。

Java代碼加密：

這點因為Java是開源的，想達到完全加密，基本是不可能的，因為在反編譯的時候，雖然反編譯回來的時候可能不是您原來的代碼，但是意思是接近的，所以是不行的。

那麼怎麼增加反編譯的難度（閱讀難度），那麼可以採用多層繼承（實現）方式來解決，這樣即使反編譯出來的代碼，可讀性太差，復用性太差了。

Java數據加密：

我們一般用校驗性加密，常用的是MD5，優點是速度快，數據佔用空間小。缺點是不可逆，所以我們一般用來校驗數據有沒有被改動等。

需要可逆，可以選用base64，Unicode，缺點是沒有密鑰，安全性不高。

而我們需要可逆而且採用安全的方式是：對稱加密和非堆成加密，我們常用的有AES、DES等單密鑰和雙密鑰的方式。而且是各種語言通用的。

全部手動敲字，望採納，下面是我用Javascript方式做的一系列在線加密/解密工具：

http://www.sojson.com/encrypt.html

⑤ 怎麼對加密的JAVA class文件進行解密

JAVA class文件加密解密

package com..encrypt;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
public class FileEncryptAndDecrypt {
/**
* 文件file進行加密
* @param fileUrl 文件路徑
* @param key 密碼
* @throws Exception
*/
public static void encrypt(String fileUrl, String key) throws Exception {
File file = new File(fileUrl);
String path = file.getPath();
if(!file.exists()){
return;
}
int index = path.lastIndexOf("\\");
String destFile = path.substring(0, index)+"\\"+"abc";
File dest = new File(destFile);
InputStream in = new FileInputStream(fileUrl);
OutputStream out = new FileOutputStream(destFile);
byte[] buffer = new byte[1024];
int r;
byte[] buffer2=new byte[1024];
while (( r= in.read(buffer)) > 0) {
for(int i=0;i<r;i++)
{
byte b=buffer[i];
buffer2[i]=b==255?0:++b;
}
out.write(buffer2, 0, r);
out.flush();
}
in.close();
out.close();
file.delete();
dest.renameTo(new File(fileUrl));
appendMethodA(fileUrl, key);
System.out.println("加密成功");
}
/**
*
* @param fileName
* @param content 密鑰
*/
public static void appendMethodA(String fileName, String content) {
try {
// 打開一個隨機訪問文件流，按讀寫方式
RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
// 文件長度，位元組數
long fileLength = randomFile.length();
//將寫文件指針移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 解密
* @param fileUrl 源文件
* @param tempUrl 臨時文件
* @param ketLength 密碼長度
* @return
* @throws Exception
*/
public static String decrypt(String fileUrl, String tempUrl, int keyLength) throws Exception{
File file = new File(fileUrl);
if (!file.exists()) {
return null;
}
File dest = new File(tempUrl);
if (!dest.getParentFile().exists()) {
dest.getParentFile().mkdirs();
}
InputStream is = new FileInputStream(fileUrl);
OutputStream out = new FileOutputStream(tempUrl);
byte[] buffer = new byte[1024];
byte[] buffer2=new byte[1024];
byte bMax=(byte)255;
long size = file.length() - keyLength;
int mod = (int) (size%1024);
int div = (int) (size>>10);
int count = mod==0?div:(div+1);
int k = 1, r;
while ((k <= count && ( r = is.read(buffer)) > 0)) {
if(mod != 0 && k==count) {
r = mod;
}
for(int i = 0;i < r;i++)
{
byte b=buffer[i];
buffer2[i]=b==0?bMax:--b;
}
out.write(buffer2, 0, r);
k++;
}
out.close();
is.close();
return tempUrl;
}
/**
* 判斷文件是否加密
* @param fileName
* @return
*/
public static String readFileLastByte(String fileName, int keyLength) {
File file = new File(fileName);
if(!file.exists())return null;
StringBuffer str = new StringBuffer();
try {
// 打開一個隨機訪問文件流，按讀寫方式
RandomAccessFile randomFile = new RandomAccessFile(fileName, "r");
// 文件長度，位元組數
long fileLength = randomFile.length();
//將寫文件指針移到文件尾。
for(int i = keyLength ; i>=1 ; i--){
randomFile.seek(fileLength-i);
str.append((char)randomFile.read());
}
randomFile.close();
return str.toString();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}

⑥ class文件詳解

能夠被JVM識別，載入並執行的文件格式

1.通過IDE自動幫我們build。
2.手動通過javac去生成class文件。

記錄一個類文件的所有信息。

1.一種8位位元組的二進制流文件
2.各個數據按順序緊密地排列，無間隙 （這樣做的好處可以減少class文件的體積，jvm載入我們class文件的時候更加快速）
3.每個類、介面和枚舉都單獨占據一個class文件（這樣做的好處是每個累介面等都可以獨自管理自己內部的內容而無需相互交叉）
整體文件格式：

格式詳解：
1.magic
無符號4位元組，用來表示class文件的開頭，加密段，給虛擬機用來判斷當前的 class文件是否被串改過。
2.minor_version
class文件最小可以被哪個版本的jdk所載入，也就是最小適配的jdk
3.major_version
表示我們當前class文件是由哪個版本的jdk生成的。
4.constant_pool_count
class文件中常量池的數量，通常只有一個常量池。
5.constant_pool
代表常量池，類型為cp_info（結構體類型）。
常量池中主要包含的內容：
首先列舉三個比較簡單的
CONSTANT_Integer_info:存儲class文件中的int類型。
CONSTANT_Long_info:存儲class文件中的long類型。
CONSTANT_String_info:存儲class文件中的string類型。
它們分別存儲位元組碼中的int、long、string類型，當然還有CONSTANT_Short_info、CONSTANT_Float_info等。
下面列舉幾個稍微復雜的
CONSTANT_Class_info:記錄類中相關的信息、不僅記錄了當前類的信息，還記錄了引用到的一些類的信息。
CONSTANT_Fieldref_info:記錄類中Field相關的信息。
CONSTANT_Methodref_info:記錄類中Method相關的信息。
這三個裡面存儲的並不是真正的內容，都是一些索引，這些索引指向的又是CONSTANT_String_info等。
6.access_flags
表示class文件的作用域標志，比如：public 、public final
取值范圍：

7.this_class
this_class是指向constant pool的索引值，該值必須是CONSTANT_Class_info類型，指定當前位元組碼定義的類或介面。
8.super_class
super_class是指向constant pool的索引值，該值必須是CONSTANT_Class_info類型，指定當前位元組碼定義的類或介面的直接父類。只有Object類才沒有直接父類，此時該索引值為0。並且父類不能是final類型。介面的父類都是Object類。
9.interfaces_count
當前class文件直接實現的介面數量。
10.interfaces
當前class文件直接實現的介面，只記錄直接實現的，不會記錄間接實現的。
11.fields_count
class文件中成員變數的數量。
12.fields
class文件中所有的成員變數，field_info類型的結構體，該結構體中主要包含了每個成員變數的name、所屬的類以及類型。
13.methods_count
記錄class文件中方法的數量。
14.methods
記錄class文件中所有的方法，類型為method_info結構體類型，主要包含了方法的名字、類型、access_flags等信息。
15.attribute_count
記錄了class文件屬性的數量。
16.attributes
記錄class文件的一些屬性，除去上面的一些信息剩下的都包含在attributes中，比如 說註解。

1.內存佔用大，不適合移動端。
2.堆棧的載入模式，載入速度慢。
3.文件IO操作多，類查找慢。

⑦ Class文件加密後，tomcat啟動錯誤，怎麼解決

給你提供幾種方式吧： 1：最快最直接的辦法，購買第三方的加密軟體，我以前用的就是第三方的加密軟體。 2：對代碼進行加密，更改自己的JDK和tomcat的在解析的時候使用解密，這種的不夠級別就別改了。 這個很早就有人研究了。

⑧ 怎麼能讓spring框架載入加密後的.class文件

加密：使用AES加密，將文件的位元組碼讀取，對位元組碼進行加密後替換源文件

Java代碼

/**

*

* 位元組加密

*/

public static byte[] encrypt(byte[] data, String key) throws Exception {

Key k = toKey(Base64.decode(key));

byte[] raw = k.getEncoded();

SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);

return cipher.doFinal(data);

}
/**
*
* 位元組加密
*/
public static byte[] encrypt(byte[] data, String key) throws Exception {
Key k = toKey(Base64.decode(key));
byte[] raw = k.getEncoded();
SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
return cipher.doFinal(data);
}

解密：

1、在tomcat的WebappClassLoader中修改源碼（自動義類載入器）；

2、修改spring源碼Code包源碼。

加密方法

Java代碼

public static byte[] decrypt(byte[] data, String key) throws Exception {

Key k = toKey(Base64.decode(key));

byte[] raw = k.getEncoded();

SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);

return cipher.doFinal(data);

}
public static byte[] decrypt(byte[] data, String key) throws Exception {
Key k = toKey(Base64.decode(key));
byte[] raw = k.getEncoded();
SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
return cipher.doFinal(data);
}

在 WebappClassLoader中解密

Java代碼

/**

* 判斷如需是需要解密的類進行數據處理

* */

//--------------------------------------start----------------------------------//

byte []data=null;

try {

if(isDecode(name)){

System.out.println("2818:--&&&-"+name);

data=AESUtils.decrypt(entry.binaryContent, key);

}else{

data=entry.binaryContent;

}

} catch (Exception e) {

e.printStackTrace();

}

try {

clazz = defineClass(name, data, 0,

data.length,

new CodeSource(entry.codeBase, entry.certificates));

//--------------------------------------end----------------------------------//
/**
* 判斷如需是需要解密的類進行數據處理
* */
//--------------------------------------start----------------------------------//
byte []data=null;
try {
if(isDecode(name)){
System.out.println("2818:--&&&-"+name);
data=AESUtils.decrypt(entry.binaryContent, key);
}else{
data=entry.binaryContent;
}
} catch (Exception e) {
e.printStackTrace();
}
try {
clazz = defineClass(name, data, 0,
data.length,
new CodeSource(entry.codeBase, entry.certificates));
//--------------------------------------end----------------------------------//

在spring的code包的SimpleMetadataReader修改器構造函數

Java代碼

// TODO 修改源碼判斷是否需要解密

SimpleMetadataReader(Resource resource, ClassLoader classLoader)

throws IOException {

InputStream is = resource.getInputStream();

ClassReader classReader = null;

try {

String name = "";

if (resource.getURI().toString().indexOf("jar:file") == -1) {

name = resource.getFile().getAbsolutePath();

if (!"".equals(name) && isDecode(name, cams)) {

byte[] data = inputStreamToByte(is);

try {

is = new ByteArrayInputStream(AESUtils.decrypt(data,

key));

// is = new ByteArrayInputStream(data);

} catch (Exception e) {

e.printStackTrace();

}

}

}

classReader = new ClassReader(is);

} finally {

is.close();

}
// TODO 修改源碼判斷是否需要解密
SimpleMetadataReader(Resource resource, ClassLoader classLoader)
throws IOException {
InputStream is = resource.getInputStream();
ClassReader classReader = null;
try {
String name = "";
if (resource.getURI().toString().indexOf("jar:file") == -1) {
name = resource.getFile().getAbsolutePath();
if (!"".equals(name) && isDecode(name, cams)) {
byte[] data = inputStreamToByte(is);
try {
is = new ByteArrayInputStream(AESUtils.decrypt(data,
key));
// is = new ByteArrayInputStream(data);
} catch (Exception e) {
e.printStackTrace();
}
}
}
classReader = new ClassReader(is);
} finally {
is.close();
}

在同樣需要進行解密。

註：(此加密有弊端)

1、加密解密演算法需保持一致。

2、加密加密密鑰需是同一密鑰。

⑨ 防止Class類反編譯的方法，對Class進行加密

這個我之前也研究過，現在與你分享一下吧。希望對你有幫助：

首先在介紹反編譯器之前，要提及JDK自帶的一個工具 [javap] ,它是一個Java代碼反匯編器。

然後其次是有一個sourceforge中開源的一個反編譯器 Jode(http://jode.sourceforge.net/download.html) 下載。

反編譯對安全構成的威脅是顯而易見的，因此源碼保護也就必不可少的。其實，反編譯和代碼保護是一場無停止斗爭，雙方都在爭斗中得以發展。

那麼到目前為止，保護源碼大致可以分為三類： 加密、模糊、和定製JAVA類裝載器。現在依我看來，流行的工具有 PGP(Pretty Good Privacy) 和 GPG(Gnu Pirvacy Guard)等等（有些名字忘記了！呵呵！）

我先講講模糊技術吧，Obfuscator就是對源代碼進行模糊化處理的行為。但是經過模糊處理後的代碼，將失去了一些可讀 性，程序員很難識別代碼的用意。利用模糊處理的工具是 Smokescreen(http://www.leesw.com/smokescreen/licensedownload.html).....

至於類載入器，你只需要看看ClassLoader的原理就行了。具體代碼實現的太多了，打字打的累！！！！

我先說這么多了，如果還有什麼不明白的可以加我MSN與我討論：[email protected]
即可！