一、Java軟體加密基本思路
對於應用軟體的保護筆者從兩個方面進行考慮，第一是阻止盜版使用軟體，第二是阻止競爭對手對軟體反編譯，即阻止對軟體的逆向工程。
1、阻止盜版
在軟體運行時對自身存在的合法性進行判斷，如果認為自身的存在和運行是被授權的、合法的，就運行；否則終止運行。這樣即使軟體可以被隨意復制，只要盜版用戶沒有相應的授權信息就無法使用軟體。
2、阻止反編譯
對編譯產生的Class文件加密處理，並在運行時進行解密，解密者無法對軟體進行反編譯。
二、Java軟體加密的總體流程
為了保護用Java語言開發的軟體，我們設計並實現了一個實用、高強度的加密演算法。以下稱需要保護的Java軟體為「受保護程序」，稱對「受保護程序」進行加密保護的軟體為「加密程序」。對軟體加密保護的流程如圖1所示。
三、加密演算法分析設計
1、用戶信息提取器設計
為了防止用戶發布序列號而導致「一次發行，到處都是」的盜版問題，提取用戶機器中硬體相關的、具有唯一性的信息——用戶計算機的硬碟分區C的序列號，並要求用戶將此信息與用戶名一起返回，之後用「序列號生成器」根據用戶返回信息生成一個唯一合法的軟體注冊序列號發回用戶，用戶即可使用此號碼注冊使用軟體。
這個信息提取器使用Winclows 32匯編以一個獨立的小程序方式實現，程序代碼如圖2所示。
2、序列號生成器與序列號合法性判斷函數的設計
序列號生成器與序列號合法性判斷函數中運用RSA加密演算法。在序列號生成器中是使用私鑰將用戶返回的信息（硬碟序列號，用戶名）進行加密得到相應的注冊序列號；在序列號合法性判斷函數中使用私鑰將用戶輸入的注冊序列號解密，再與（硬碟序列號，用戶名）進行比較，一致則調用程序裝載器將程序其他部分解密裝入內存，初始化刪環境並運行程序主體；否則退出。
RSA加密演算法的實現需要使用大數運算庫，我們使用MIRACL大數庫來實現RSA計算，序列號生成器的主要代碼如下：
char szlnputString[]=」機器碼和用戶名組成的字元串」;
char szSerial[256]=[0];//用於存放生成的注冊碼
bign，d，c，m; //MIRACL中的大數類型
mip→IBASE=16; //以16進制模式
n= mlrvar(0); //初始化大數
d= mirvar(0);
c= mirvar(0); //C存放輸入的字元串大數
m= mlrva(o);
bytes to big( len, szlnputString,c);
//將輸入字元串轉換成大數形式並存入變數c中
cinstr(n,」以字元串形成表示的模數」);//初始化模數
cinstr(d,」以字元串形成表示的公鑰」)：//初始化公鑰
powmod(c,d,n,m); //計算m=cdmod n
cotstr(m,szSerial)；//m的16進制字元串即為注冊碼
序列號合法性檢測函數的主要代碼如下：
char szlnputStringL]=」機器碼和用戶名組成的字元串」;
char szSerial[ 256]=」用戶輸入的序列號」
bign,e,c,m; //MIRACL中的大數類型
mip→IBASE=16; //以16進制模式
cinstr(m,szSerial); //將序列號的16進制轉成大數形式
cinstr(n,」模數n的字元串形式」);//初始化模數n
cinstr(e,」字元串形式的公鑰」);//初始化公鑰
if compare(m,n)==-1） //m<n時才進行解密
{
powmod(m,e,n,c);//計算m=me mod n
big_to _bytes(0,c,szSerial,0); //轉為字元串
return lstrcmp( szlnputString,szSerial);
}
3、強耦合關系的設計
如果在序列號合法性檢測函數中簡單地使用圖3所示流程：
解密者可以使用以下幾種手段進行攻擊：
（1）修改「判斷合法性子函數」的返回指令，讓它永遠返回正確值，這樣可以使用任意的序列號，安裝／使用軟體。
（2）修改判斷後的跳轉指令，使程序永遠跳到正確的分支運行，效果和上一種一樣。
（3）在「判斷合法性子函數」之前執行一條跳轉指令，繞過判斷，直接跳轉到「正常執行」分支運行，這樣可以不用輸入序列號安裝／使用軟體。
為阻止以上攻擊手段，筆者在程序中增加了「序列號合法性檢測函數」與程序其他部分「強耦合」（即增強其與程序其他部分的關聯度，成為程序整體密不可分的一部分，一旦被修改程序將無法正常工作）的要求（見圖1），並且設置一個「完整性檢測函數」用於判斷相關的代碼是否被修改過。當然，基於同樣的原因，「完整性檢測函數」也必須與程序其他部分存在「強耦合」關系。
強耦合關系通過以下方式建立：
在程序其他部分的函數（例如函數A）中隨機的訪問需要強耦合的「序列號合法性檢測函數」和「完整性檢測函數」，在調用時隨機的選擇使用一個錯誤的序列號或是用戶輸入的序列號，並根據返回結果選擇執行A中正常的功能代碼還是錯誤退出的功能代碼，流程如圖4所示。
經過這種改進，如果破解者通過修改代碼的方式破解將因「完整性檢測」失敗導致程序退出；如果使用SMC等技術繞過「序列號合法性判斷函數」而直接跳至序列號正確時的執行入口，在後續的運行中，將因為隨機的耦合調用失敗導致程序退出。破解者要破解軟體將不得不跟蹤所有進行了耦合調用的函數，這顯然是一個艱巨的任務。
4、完整性檢測函數的設計
我們使用CRC演算法算出需進行完整性檢測的文件的校驗碼，並用RSA加密演算法的公鑰（不同於序列號合法性檢測中的公鑰／私鑰對）將其加密存放在特定的文件中，在檢測時先用CRC演算法重新生成需進行完
整性檢測的文件的校驗碼，並用私鑰將保存的校驗碼解密，兩者相比較，相等則正常運行；否則退出。
5、程序載入器的設計
與編譯成機器碼執行的程序不同，Java程序只能由Java虛擬機解釋執行，因此程序載入器的工作包括：初始化Java虛擬機；在內存中解密當前要運行的class文件；使解密後的c:lass文件在虛擬機中運行，在
需要時解密另一個class文件。圖5是用於初始化JVM的代碼：
以上介紹了我們設計的針對Java軟體的加密保護方法，其中綜合運用了多種加密技術，抗破解強度高；使用純軟體保護技術，成本低。經筆者在Windows系列平台上進行測試，運行穩定，效果良好。
在研宄開發過程中，我們還總結出加密保護軟體的一些經驗：
1、對關鍵代碼和數據要靜態加密，再動態解密執行；要結合具體的工作平台使用反跟蹤／調試技術；
2、要充分利用系統的功能，如在Windows下使用DLL文件或驅動程序形式能得到最大的豐又限，可以充分利用系統具有的各種功能；
3、如果可能應該將關鍵代碼存放在不可禚復制的地方；
4、序列號要與機器碼等用戶信息相關以阻止鹽復布序列號；
5、加密流程的合理性比加密演算法本身的強度更重要。
『貳』 如何使用java對密碼加密 加密方式aes
Java有相關的實現類：具體原理如下
對於任意長度的明文，AES首先對其進行分組，每組的長度為128位。分組之後將分別對每個128位的明文分組進行加密。
對於每個128位長度的明文分組的加密過程如下：
（1）將128位AES明文分組放入狀態矩陣中。
（2）AddRoundKey變換：對狀態矩陣進行AddRoundKey變換，與膨脹後的密鑰進行異或操作（密鑰膨脹將在實驗原理七中詳細討論）。
（3）10輪循環：AES對狀態矩陣進行了10輪類似的子加密過程。前9輪子加密過程中，每一輪子加密過程包括4種不同的變換，而最後一輪只有3種變換，前9輪的子加密步驟如下：
● SubBytes變換：SubBytes變換是一個對狀態矩陣非線性的變換；
● ShiftRows變換：ShiftRows變換對狀態矩陣的行進行循環移位；
● MixColumns變換：MixColumns變換對狀態矩陣的列進行變換；
● AddRoundKey變換：AddRoundKey變換對狀態矩陣和膨脹後的密鑰進行異或操作。
最後一輪的子加密步驟如下：
● SubBytes變換：SubBytes變換是一個對狀態矩陣非線性的變換；
● ShiftRows變換：ShiftRows變換對狀態矩陣的行進行循環移位；
● AddRoundKey變換：AddRoundKey變換對狀態矩陣和膨脹後的密鑰進行異或操作；
（4）經過10輪循環的狀態矩陣中的內容就是加密後的密文。
AES的加密演算法的偽代碼如下。
在AES演算法中，AddRoundKey變換需要使用膨脹後的密鑰，原始的128位密鑰經過膨脹會產生44個字（每個字為32位）的膨脹後的密鑰，這44個字的膨脹後的密鑰供11次AddRoundKey變換使用，一次AddRoundKey使用4個字（128位）的膨脹後的密鑰。
三．AES的分組過程
對於任意長度的明文，AES首先對其進行分組，分組的方法與DES相同，即對長度不足的明文分組後面補充0即可，只是每一組的長度為128位。
AES的密鑰長度有128比特，192比特和256比特三種標准，其他長度的密鑰並沒有列入到AES聯邦標准中，在下面的介紹中，我們將以128位密鑰為例。
四．狀態矩陣
狀態矩陣是一個4行、4列的位元組矩陣，所謂位元組矩陣就是指矩陣中的每個元素都是一個1位元組長度的數據。我們將狀態矩陣記為State，State中的元素記為Sij，表示狀態矩陣中第i行第j列的元素。128比特的明文分組按位元組分成16塊，第一塊記為「塊0」，第二塊記為「塊1」，依此類推，最後一塊記為「塊15」，然後將這16塊明文數據放入到狀態矩陣中，將這16塊明文數據放入到狀態矩陣中的方法如圖2-2-1所示。
塊0
塊4
塊8
塊12
塊1
塊5
塊9
塊13
塊2
塊6
塊10
塊14
塊3
塊7
塊11
塊15
圖2-2-1 將明文塊放入狀態矩陣中
五．AddRoundKey變換
狀態矩陣生成以後，首先要進行AddRoundKey變換，AddRoundKey變換將狀態矩陣與膨脹後的密鑰進行按位異或運算，如下所示。
其中，c表示列數，數組W為膨脹後的密鑰，round為加密輪數，Nb為狀態矩陣的列數。
它的過程如圖2-2-2所示。
圖2-2-2 AES演算法AddRoundKey變換
六．10輪循環
經過AddRoundKey的狀態矩陣要繼續進行10輪類似的子加密過程。前9輪子加密過程中，每一輪要經過4種不同的變換，即SubBytes變換、ShiftRows變換、MixColumns變換和AddRoundKey變換，而最後一輪只有3種變換，即SubBytes變換、ShiftRows變換和AddRoundKey變換。AddRoundKey變換已經討論過，下面分別討論餘下的三種變換。
1．SubBytes變換
SubBytes是一個獨立作用於狀態位元組的非線性變換，它由以下兩個步驟組成：
（1）在GF（28）域，求乘法的逆運算，即對於α∈GF（28）求β∈GF（28），使αβ =βα = 1mod（x8 + x4 + x3 + x + 1）。
（2）在GF（28）域做變換，變換使用矩陣乘法，如下所示：
由於所有的運算都在GF（28）域上進行，所以最後的結果都在GF（28）上。若g∈GF（28）是GF（28）的本原元素，則對於α∈GF（28），α≠0，則存在
β ∈ GF（28），使得：
β = gαmod（x8 + x4 + x3 + x + 1）
由於g255 = 1mod（x8 + x4 + x3 + x + 1）
所以g255-α = β-1mod（x8 + x4 + x3 + x + 1）
根據SubBytes變換演算法，可以得出SubBytes的置換表，如表2-2-1所示，這個表也叫做AES的S盒。該表的使用方法如下：狀態矩陣中每個元素都要經過該表替換，每個元素為8比特，前4比特決定了行號，後4比特決定了列號，例如求SubBytes(0C)查表的0行C列得FE。
表2-2-1 AES的SubBytes置換表
它的變換過程如圖2-2-3所示。
圖2-2-3 SubBytes變換
AES加密過程需要用到一些數學基礎，其中包括GF(2)域上的多項式、GF（28）域上的多項式的計算和矩陣乘法運算等，有興趣的同學請參考相關的數學書籍。
2．ShiftRows變換
ShiftRows變換比較簡單，狀態矩陣的第1行不發生改變，第2行循環左移1位元組，第3行循環左移2位元組，第4行循環左移3位元組。ShiftRows變換的過程如圖2-2-4所示。
圖2-2-4 AES的ShiftRows變換
3．MixColumns變換
在MixColumns變換中，狀態矩陣的列看作是域GF（28）的多項式，模(x4＋1)乘以c（x）的結果：
c(x)＝(03)x3＋(01)x2+(01)x+(02)
這里(03)為十六進製表示，依此類推。c(x)與x4＋1互質，故存在逆：
d(x)=(0B)x3＋(0D)x2＋(0G)x＋(0E)使c(x)•d(x) = (D1)mod(x4＋1)。
設有：
它的過程如圖2-2-5所示。
圖2-2-5 AES演算法MixColumns變換
七．密鑰膨脹
在AES演算法中，AddRoundKey變換需要使用膨脹後的密鑰，膨脹後的密鑰記為子密鑰，原始的128位密鑰經過膨脹會產生44個字（每個字為32位）的子密鑰，這44個字的子密鑰供11次AddRoundKey變換使用，一次AddRoundKey使用4個字（128位）的膨脹後的密鑰。
密鑰膨脹演算法是以字為基礎的（一個字由4個位元組組成，即32比特）。128比特的原始密鑰經過膨脹後將產生44個字的子密鑰，我們將這44個密鑰保存在一個字數組中，記為W[44]。128比特的原始密鑰分成16份，存放在一個位元組的數組：Key[0]，Key[1]……Key[15]中。
在密鑰膨脹演算法中，Rcon是一個10個字的數組，在數組中保存著演算法定義的常數，分別為：
Rcon[0] = 0x01000000
Rcon[1] = 0x02000000
Rcon[2] = 0x04000000
Rcon[3] = 0x08000000
Rcon[4] = 0x10000000
Rcon[5] = 0x20000000
Rcon[6] = 0x40000000
Rcon[7] = 0x80000000
Rcon[8] = 0x1b000000
Rcon[9] = 0x36000000
另外，在密鑰膨脹中包括其他兩個操作RotWord和SubWord，下面對這兩個操作做說明：
RotWord( B0,B1,B2,B3 )對4個位元組B0,B1,B2,B3進行循環移位，即
RotWord( B0,B1,B2,B3 ) = ( B1,B2,B3,B0 )
SubWord( B0,B1,B2,B3 )對4個位元組B0,B1,B2,B3使用AES的S盒，即
SubWord( B0,B1,B2,B3 ) = ( B』0,B』1,B』2,B』3 )
其中，B』i = SubBytes（Bi），i = 0,1,2,3。
密鑰膨脹的演算法如下：
八．解密過程
AES的加密和解密過程並不相同，首先密文按128位分組，分組方法和加密時的分組方法相同，然後進行輪變換。
AES的解密過程可以看成是加密過程的逆過程，它也由10輪循環組成，每一輪循環包括四個變換分別為InvShiftRows變換、InvSubBytes變換、InvMixColumns變換和AddRoundKey變換；
這個過程可以描述為如下代碼片段所示：
九．InvShiftRows變換
InvShiftRows變換是ShiftRows變換的逆過程，十分簡單，指定InvShiftRows的變換如下。
Sr,(c+shift(r,Nb))modNb= Sr,c for 0 < r< 4 and 0 ≤ c < Nb
圖2-2-6演示了這個過程。
圖2-2-6 AES演算法InvShiftRows變換
十．InvSubBytes變換
InvSubBytes變換是SubBytes變換的逆變換，利用AES的S盒的逆作位元組置換，表2-2-2為InvSubBytes變換的置換表。
表2-2-2 InvSubBytes置換表
十一．InvMixColumns變換
InvMixColumns變換與MixColumns變換類似，每列乘以d(x)
d(x) = (OB)x3 + (0D)x2 + (0G)x + (0E)
下列等式成立：
( (03)x3 + (01)x2 + (01)x + (02) )⊙d(x) = (01)
上面的內容可以描述為以下的矩陣乘法：
十二．AddRoundKey變換
AES解密過程的AddRoundKey變換與加密過程中的AddRoundKey變換一樣，都是按位與子密鑰做異或操作。解密過程的密鑰膨脹演算法也與加密的密鑰膨脹演算法相同。最後狀態矩陣中的數據就是明文。
『叄』 java中怎麼用jsp調用已有的介面,調用加密工具類,拼接參數
jsp中傳值到servlet有三種方法：
JSP頁面有3種方法向 servlet傳值： form表單、URL
方法一：
<%
session.setAttribute("testSession","Hello session");
reqeust.setAttribute("testRequest","Hello request");
%>
方法二：
<a href="JspServlet?action=toServlet">點擊提交傳參數</a>
方法三：
<form action="JspServlet?action=toServlet" method="post" name="form">
<input name="username" type="test" />
<input type="submit" value="submit">
</form>
1、對於該JSP頁面 form表單的內容，如 <input>標簽，在 servlet可用 request.getParameter("username");獲取。
2、URL：比如這里的 <a>標簽的 href屬性與 <form>標簽的 action屬性的值 "JspServlet?action=toServlet"，在 servlet同樣用 request.getParameter("action")獲取；所要注意的是這里的 url 要和 servlet在web.xml里的 <url-pattern>標簽的路徑所對應。這部分後面會提到。
3、java片段代碼，servlet只能接到 session.setAttribute("testSession","Hello session")的內容，而接不到 request的內容。在 servlet里用 request.getSession().getAttribute("testSession")獲取 session內容。
『肆』 java 程序gpg加密， 因為程序調用命令時需要確認，有沒有方法不需要確認直接一條命令或者程序就可以執行
你是說gpg需要密碼？導致不能簡單的調用gpg命令是吧。 其實如果gpg和應用程序交互的話不應該使用命令行 調用命令行會導緻密碼可以被黑客獲取，比如黑客可以模擬一個假的gpg 程序，你的程序調用後 就把密碼傳遞給它了，它再去調用真實gpg，破解難度降低。應該直接調用gpg的lib：libgcrypt 。
另一個解決辦法是gpg2 提供使用 命名管道的方式和應用程序交互 linux可用。
『伍』 如何利用JAVA對文檔進行加密和解密處理，完整的java類
我以前上密碼學課寫過一個DES加解密的程序，是自己實現的，不是通過調用java庫函數，代碼有點長，帶有用戶界面。需要的話聯系我
『陸』 求大神用java實現RC4的加密,解密功能,高分懸賞.
importjavax.crypto.Cipher;
importjavax.crypto.spec.SecretKeySpec;
importjavax.xml.bind.DatatypeConverter;
publicclassTest{
publicstaticvoidmain(String[]args)throwsException{
Ciphercipher=Cipher.getInstance("RC4");
Stringpwd="123456";
Stringptext="HelloWorld你好";
SecretKeySpeckey=newSecretKeySpec(pwd.getBytes("UTF-8"),"RC4");
cipher.init(Cipher.ENCRYPT_MODE,key);
byte[]cdata=cipher.update(ptext.getBytes("UTF-8"));
//解密
cipher.init(Cipher.DECRYPT_MODE,key);
byte[]ddata=cipher.update(cdata);
System.out.println("密碼:"+pwd);
System.out.println("明文:"+ptext);
System.out.println("密文:"+DatatypeConverter.printHexBinary(cdata));
System.out.println("解密文:"+newString(ddata,"UTF-8"));
}
}
密碼:123456
明文:HelloWorld你好
密文:
解密文:HelloWorld你好
RC4已經不太安全，只能用於一般加密，不能用於金融等緊要場合。
『柒』 java怎麼調用別人加密後的介面啊
1、調用WebService，對方給出WebService地址，可以用Axis生成對WebService的調用代碼進行調用
2、對方提供介面文檔和傳輸方式，根據介面文檔調用。
Java介面是一系列方法的聲明，是一些方法特徵的集合，一個介面只有方法的特徵沒有方法的實現，因此這些方法可以在不同的地方被不同的類實現，而這些實現可以具有不同的行為（功能）。
兩種含義：一，Java介面，Java語言中存在的結構，有特定的語法和結構；二，一個類所具有的方法的特徵集合，是一種邏輯上的抽象。前者叫做「Java介面」，後者叫做「介面」。
『捌』 如何用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 http://blog.csdn.net/qiushyfm
*/
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!");
}
}
}
『玖』 如何用Java進行3DES加密解密
這里是例子，直接拿來用就可以了。
package com.nnff.des;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
/*字元串 DESede(3DES) 加密
* ECB模式/使用PKCS7方式填充不足位,目前給的密鑰是192位
* 3DES（即Triple DES）是DES向AES過渡的加密演算法（1999年，NIST將3-DES指定為過渡的
* 加密標准），是DES的一個更安全的變形。它以DES為基本模塊，通過組合分組方法設計出分組加
* 密演算法，其具體實現如下：設Ek()和Dk()代表DES演算法的加密和解密過程，K代表DES演算法使用的
* 密鑰，P代表明文，C代表密表，這樣，
* 3DES加密過程為：C=Ek3(Dk2(Ek1(P)))
* 3DES解密過程為：P=Dk1((EK2(Dk3(C)))
* */
public class ThreeDes {
/**
* @param args在java中調用sun公司提供的3DES加密解密演算法時，需要使
* 用到$JAVA_HOME/jre/lib/目錄下如下的4個jar包：
*jce.jar
*security/US_export_policy.jar
*security/local_policy.jar
*ext/sunjce_provider.jar
*/
private static final String Algorithm = "DESede"; //定義加密演算法,可用 DES,DESede,Blowfish
//keybyte為加密密鑰，長度為24位元組
//src為被加密的數據緩沖區（源）
public static byte[] encryptMode(byte[] keybyte,byte[] src){
try {
//生成密鑰
SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
//加密
Cipher c1 = Cipher.getInstance(Algorithm);
c1.init(Cipher.ENCRYPT_MODE, deskey);
return c1.doFinal(src);//在單一方面的加密或解密
} catch (java.security.NoSuchAlgorithmException e1) {
// TODO: handle exception
e1.printStackTrace();
}catch(javax.crypto.NoSuchPaddingException e2){
e2.printStackTrace();
}catch(java.lang.Exception e3){
e3.printStackTrace();
}
return null;
}
//keybyte為加密密鑰，長度為24位元組
//src為加密後的緩沖區
public static byte[] decryptMode(byte[] keybyte,byte[] src){
try {
//生成密鑰
SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
//解密
Cipher c1 = Cipher.getInstance(Algorithm);
c1.init(Cipher.DECRYPT_MODE, deskey);
return c1.doFinal(src);
} catch (java.security.NoSuchAlgorithmException e1) {
// TODO: handle exception
e1.printStackTrace();
}catch(javax.crypto.NoSuchPaddingException e2){
e2.printStackTrace();
}catch(java.lang.Exception e3){
e3.printStackTrace();
}
return null;
}
//轉換成十六進制字元串
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();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
//添加新安全演算法,如果用JCE就要把它添加進去
Security.addProvider(new com.sun.crypto.provider.SunJCE());
final byte[] keyBytes = {0x11, 0x22, 0x4F, 0x58,
(byte)0x88, 0x10, 0x40, 0x38, 0x28, 0x25, 0x79, 0x51,
(byte)0xCB,
(byte)0xDD, 0x55, 0x66, 0x77, 0x29, 0x74,
(byte)0x98, 0x30, 0x40, 0x36,
(byte)0xE2
}; //24位元組的密鑰
String szSrc = "This is a 3DES test. 測試";
System.out.println("加密前的字元串:" + szSrc);
byte[] encoded = encryptMode(keyBytes,szSrc.getBytes());
System.out.println("加密後的字元串:" + new String(encoded));
byte[] srcBytes = decryptMode(keyBytes,encoded);
System.out.println("解密後的字元串:" + (new String(srcBytes)));
}
}