java移位加密
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class md5 {
public String str;
public void md5s(String plainText) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(plainText.getBytes());
byte b[] = md.digest();
int i;
StringBuffer buf = new StringBuffer("");
for (int offset = 0; offset < b.length; offset++) {
i = b[offset];
if (i < 0)
i += 256;
if (i < 16)
buf.append("0");
buf.append(Integer.toHexString(i));
}
str = buf.toString();
System.out.println("result: " + buf.toString());// 32位的加密
System.out.println("result: " + buf.toString().substring(8, 24));// 16位的加密
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String agrs[]) {
md5 md51 = new md5();
md51.md5s("4");//加密4
}
}
『貳』 用java實現des加密和解密
一個用DES來加密、解密的類
http://www.javanb.com/java/1/17816.html
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
/**
* 字元串工具集合
* @author Liudong
*/
public class StringUtils {
private static final String PASSWORD_CRYPT_KEY = "__jDlog_";
private final static String DES = "DES";
/**
* 加密
* @param src 數據源
* @param key 密鑰，長度必須是8的倍數
* @return 返回加密後的數據
* @throws Exception
*/
public static byte[] encrypt(byte[] src, byte[] key)throws Exception {
//DES演算法要求有一個可信任的隨機數源
SecureRandom sr = new SecureRandom();
// 從原始密匙數據創建DESKeySpec對象
DESKeySpec dks = new DESKeySpec(key);
// 創建一個密匙工廠，然後用它把DESKeySpec轉換成
// 一個SecretKey對象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey securekey = keyFactory.generateSecret(dks);
// Cipher對象實際完成加密操作
Cipher cipher = Cipher.getInstance(DES);
// 用密匙初始化Cipher對象
cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
// 現在，獲取數據並加密
// 正式執行加密操作
return cipher.doFinal(src);
}
/**
* 解密
* @param src 數據源
* @param key 密鑰，長度必須是8的倍數
* @return 返回解密後的原始數據
* @throws Exception
*/
public static byte[] decrypt(byte[] src, byte[] key)throws Exception {
// DES演算法要求有一個可信任的隨機數源
SecureRandom sr = new SecureRandom();
// 從原始密匙數據創建一個DESKeySpec對象
DESKeySpec dks = new DESKeySpec(key);
// 創建一個密匙工廠，然後用它把DESKeySpec對象轉換成
// 一個SecretKey對象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey securekey = keyFactory.generateSecret(dks);
// Cipher對象實際完成解密操作
Cipher cipher = Cipher.getInstance(DES);
// 用密匙初始化Cipher對象
cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
// 現在，獲取數據並解密
// 正式執行解密操作
return cipher.doFinal(src);
}
/**
* 密碼解密
* @param data
* @return
* @throws Exception
*/
public final static String decrypt(String data){
try {
return new String(decrypt(hex2byte(data.getBytes()),
PASSWORD_CRYPT_KEY.getBytes()));
}catch(Exception e) {
}
return null;
}
/**
* 密碼加密
* @param password
* @return
* @throws Exception
*/
public final static String encrypt(String password){
try {
return byte2hex(encrypt(password.getBytes(),PASSWORD_CRYPT_KEY.getBytes())); }catch(Exception e) {
}
return null;
}
比較長, 轉了一部分.
『叄』 JAVA和.NET使用DES對稱加密的區別
如果我說沒有區別你會信嗎？
但答案還真是這樣，兩者沒有任何區別的，只不過實現的語言代碼不同而已。
那麼java與dot net之間的DES是否可以通用？答案也是完全通用。無論是Java的DES加密還是dot net的DES回密，均可以使用另一種語言且不限於Java或dot net解密。夠明白嗎？
DES其實只是一個演算法，加密與解密我們都知道演算法與密碼是分離的。演算法是公開的，都可以用，而密碼是獨立於演算法的。所以DES在不同的語言中實現的演算法根本就是一樣的——也正是因為如此不管何種語言都是通用的（除非偽DES，要知道DES演算法網上本身能搜到而且是一個標准，最先是由美國安全部門公開的）
再說一下，為什麼有人「通」用不起來的原因。DES其實有CBC之類的參數的，也就是針對加密塊選用的不同的加密手段。正是這個參數的原因，不同的語言中使用不同的參數做為默認值，所以使用默認的方式進行讓兩個串進行加解密肯定是不同的。DES使用一種模式（方法）加密，用另一種模式(方法）進行解密能得到正確的結果嗎？一些人不怪自己的學藝不精，反說是兩種語言的DES不通用（這也就是為什麼網路上會出現諸多說java和dot net的DES加密方法不通用的原因）。
即便是自己使用的DES加密的代碼也是通用的（前提你要遵守DES分開演算法），但不要「重復實現已經實現的東西（專業術語叫造輪子）」。
附：
DES.Model屬性取值
CBC 密碼塊鏈 (CBC) 模式引入了反饋。每個純文本塊在加密前，通過按位「異或」操作與前一個塊的密碼文本結合。這樣確保了即使純文本包含許多相同的塊，這些塊中的每一個也會加密為不同的密碼文本塊。在加密塊之前，初始化向量通過按位「異或」操作與第一個純文本塊結合。如果密碼文本塊中有一個位出錯，相應的純文本塊也將出錯。此外，後面的塊中與原出錯位的位置相同的位也將出錯。
ECB 電子密碼本 (ECB) 模式分別加密每個塊。這意味著任何純文本塊只要相同並且在同一消息中，或者在用相同的密鑰加密的不同消息中，都將被轉換成同樣的密碼文本塊。如果要加密的純文本包含大量重復的塊，則逐塊破解密碼文本是可行的。另外，隨時准備攻擊的對手可能在您沒有察覺的情況下替代和交換個別的塊。如果密碼文本塊中有一個位出錯，相應的整個純文本塊也將出錯。
OFB 輸出反饋 (OFB) 模式將少量遞增的純文本處理成密碼文本，而不是一次處理整個塊。此模式與 CFB 相似；這兩種模式的唯一差別是移位寄存器的填充方式不同。如果密碼文本中有一個位出錯，純文本中相應的位也將出錯。但是，如果密碼文本中有多餘或者缺少的位，則那個位之後的純文本都將出錯。
CFB 密碼反饋 (CFB) 模式將少量遞增的純文本處理成密碼文本，而不是一次處理整個塊。該模式使用在長度上為一個塊且被分為幾部分的移位寄存器。例如，如果塊大小為 8 個位元組，並且每次處理一個位元組，則移位寄存器被分為 8 個部分。如果密碼文本中有一個位出錯，則一個純文本位出錯，並且移位寄存器損壞。這將導致接下來若干次遞增的純文本出錯，直到出錯位從移位寄存器中移出為止。
CTS 密碼文本竊用 (CTS) 模式處理任何長度的純文本並產生長度與純文本長度匹配的密碼文本。除了最後兩個純文本塊外，對於所有其他塊，此模式與 CBC 模式的行為相同。
DES.Padding屬性的取值
None 不填充。
PKCS7 PKCS #7 填充字元串由一個位元組序列組成，每個位元組填充該位元組序列的長度。
Zeros 填充字元串由設置為零的位元組組成。
ANSIX923 ANSIX923 填充字元串由一個位元組序列組成，此位元組序列的最後一個位元組填充位元組序列的長度，其餘位元組均填充數字零。
ISO10126 ISO10126 填充字元串由一個位元組序列組成，此位元組序列的最後一個位元組填充位元組序列的長度，其餘位元組填充隨機數據。
當Mode不同時，解密的內密內容能與相同嗎？PaddingMode不同時，解密的內容的結尾部分能相同嗎（填充結果只涉及到最後的一個塊）.所以當不管何種語言使用相同的Mode及PaddingMode時，加解密的結果是相同的（當然不排除部分語言不實現全部的Mode和PaddingMode)但，基本的都是實現了的，所以基本上任何兩種語言之間的DES都可以實現相同的加解密結果！而java和dot net中的DES顯然指的是演算法，兩者是相同的，可以隨意使用（Java中dot net中的Mode默認值是不同的，一定要設置相同的Mode和PaddingMode才可以的，不要雙方都採用默認值，那樣真的通不起來）
『肆』 java代碼想加密怎麼處理
如果你說的是文本加密，有很多方法，自己也可以寫個字元變換程序
如果是代碼加密，沒用的，java就是開源。
你藏再厲害，編譯+反編譯，干凈的源碼就出來了
『伍』 如何使用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 加密方式有哪些
Java加密方式有多種，包括對稱加密、非對稱加密、散列加密等。
1. 對稱加密：
對稱加密是指加密和解密使用相同密鑰的加密方式。在Java中，常見的對稱加密演算法有AES、DES、3DES等。其中，AES演算法是DES的替代品，具有更高的安全性。這些演算法提供了不同級別的加密強度，適用於保護敏感信息。
2. 非對稱加密：
非對稱加密使用一對密鑰，一個用於加密，另一個用於解密。在Java中，常見的非對稱加密演算法有RSA、DSA、ECC等。RSA演算法是最常用的非對稱加密演算法之一，它利用公鑰進行加密，私鑰進行解密，適用於安全通信和數字簽名。
3. 散列加密（哈希加密）：
散列加密是一種將任意長度的輸入轉換為固定長度輸出的加密方式。在Java中，常見的散列加密演算法有MD5、SHA-1、SHA-256等。這些演算法主要用於生成數據的唯一標識符（哈希值），適用於密碼存儲、文件校驗等場景。需要注意的是，雖然MD5在某些情況下存在安全隱患，但SHA系列演算法提供了更高的安全性。
以上三種加密方式在Java中都有廣泛的應用，根據具體需求選擇合適的加密方式至關重要。同時，為了確保加密的安全性，還需要注意密鑰的管理和保護，避免密鑰泄露帶來的安全風險。
『柒』 求JAVA編寫的RSA加密演算法
代碼如下：main方法用於測試的，不是演算法本身。
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import javax.crypto.Cipher;
public class RSACrypto
{
private final static String RSA = "RSA";
public static PublicKey uk;
public static PrivateKey rk;
public static void generateKey() throws Exception
{
KeyPairGenerator gen = KeyPairGenerator.getInstance(RSA);
gen.initialize(512, new SecureRandom());
KeyPair keyPair = gen.generateKeyPair();
uk = keyPair.getPublic();
rk = keyPair.getPrivate();
}
private static byte[] encrypt(String text, PublicKey pubRSA) throws Exception
{
Cipher cipher = Cipher.getInstance(RSA);
cipher.init(Cipher.ENCRYPT_MODE, pubRSA);
return cipher.doFinal(text.getBytes());
}
public final static String encrypt(String text)
{
try {
return byte2hex(encrypt(text, uk));
}
catch(Exception e)
{
e.printStackTrace();
}
return null;
}
public final static String decrypt(String data)
{
try{
return new String(decrypt(hex2byte(data.getBytes())));
}
catch (Exception e)
{
e.printStackTrace();
}
return null;
}
private static byte[] decrypt(byte[] src) throws Exception
{
Cipher cipher = Cipher.getInstance(RSA);
cipher.init(Cipher.DECRYPT_MODE, rk);
return cipher.doFinal(src);
}
public static String byte2hex(byte[] b)
{
String hs = "";
String stmp = "";
for (int n = 0; n < b.length; n ++)
{
stmp = Integer.toHexString(b[n] & 0xFF);
if (stmp.length() == 1)
hs += ("0" + stmp);
else
hs += stmp;
}
return hs.toUpperCase();
}
public static byte[] hex2byte(byte[] b)
{
if ((b.length % 2) != 0)
throw new IllegalArgumentException("長度不是偶數");
byte[] b2 = new byte[b.length / 2];
for (int n = 0; n < b.length; n += 2)
{
String item = new String(b, n, 2);
b2[n/2] = (byte)Integer.parseInt(item, 16);
}
return b2;
}
//just for test
public static void main(String args[])
{
try
{
RSACrypto.generateKey();
String cipherText = RSACrypto.encrypt("asdfghjh");
System.out.println(cipherText);
String plainText = RSACrypto.decrypt(cipherText);
System.out.println(plainText);
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
『捌』 java 用^進行加密
import java.util.Scanner;
public class Test {
public static final int KEY = 8;
public static void main(String[] args) {
String str = "十點進攻";
StringBuffer str2 = new StringBuffer(); //存儲加密後的字元串
StringBuffer str3 = new StringBuffer(); //存儲解密後的字元串
//加密過程
for(int i=0;i<str.length();i++)
{
char c = (char)(str.charAt(i) ^ KEY);
str2.append(c);
}
//解密過程
for(int i=0;i<str2.length();i++)
{
char c = (char)(str2.charAt(i) ^ KEY);
str3.append(c);
}
System.out.println("原始 的字元串為:" + str);
System.out.println("加密後 的字元串為:" + str2);
System.out.println("解密後 的字元串為:" + str3);
}
}