java演算法加密
接下來我們介紹對稱加密演算法 最常用的莫過於DES數據加密演算法
DES
DES Data Encryption Standard 即數據加密演算法 是IBM公司於 年研究成功並公開發表的 DES演算法的入口參數有三個 Key Data Mode 其中Key為 個位元組共 位 是DES演算法的工作密鑰 Data也為 個位元組 位 是要被加密或被解密的數據 Mode為DES的工作方式 有兩種 加密或解密
DES演算法把 位的明文輸入塊變為 位的密文輸出塊 它所使用的密鑰也是 位
通過java代碼實現如下
importjava security Key;importjava security SecureRandom;importjavax crypto Cipher;importjavax crypto KeyGenerator;importjavax crypto SecretKey;importjavax crypto SecretKeyFactory;importjavax crypto spec DESKeySpec;/***//***DES安全編碼組件authorby;**<pre>*支持DES DESede(TripleDES 就是 DES) AES Blowfish RC RC (ARCFOUR)*DESkeysizemustbeequalto *DESede(TripleDES)keysizemustbeequalto or *AESkeysizemustbeequalto or but and bitsmaynotbeavailable* andcanonlyrangefrom to (inclusive)*RC keysizemustbebeeen and bits*RC (ARCFOUR)keysizemustbebeeen and bits*具體內容需要關注JDKDocument&///docs/technotes/guides/security/l*</pre>**@author梁棟*@version *@since */{/***//***ALGORITHM演算法<br>*可替換為以下任意一種演算法 同時key值的size相應改變 **<pre>*DESkeysizemustbeequalto *DESede(TripleDES)keysizemustbeequalto or *AESkeysizemustbeequalto or but and bitsmaynotbeavailable* andcanonlyrangefrom to (inclusive)*RC keysizemustbebeeen and bits*RC (ARCFOUR)keysizemustbebeeen and bits*</pre>**在KeytoKey(byte[]key)方法中使用下述代碼*<code>SecretKeysecretKey=newSecretKeySpec(key ALGORITHM);</code>替換*<code>*DESKeySpecdks=newDESKeySpec(key);*SecretKeyFactorykeyFactory=SecretKeyFactory getInstance(ALGORITHM);*SecretKeysecretKey=keyFactory generateSecret(dks);*</code>*/= DES ;/***//***轉換密鑰<br>**@paramkey*@return*@throwsException*/privatestaticKeytoKey(byte[]key)throwsException{DESKeySpecdks=newDESKeySpec(key);SecretKeyFactorykeyFactory=SecretKeyFactory getInstance(ALGORITHM);SecretKeysecretKey=keyFactory generateSecret(dks);//當使用其他對稱加密演算法時 如AES Blowfish等演算法時 用下述代碼替換上述三行代碼//SecretKeysecretKey=newSecretKeySpec(key ALGORITHM);returnsecretKey;}/***//***解密**@paramdata*@paramkey*@return*@throwsException*/publicstaticbyte[]decrypt(byte[]data Stringkey)throwsException{Keyk=toKey(decryptBASE (key));Ciphercipher=Cipher getInstance(ALGORITHM);cipher init(Cipher DECRYPT_MODE k);returncipher doFinal(data);}/***//***加密**@paramdata*@paramkey*@return*@throwsException*/publicstaticbyte[]encrypt(byte[]data Stringkey)throwsException{Keyk=toKey(decryptBASE (key));Ciphercipher=Cipher getInstance(ALGORITHM);cipher init(Cipher ENCRYPT_MODE k);returncipher doFinal(data);}/***//***生成密鑰**@return*@throwsException*/publicstaticStringinitKey()throwsException{returninitKey(null);}/***//***生成密鑰**@paramseed*@return*@throwsException*/publicstaticStringinitKey(Stringseed)throwsException{SecureRandomsecureRandom=null;if(seed!=null){secureRandom=newSecureRandom(decryptBASE (seed));}else{secureRandom=newSecureRandom();}KeyGeneratorkg=KeyGenerator getInstance(ALGORITHM);kg init(secureRandom);SecretKeysecretKey=kg generateKey();returnencryptBASE (secretKey getEncoded());}}
延續上一個類的實現 我們通過MD 以及SHA對字元串加密生成密鑰 這是比較常見的密鑰生成方式
再給出一個測試類
importstatic junit Assert *;import junit Test;/***//****@authorby;;*@version *@since */publicclassDESCoderTest{@Testpublicvoidtest()throwsException{StringinputStr= DES ;Stringkey=DESCoder initKey();System err println( 原文: +inputStr);System err println( 密鑰: +key);byte[]inputData=inputStr getBytes();inputData=DESCoder encrypt(inputData key);System err println( 加密後: +DESCoder encryptBASE (inputData));byte[]outputData=DESCoder decrypt(inputData key);StringoutputStr=newString(outputData);System err println( 解密後: +outputStr);assertEquals(inputStr outputStr);}}
得到的輸出內容如下
原文 DES
密鑰 f wEtRrV q =
加密後 C qe oNIzRY=
解密後 DES
由控制台得到的輸出 我們能夠比對加密 解密後結果一致 這是一種簡單的加密解密方式 只有一個密鑰
其實DES有很多同胞兄弟 如DESede（TripleDES） AES Blowfish RC RC （ARCFOUR） 這里就不過多闡述了 大同小異 只要換掉ALGORITHM換成對應的值 同時做一個代碼替換SecretKey secretKey = new SecretKeySpec（key ALGORITHM） 就可以了 此外就是密鑰長度不同了
/**
lishixin/Article/program/Java/gj/201311/27624
② java最常用的幾種加密演算法
簡單的Java加密演算法有：
第一種. BASE
Base是網路上最常見的用於傳輸Bit位元組代碼的編碼方式之一，大家可以查看RFC～RFC，上面有MIME的詳細規范。Base編碼可用於在HTTP環境下傳遞較長的標識信息。例如，在Java Persistence系統Hibernate中，就採用了Base來將一個較長的唯一標識符（一般為-bit的UUID）編碼為一個字元串，用作HTTP表單和HTTP GET URL中的參數。在其他應用程序中，也常常需要把二進制數據編碼為適合放在URL（包括隱藏表單域）中的形式。此時，採用Base編碼具有不可讀性，即所編碼的數據不會被人用肉眼所直接看到。
第二種. MD
MD即Message-Digest Algorithm （信息-摘要演算法），用於確保信息傳輸完整一致。是計算機廣泛使用的雜湊演算法之一（又譯摘要演算法、哈希演算法），主流編程語言普遍已有MD實現。將數據（如漢字）運算為另一固定長度值，是雜湊演算法的基礎原理，MD的前身有MD、MD和MD。
MD演算法具有以下特點：
壓縮性：任意長度的數據，算出的MD值長度都是固定的。
容易計算：從原數據計算出MD值很容易。
抗修改性：對原數據進行任何改動，哪怕只修改個位元組，所得到的MD值都有很大區別。
弱抗碰撞：已知原數據和其MD值，想找到一個具有相同MD值的數據（即偽造數據）是非常困難的。
強抗碰撞：想找到兩個不同的數據，使它們具有相同的MD值，是非常困難的。
MD的作用是讓大容量信息在用數字簽名軟體簽署私人密鑰前被」壓縮」成一種保密的格式（就是把一個任意長度的位元組串變換成一定長的十六進制數字串）。除了MD以外，其中比較有名的還有sha-、RIPEMD以及Haval等。
第三種.SHA
安全哈希演算法（Secure Hash Algorithm）主要適用於數字簽名標准（Digital Signature Standard DSS）裡面定義的數字簽名演算法（Digital Signature Algorithm DSA）。對於長度小於^位的消息，SHA會產生一個位的消息摘要。該演算法經過加密專家多年來的發展和改進已日益完善，並被廣泛使用。該演算法的思想是接收一段明文，然後以一種不可逆的方式將它轉換成一段（通常更小）密文，也可以簡單的理解為取一串輸入碼（稱為預映射或信息），並把它們轉化為長度較短、位數固定的輸出序列即散列值（也稱為信息摘要或信息認證代碼）的過程。散列函數值可以說是對明文的一種「指紋」或是「摘要」所以對散列值的數字簽名就可以視為對此明文的數字簽名。
SHA-與MD的比較
因為二者均由MD導出，SHA-和MD彼此很相似。相應的，他們的強度和其他特性也是相似，但還有以下幾點不同：
對強行攻擊的安全性：最顯著和最重要的區別是SHA-摘要比MD摘要長 位。使用強行技術，產生任何一個報文使其摘要等於給定報摘要的難度對MD是^數量級的操作，而對SHA-則是^數量級的操作。這樣，SHA-對強行攻擊有更大的強度。
對密碼分析的安全性：由於MD的設計，易受密碼分析的攻擊，SHA-顯得不易受這樣的攻擊。
速度：在相同的硬體上，SHA-的運行速度比MD慢。
第四種.HMAC
HMAC(Hash Message Authentication Code，散列消息鑒別碼，基於密鑰的Hash演算法的認證協議。消息鑒別碼實現鑒別的原理是，用公開函數和密鑰產生一個固定長度的值作為認證標識，用這個標識鑒別消息的完整性。使用一個密鑰生成一個固定大小的小數據塊，即MAC，並將其加入到消息中，然後傳輸。接收方利用與發送方共享的密鑰進行鑒別認證等。
③ java項目如何加密
Java基本的單向加密演算法：
1.BASE64 嚴格地說，屬於編碼格式，而非加密演算法
2.MD5(Message Digest algorithm 5，信息摘要演算法)
3.SHA(Secure Hash Algorithm，安全散列演算法)
4.HMAC(Hash Message Authentication Code，散列消息鑒別碼)
按 照RFC2045的定義，Base64被定義為：Base64內容傳送編碼被設計用來把任意序列的8位位元組描述為一種不易被人直接識別的形式。（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）
常見於郵件、http加密，截取http信息，你就會發現登錄操作的用戶名、密碼欄位通過BASE64加密的。
主要就是BASE64Encoder、BASE64Decoder兩個類，我們只需要知道使用對應的方法即可。另，BASE加密後產生的位元組位數是8的倍數，如果不夠位數以=符號填充。
MD5
MD5 -- message-digest algorithm 5 （信息-摘要演算法）縮寫，廣泛用於加密和解密技術，常用於文件校驗。校驗？不管文件多大，經過MD5後都能生成唯一的MD5值。好比現在的ISO校驗，都 是MD5校驗。怎麼用？當然是把ISO經過MD5後產生MD5的值。一般下載linux-ISO的朋友都見過下載鏈接旁邊放著MD5的串。就是用來驗證文 件是否一致的。
HMAC
HMAC(Hash Message Authentication Code，散列消息鑒別碼，基於密鑰的Hash演算法的認證協議。消息鑒別碼實現鑒別的原理是，用公開函數和密鑰產生一個固定長度的值作為認證標識，用這個 標識鑒別消息的完整性。使用一個密鑰生成一個固定大小的小數據塊，即MAC，並將其加入到消息中，然後傳輸。接收方利用與發送方共享的密鑰進行鑒別認證 等。
④ 可變MD5加密(Java實現)
可變在這里含義很簡單 就是最終的加密結果是可變的 而非必需按標准MD 加密實現 Java類庫security中的MessageDigest類就提供了MD 加密的支持 實現起來非常方便 為了實現更多效果 我們可以如下設計MD 工具類
Java代碼
package ** ** util;
import java security MessageDigest;
/**
* 標准MD 加密方法 使用java類庫的security包的MessageDigest類處理
* @author Sarin
*/
public class MD {
/**
* 獲得MD 加密密碼的方法
*/
public static String getMD ofStr(String origString) {
String origMD = null;
try {
MessageDigest md = MessageDigest getInstance( MD );
byte[] result = md digest(origString getBytes());
origMD = byteArray HexStr(result);
} catch (Exception e) {
e printStackTrace();
}
return origMD ;
}
/**
* 處理位元組數組得到MD 密碼的方法
*/
private static String byteArray HexStr(byte[] bs) {
StringBuffer *** = new StringBuffer();
for (byte b : bs) {
*** append(byte HexStr(b));
}
return *** toString();
}
/**
* 位元組標准移位轉十六進制方法
*/
private static String byte HexStr(byte b) {
String hexStr = null;
int n = b;
if (n < ) {
//若需要自定義加密 請修改這個移位演算法即可
n = b & x F + ;
}
hexStr = Integer toHexString(n / ) + Integer toHexString(n % );
return hexStr toUpperCase();
}
/**
* 提供一個MD 多次加密方法
*/
public static String getMD ofStr(String origString int times) {
String md = getMD ofStr(origString);
for (int i = ; i < times ; i++) {
md = getMD ofStr(md );
}
return getMD ofStr(md );
}
/**
* 密碼驗證方法
*/
public static boolean verifyPassword(String inputStr String MD Code) {
return getMD ofStr(inputStr) equals(MD Code);
}
/**
* 重載一個多次加密時的密碼驗證方法
*/
public static boolean verifyPassword(String inputStr String MD Code int times) {
return getMD ofStr(inputStr times) equals(MD Code);
}
/**
* 提供一個測試的主函數
*/
public static void main(String[] args) {
System out println( : + getMD ofStr( ));
System out println( : + getMD ofStr( ));
System out println( sarin: + getMD ofStr( sarin ));
System out println( : + getMD ofStr( ));
}
}
可以看出實現的過程非常簡單 因為由java類庫提供了處理支持 但是要清楚的是這種方式產生的密碼不是標準的MD 碼 它需要進行移位處理才能得到標准MD 碼 這個程序的關鍵之處也在這了 怎麼可變？調整移位演算法不就可變了么！不進行移位 也能夠得到 位的密碼 這就不是標准加密了 只要加密和驗證過程使用相同的演算法就可以了
MD 加密還是很安全的 像CMD 那些窮舉破解的只是針對標准MD 加密的結果進行的 如果自定義移位演算法後 它還有效么？可以說是無解的了 所以MD 非常安全可靠
為了更可變 還提供了多次加密的方法 可以在MD 基礎之上繼續MD 就是對 位的第一次加密結果再MD 恩 這樣去破解？沒有任何意義
這樣在MIS系統中使用 安全可靠 歡迎交流 希望對使用者有用
我們最後看看由MD 加密演算法實現的類 那是非常龐大的
Java代碼
import java lang reflect *;
/**
* **********************************************
* md 類實現了RSA Data Security Inc 在提交給IETF
* 的RFC 中的MD message digest 演算法
* ***********************************************
*/
public class MD {
/* 下面這些S S 實際上是一個 * 的矩陣 在原始的C實現中是用#define 實現的
這里把它們實現成為static final是表示了只讀 切能在同一個進程空間內的多個
Instance間共享*/
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final int S = ;
static final byte[] PADDING = {
};
/* 下面的三個成員是MD 計算過程中用到的 個核心數據 在原始的C實現中
被定義到MD _CTX結構中
*/
private long[] state = new long[ ]; // state (ABCD)
private long[] count = new long[ ]; // number of bits molo ^ (l *** first)
private byte[] buffer = new byte[ ]; // input buffer
/* digestHexStr是MD 的唯一一個公共成員 是最新一次計算結果的
進制ASCII表示
*/
public String digestHexStr;
/* digest 是最新一次計算結果的 進制內部表示 表示 bit的MD 值
*/
private byte[] digest = new byte[ ];
/*
getMD ofStr是類MD 最主要的公共方法 入口參數是你想要進行MD 變換的字元串
返回的是變換完的結果 這個結果是從公共成員digestHexStr取得的．
*/
public String getMD ofStr(String inbuf) {
md Init();
md Update(inbuf getBytes() inbuf length());
md Final();
digestHexStr = ;
for (int i = ; i < ; i++) {
digestHexStr += byteHEX(digest[i]);
}
return digestHexStr;
}
// 這是MD 這個類的標准構造函數 JavaBean要求有一個public的並且沒有參數的構造函數
public MD () {
md Init();
return;
}
/* md Init是一個初始化函數 初始化核心變數 裝入標準的幻數 */
private void md Init() {
count[ ] = L;
count[ ] = L;
///* Load magic initialization constants
state[ ] = x L;
state[ ] = xefcdab L;
state[ ] = x badcfeL;
state[ ] = x L;
return;
}
/* F G H I 是 個基本的MD 函數 在原始的MD 的C實現中 由於它們是
簡單的位運算 可能出於效率的考慮把它們實現成了宏 在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 rounds and
Rotation is separate from addition to prevent reputation
*/
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 = ((int) a << s) | ((int) a >>> ( s));
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;
a = ((int) a << s) | ((int) a >>> ( s));
a += b;
return a;
}
private long HH(long a long b long c long d long x long s long ac) {
a += H(b c d) + x + ac;
a = ((int) a << s) | ((int) a >>> ( s));
a += b;
return a;
}
private long II(long a long b long c long d long x long s long ac) {
a += I(b c d) + x + ac;
a = ((int) a << s) | ((int) a >>> ( s));
a += b;
return a;
}
/*
md Update是MD 的主計算過程 inbuf是要變換的位元組串 inputlen是長度 這個
函數由getMD ofStr調用 調用之前需要調用md init 因此把它設計成private的
*/
private void md Update(byte[] inbuf int inputLen) {
int i index partLen;
byte[] block = new byte[ ];
index = (int) (count[ ] >>> ) & x F;
// /* Update number of bits */
if ((count[ ] += (inputLen << )) < (inputLen << ))
count[ ]++;
count[ ] += (inputLen >>> );
partLen = index;
// Transform as many times as possible
if (inputLen >= partLen) {
md Memcpy(buffer inbuf index partLen);
md Transform(buffer);
for (i = partLen; i + < inputLen; i += ) {
md Memcpy(block inbuf i );
md Transform(block);
}
index = ;
} else
i = ;
///* Buffer remaining input */
md Memcpy(buffer inbuf index i inputLen i);
}
/*
md Final整理和填寫輸出結果
*/
private void md Final() {
byte[] bits = new byte[ ];
int index padLen;
///* Save number of bits */
Encode(bits count );
///* Pad out to mod
index = (int) (count[ ] >>> ) & x f;
padLen = (index < ) ? ( index) : ( index);
md Update(PADDING padLen);
///* Append length (before padding) */
md Update(bits );
///* Store state in digest */
Encode(digest state );
}
/* md Memcpy是一個內部使用的byte數組的塊拷貝函數 從input的inpos開始把len長度的
位元組拷貝到output的outpos位置開始
*/
private void md Memcpy(byte[] output byte[] input int outpos int inpos int len) {
int i;
for (i = ; i < len; i++)
output[outpos + i] = input[inpos + i];
}
/*
md Transform是MD 核心變換程序 有md Update調用 block是分塊的原始位元組
*/
private void md Transform(byte block[]) {
long a = state[ ] b = state[ ] c = state[ ] d = state[ ];
long[] x = new long[ ];
Decode(x block );
/* Round */
a = FF(a b c d x[ ] S xd aa L); /* */
d = FF(d a b c x[ ] S xe c b L); /* */
c = FF(c d a b x[ ] S x dbL); /* */
b = FF(b c d a x[ ] S xc bdceeeL); /* */
a = FF(a b c d x[ ] S xf c fafL); /* */
d = FF(d a b c x[ ] S x c aL); /* */
c = FF(c d a b x[ ] S xa L); /* */
b = FF(b c d a x[ ] S xfd L); /* */
a = FF(a b c d x[ ] S x d L); /* */
d = FF(d a b c x[ ] S x b f afL); /* */
c = FF(c d a b x[ ] S xffff bb L); /* */
b = FF(b c d a x[ ] S x cd beL); /* */
a = FF(a b c d x[ ] S x b L); /* */
d = FF(d a b c x[ ] S xfd L); /* */
c = FF(c d a b x[ ] S xa eL); /* */
b = FF(b c d a x[ ] S x b L); /* */
/* Round */
a = GG(a b c d x[ ] S xf e L); /* */
d = GG(d a b c x[ ] S xc b L); /* */
c = GG(c d a b x[ ] S x e a L); /* */
b = GG(b c d a x[ ] S xe b c aaL); /* */
a = GG(a b c d x[ ] S xd f dL); /* */
d = GG(d a b c x[ ] S x L); /* */
c = GG(c d a b x[ ] S xd a e L); /* */
b = GG(b c d a x[ ] S xe d fbc L); /* */
a = GG(a b c d x[ ] S x e cde L); /* */
d = GG(d a b c x[ ] S xc d L); /* */
c = GG(c d a b x[ ] S xf d d L); /* */
b = GG(b c d a x[ ] S x a edL); /* */
a = GG(a b c d x[ ] S xa e e L); /* */
d = GG(d a b c x[ ] S xfcefa f L); /* */
c = GG(c d a b x[ ] S x f d L); /* */
b = GG(b c d a x[ ] S x d a c aL); /* */
/* Round */
a = HH(a b c d x[ ] S xfffa L); /* */
d = HH(d a b c x[ ] S x f L); /* */
c = HH(c d a b x[ ] S x d d L); /* */
b = HH(b c d a x[ ] S xfde cL); /* */
a = HH(a b c d x[ ] S xa beea L); /* */
d = HH(d a b c x[ ] S x bdecfa L); /* */
c = HH(c d a b x[ ] S xf bb b L); /* */
b = HH(b c d a x[ ] S xbebfbc L); /* */
a = HH(a b c d x[ ] S x b ec L); /* */
d = HH(d a b c x[ ] S xeaa faL); /* */
c = HH(c d a b x[ ] S xd ef L); /* */
b = HH(b c d a x[ ] S x d L); /* */
a = HH(a b c d x[ ] S xd d d L); /* */
d = HH(d a b c x[ ] S xe db e L); /* */
c = HH(c d a b x[ ] S x fa cf L); /* */
b = HH(b c d a x[ ] S xc ac L); /* */
/* Round */
a = II(a b c d x[ ] S xf L); /* */
d = II(d a b c x[ ] S x aff L); /* */
c = II(c d a b x[ ] S xab a L); /* */
b = II(b c d a x[ ] S xfc a L); /* */
a = II(a b c d x[ ] S x b c L); /* */
d = II(d a b c x[ ] S x f ccc L); /* */
c = II(c d a b x[ ] S xffeff dL); /* */
b = II(b c d a x[ ] S x dd L); /* */
a = II(a b c d x[ ] S x fa e fL); /* */
d = II(d a b c x[ ] S xfe ce e L); /* */
c = II(c d a b x[ ] S xa L); /* */
b = II(b c d a x[ ] S x e a L); /* */
a = II(a b c d x[ ] S xf e L); /* */
d = II(d a b c x[ ] S xbd af L); /* */
c = II(c d a b x[ ] S x ad d bbL); /* */
b = II(b c d a x[ ] S xeb d L); /* */
state[ ] += a;
state[ ] += b;
state[ ] += c;
state[ ] += d;
}
/*Encode把long數組按順序拆成byte數組 因為java的long類型是 bit的
只拆低 bit 以適應原始C實現的用途
*/
private void Encode(byte[] output long[] input int len) {
int i j;
for (i = j = ; j < len; i++ j += ) {
output[j] = (byte) (input[i] & xffL);
output[j + ] = (byte) ((input[i] >>> ) & xffL);
output[j + ] = (byte) ((input[i] >>> ) & xffL);
output[j + ] = (byte) ((input[i] >>> ) & xffL);
}
}
/*Decode把byte數組按順序合成成long數組 因為java的long類型是 bit的
只合成低 bit 高 bit清零 以適應原始C實現的用途
*/
private void Decode(long[] output byte[] input int len) {
int i j;
for (i = j = ; j < len; i++ j += )
output[i] = b iu(input[j]) | (b iu(input[j + ]) << ) | (b iu(input[j + ]) << )
| (b iu(input[j + ]) << );
return;
}
/*
b iu是我寫的一個把byte按照不考慮正負號的原則的＂升位＂程序 因為java沒有unsigned運算
*/
public static long b iu(byte b) {
return b < ? b & x F + : b;
}
/*byteHEX() 用來把一個byte類型的數轉換成十六進制的ASCII表示
因為java中的byte的toString無法實現這一點 我們又沒有C語言中的
sprintf(outbuf % X ib)
*/
public static String byteHEX(byte ib) {
char[] Digit = { A B C D E F };
char[] ob = new char[ ];
ob[ ] = Digit[(ib >>> ) & X F];
ob[ ] = Digit[ib & X F];
String s = new String(ob);
return s;
}
public static void main(String args[]) {
MD m = new MD ();
if (Array getLength(args) == ) { //如果沒有參數 執行標準的Test Suite
System out println( MD Test suite: );
System out println( MD ( ): + m getMD ofStr( ));
System out println( MD ( a ): + m getMD ofStr( a ));
System out println( MD ( abc ): + m getMD ofStr( abc ));
System out println( MD ( ): + m getMD ofStr( ));
System out println( MD ( ): + m getMD ofStr( ));
System out println( MD ( message digest ): + m getMD ofStr( message digest ));
System out println( MD ( abcdefghijklmnopqrstuvwxyz ): + m getMD ofStr( abcdefghijklmnopqrstuvwxyz ));
System out println( MD ( ):
+ m getMD ofStr( ));
} else
System out println( MD ( + args[ ] + )= + m getMD ofStr(args[ ]));
}
lishixin/Article/program/Java/hx/201311/26604
⑤ java中使用MD5加密演算法進行加密
在各種應用系統的開發中 經常需要存儲用戶信息 很多地方都要存儲用戶密碼 而將用戶密碼直接存儲亮衫唯在伺服器上顯然是不安全的 本文簡要介紹工作中常用的 MD 加密演算法 希望能拋磚引玉
（一）消息摘要簡介
一個消息摘要就是一個數據塊的數字指紋 即對一個任意敬培長度的一個數據塊進行計算 產生一個唯一指印（對於SHA 是產生一個 位元組的二進制數組） 消息摘要是一種與消息認證碼結合使用以確保消息完整性的技術 主要使用單向散列函數演算法 可用於檢驗消息的完整性 和通過散列密碼直接以文本形式保存等 目前廣泛使用的演算法有MD MD SHA
消息摘要有兩個基本屬性
兩個不同的報文難以生成相同的摘要難以對指定的摘要生成一個報文 而可以由該報文反推算出該指定的摘要代表 美國國家標准技術研究所的SHA 和麻省理工學院Ronald Rivest提出的MD
（二）對字元串進行加密
/***//**利用MD 進行加密*@paramstr待加密的字元串*@return加密後的字元串*塌仔@沒有這種產生消息摘要的演算法*@*/publicStringEncoderByMd (Stringstr) UnsupportedEncodingException {//確定計算方法MessageDigestmd =MessageDigest getInstance( MD );BASE Encoderbase en=newBASE Encoder();//加密後的字元串Stringnewstr=base en encode(md digest(str getBytes( utf )));returnnewstr;}調用函數 String str=
System out println（EncoderByMd （str））
輸出 eB eJF ptWaXm bijSPyxw==
（三）驗證密碼是否正確
/***//**判斷用戶密碼是否正確*@paramnewpasswd用戶輸入的密碼*@paramoldpasswd資料庫中存儲的密碼－－用戶密碼的摘要*@return*@*@*/publicbooleancheckpassword(Stringnewpasswd Stringoldpasswd) UnsupportedEncodingException {if(EncoderByMd (newpasswd) equals(oldpasswd))returntrue;elsereturnfalse;} lishixin/Article/program/Java/hx/201311/26374
⑥ java rsa私鑰加密
java rsa私鑰加密是什麼？讓我們一起來了解一下吧！
java rsa私鑰加密是一種加密演算法。私鑰加密演算法是用私鑰來進行加密與解密信息。私鑰加密也被稱作對稱加密，原因是加密與解密使用的秘鑰是同一個。
RSA加密需要注意的事項如下：
1. 首先產生公鑰與私鑰
2. 設計加密與解密的演算法
3. 私鑰加密的數據信息只能由公鑰可以解密
4. 公鑰加密的數據信息只能由私鑰可以解密
實戰演練，具體步驟如下： public class RsaCryptTools { private static final String CHARSET = "utf-8"; private static final Base64.Decoder decoder64 = Base64.getDecoder(); private static final Base64.Encoder encoder64 = Base64.getEncoder(); /** * 生成公私鑰 * @param keySize * @return * @throws NoSuchAlgorithmException */ public static SecretKey generateSecretKey(int keySize) throws NoSuchAlgorithmException { //生成密鑰對 KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(keySize, new SecureRandom()); KeyPair pair = keyGen.generateKeyPair(); PrivateKey privateKey = pair.getPrivate(); PublicKey publicKey = pair.getPublic(); //這里可以將密鑰對保存到本地 return new SecretKey(encoder64.encodeToString(publicKey.getEncoded()), encoder64.encodeToString(privateKey.getEncoded())); } /** * 私鑰加密 * @param data * @param privateInfoStr * @return * @throws IOException * @throws InvalidCipherTextException */ public static String encryptData(String data, String privateInfoStr) throws IOException, InvalidKeySpecException, NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, BadPaddingException, IllegalBlockSizeException { Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); cipher.init(Cipher.ENCRYPT_MODE, getPrivateKey(privateInfoStr)); return encoder64.encodeToString(cipher.doFinal(data.getBytes(CHARSET))); } /** * 公鑰解密 * @param data * @param publicInfoStr * @return */ public static String decryptData(String data, String publicInfoStr) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException { byte[] encryptDataBytes=decoder64.decode(data.getBytes(CHARSET)); //解密 Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); cipher.init(Cipher.DECRYPT_MODE, getPublicKey(publicInfoStr)); return new String(cipher.doFinal(encryptDataBytes), CHARSET); } private static PublicKey getPublicKey(String base64PublicKey) throws NoSuchAlgorithmException, InvalidKeySpecException { X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(base64PublicKey.getBytes())); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); return keyFactory.generatePublic(keySpec); } private static PrivateKey getPrivateKey(String base64PrivateKey) throws NoSuchAlgorithmException, InvalidKeySpecException { PrivateKey privateKey = null; PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(base64PrivateKey.getBytes())); KeyFactory keyFactory = null; keyFactory = KeyFactory.getInstance("RSA"); privateKey = keyFactory.generatePrivate(keySpec); return privateKey; } /** * 密鑰實體 * @author hank * @since 2020/2/28 0028 下午 16:27 */ public static class SecretKey { /** * 公鑰 */ private String publicKey; /** * 私鑰 */ private String privateKey; public SecretKey(String publicKey, String privateKey) { this.publicKey = publicKey; this.privateKey = privateKey; } public String getPublicKey() { return publicKey; } public void setPublicKey(String publicKey) { this.publicKey = publicKey; } public String getPrivateKey() { return privateKey; } public void setPrivateKey(String privateKey) { this.privateKey = privateKey; } @Override public String toString() { return "SecretKey{" + "publicKey='" + publicKey + '\'' + ", privateKey='" + privateKey + '\'' + '}'; } } private static void writeToFile(String path, byte[] key) throws IOException { File f = new File(path); f.getParentFile().mkdirs(); try(FileOutputStream fos = new FileOutputStream(f)) { fos.write(key); fos.flush(); } } public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, IOException, BadPaddingException, IllegalBlockSizeException, InvalidKeyException, InvalidKeySpecException { SecretKey secretKey = generateSecretKey(2048); System.out.println(secretKey); String enStr = encryptData("你好測試測試", secretKey.getPrivateKey()); System.out.println(enStr); String deStr = decryptData(enStr, secretKey.getPublicKey()); System.out.println(deStr); enStr = encryptData("你好測試測試hello", secretKey.getPrivateKey()); System.out.println(enStr); deStr = decryptData(enStr, secretKey.getPublicKey()); System.out.println(deStr); } }
⑦ java加密的幾種方式
朋友你好，很高興為你作答。
首先，Java加密能夠應對的風險包括以下幾個：
1、核心技術竊取
2、核心業務破解
3、通信模塊破解
4、API介面暴露
本人正在使用幾維安全Java加密方式，很不錯，向你推薦，希望能夠幫助到你。
幾維安全Java2C針對DEX文件進行加密保護，將DEX文件中標記的Java代碼翻譯為C代碼，編譯成加固後的SO文件。默認情況只加密activity中的onCreate函數，如果開發者想加密其它類和方法，只需對相關類或函數添加標記代碼，在APK加密時會自動對標記的代碼進行加密處理。
與傳統的APP加固方案相比，不涉及到自定義修改DEX文件的載入方式，所以其兼容性非常好；其次Java函數被完全轉化為C函數，直接在Native層執行，不存在Java層解密執行的步驟，其性能和執行效率更優。
如果操作上有不明白的地方，可以聯系技術支持人員幫你完成Java加密。
希望以上解答能夠幫助到你。