des演算法代碼java

㈠ 如何使用java實現對字元串的DES加密和解密

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 des32加密解密演算法

packagecn.xinxi.des;

importjava.security.Key;
importjava.security.Security;

importjavax.crypto.Cipher;
importjavax.crypto.KeyGenerator;
importjavax.crypto.SecretKey;
importjavax.crypto.SecretKeyFactory;
importjavax.crypto.spec.DESKeySpec;
importorg.apache.commons.codec.binary.Hex;
importorg.bouncycastle.jce.provider.BouncyCastleProvider;


publicclassDES{
	privatestaticfinalStringstr="xinxi";
	publicstaticvoidmain(String[]args)throwsException{
		jdkDES();
		bcDES();
	}
	publicstaticvoidjdkDES()throwsException{
		//生成key
		//KeyGenerator，密鑰生成器
		KeyGeneratorkeyGenerator=KeyGenerator.getInstance("DES");
		keyGenerator.init(56);//指定keysize這里使用默認值56位
		//聲稱密鑰
		SecretKeysecreKey=keyGenerator.generateKey();
		byte[]bytesKey=secreKey.getEncoded();
		
		//key轉換(恢復密鑰)
//		SecretKeyconvertSecreKey=newSecretKeySpec(bytesKey,"DES");//與下面三行效果貌似差不多
		DESKeySpecdesKeySpec=newDESKeySpec(bytesKey);
		SecretKeyFactoryfactory=SecretKeyFactory.getInstance("DES");
//		System.out.println(keyGenerator.getProvider());
		KeyconvertSecreKey=factory.generateSecret(desKeySpec);
		
		//加密
		Ciphercipher=Cipher.getInstance("DES/ECB/PKCS5Padding");//加密演算法/工作方式/填充方式
		cipher.init(Cipher.ENCRYPT_MODE,convertSecreKey);//模式(此處是加密模式)、key
		byte[]result=cipher.doFinal(str.getBytes());//參數是要被加密的內容
		System.out.println("JDKDES加密結果："+Hex.encodeHexString(result));//轉成16進制
		
		//解密生成key和key轉換與加密一樣
		cipher.init(Cipher.DECRYPT_MODE,convertSecreKey);//模式(此處是解密模式)、key
		result=cipher.doFinal(result);
		System.out.println("JDKDES解密結果："+newString(result));
	}
	publicstaticvoidbcDES()throwsException{
		Security.addProvider(newBouncyCastleProvider());
		
		//生成key
		KeyGeneratorkeyGenerator=KeyGenerator.getInstance("DES","BC");
//		System.out.println(keyGenerator.getProvider());
		keyGenerator.init(56);//指定keysize這里使用默認值56位
		SecretKeysecreKey=keyGenerator.generateKey();
		byte[]bytesKey=secreKey.getEncoded();
		
		//key轉換
		DESKeySpecdesKeySpec=newDESKeySpec(bytesKey);
		SecretKeyFactoryfactory=SecretKeyFactory.getInstance("DES");
		KeyconvertSecreKey=factory.generateSecret(desKeySpec);
		
		//加密
		Ciphercipher=Cipher.getInstance("DES/ECB/PKCS5Padding");//加密演算法/工作方式/填充方式
		cipher.init(Cipher.ENCRYPT_MODE,convertSecreKey);//模式(此處是加密模式)、key
		byte[]result=cipher.doFinal(str.getBytes());//參數是要被加密的內容
		System.out.println("BCDES加密結果："+Hex.encodeHexString(result));//轉成16進制
		
		//解密生成key和key轉換與加密一樣
		cipher.init(Cipher.DECRYPT_MODE,convertSecreKey);//模式(此處是解密模式)、key
		result=cipher.doFinal(result);
		System.out.println("BCDES解密結果："+newString(result));
	}
}

是你想要的么？

㈢ DES加密演算法 java實現

c語言的源代碼，供參考：

http://hi..com/gaojinshan/blog/item/8b2710c4ece4b3ce39db49e9.html

㈣ 用java實現des演算法

package des;

import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;

public class FileDES{
private static final boolean enc=true; //加密
private static final boolean dec=false; //解密

private String srcFileName;
private String destFileName;
private String inKey;
private boolean actionType;
private File srcFile;
private File destFile;
private Des des;

private void analyzePath(){
String dirName;
int pos=srcFileName.lastIndexOf("/");
dirName=srcFileName.substring(0,pos);
File dir=new File(dirName);
if (!dir.exists()){
System.err.println(dirName+" is not exist");
System.exit(1);
}else if(!dir.isDirectory()){
System.err.println(dirName+" is not a directory");
System.exit(1);
}

pos=destFileName.lastIndexOf("/");
dirName=destFileName.substring(0,pos);
dir=new File(dirName);
if (!dir.exists()){
if(!dir.mkdirs()){
System.out.println ("can not creat directory:"+dirName);
System.exit(1);
}
}else if(!dir.isDirectory()){
System.err.println(dirName+" is not a directory");
System.exit(1);
}
}

private static int replenish(FileChannel channel,ByteBuffer buf) throws IOException{
long byteLeft=channel.size()-channel.position();
if(byteLeft==0L)
return -1;
buf.position(0);
buf.limit(buf.position()+(byteLeft<8 ? (int)byteLeft :8));
return channel.read(buf);
}

private void file_operate(boolean flag){
des=new Des(inKey);
FileOutputStream outputFile=null;
try {
outputFile=new FileOutputStream(srcFile,true);
}catch (java.io.FileNotFoundException e) {
e.printStackTrace(System.err);
}
FileChannel outChannel=outputFile.getChannel();

try{
if(outChannel.size()%2!=0){
ByteBuffer bufTemp=ByteBuffer.allocate(1);
bufTemp.put((byte)32);
bufTemp.flip();
outChannel.position(outChannel.size());
outChannel.write(bufTemp);
bufTemp.clear();
}
}catch(Exception ex){
ex.printStackTrace(System.err);
System.exit(1);
}
FileInputStream inFile=null;
try{
inFile=new FileInputStream(srcFile);
}catch(java.io.FileNotFoundException e){
e.printStackTrace(System.err);
//System.exit(1);
}
outputFile=null;
try {
outputFile=new FileOutputStream(destFile,true);
}catch (java.io.FileNotFoundException e) {
e.printStackTrace(System.err);
}

FileChannel inChannel=inFile.getChannel();
outChannel=outputFile.getChannel();

ByteBuffer inBuf=ByteBuffer.allocate(8);
ByteBuffer outBuf=ByteBuffer.allocate(8);

try{
String srcStr;
String destStr;
while(true){

if (replenish(inChannel,inBuf)==-1) break;
srcStr=((ByteBuffer)(inBuf.flip())).asCharBuffer().toString();
inBuf.clear();
if (flag)
destStr=des.enc(srcStr,srcStr.length());
else
destStr=des.dec(srcStr,srcStr.length());
outBuf.clear();
if (destStr.length()==4){
for (int i = 0; i<4; i++) {
outBuf.putChar(destStr.charAt(i));
}
outBuf.flip();
}else{
outBuf.position(0);
outBuf.limit(2*destStr.length());
for (int i = 0; i<destStr.length(); i++) {
outBuf.putChar(destStr.charAt(i));
}
outBuf.flip();
}

try {
outChannel.write(outBuf);
outBuf.clear();
}catch (java.io.IOException ex) {
ex.printStackTrace(System.err);
}
}
System.out.println (inChannel.size());
System.out.println (outChannel.size());
System.out.println ("EoF reached.");
inFile.close();
outputFile.close();
}catch(java.io.IOException e){
e.printStackTrace(System.err);
System.exit(1);
}
}

public FileDES(String srcFileName,String destFileName,String inKey,boolean actionType){
this.srcFileName=srcFileName;
this.destFileName=destFileName;
this.actionType=actionType;
analyzePath();
srcFile=new File(srcFileName);
destFile=new File(destFileName);
this.inKey=inKey;
if (actionType==enc)
file_operate(enc);
else
file_operate(dec);
}

public static void main(String[] args){
String file1=System.getProperty("user.dir")+"/111.doc";
String file2=System.getProperty("user.dir")+"/222.doc";
String file3=System.getProperty("user.dir")+"/333.doc";
String passWord="1234ABCD";
FileDES fileDes=new FileDES(file1,file2,passWord,true);
FileDES fileDes1=new FileDES(file2,file3,passWord,false);
}

㈤ java des加密，密鑰的長度是多少

3des演算法是指使用雙長度（16位元組）密鑰k=（kl||kr）將8位元組明文數據塊進行3次des加密/解密。如下所示：
y
=
des(kl)[des-1(kr)[des(kl[x])]]
解密方式為：
x
=
des-1
(kl)[des
(kr)[
des-1
(kl[y])]]
其中，des(kl[x])表示用密鑰k對數據x進行des加密，des-1
(kl[y])表示用密鑰k對數據y進行解密。
sessionkey的計算採用3des演算法，計算出單倍長度的密鑰。表示法為:sk
=
session(dk，data)
3des加密演算法為：
void
3des(byte
doublekeystr[16]，
byte
data[8]，
byte
out[8])
{
byte
buf1[8]，
buf2[8];
des
(&doublekeystr[0]，
data，
buf1);
udes(&doublekeystr[8]，
buf1，
buf2);
des
(&doublekeystr[0]，
buf2，
out);
}

㈥ java中的rsa\des演算法的方法

rsa加密解密演算法
1978年就出現了這種演算法，它是第一個既能用於數據加密
也能用於數字簽名的演算法。它易於理解和操作，也很流行。算
法的名字以發明者的名字命名：Ron Rivest, AdiShamir 和
Leonard Adleman。但RSA的安全性一直未能得到理論上的證明。

RSA的安全性依賴於大數分解。公鑰和私鑰都是兩個大素數
（ 大於 100個十進制位）的函數。據猜測，從一個密鑰和密文
推斷出明文的難度等同於分解兩個大素數的積。

密鑰對的產生:選擇兩個大素數，p 和q 。計算：
n = p * q
然後隨機選擇加密密鑰e，要求 e 和 ( p - 1 ) * ( q - 1 )
互質。最後，利用Euclid 演算法計算解密密鑰d, 滿足

e * d = 1 ( mod ( p - 1 ) * ( q - 1 ) )

其中n和d也要互質。數e和
n是公鑰，d是私鑰。兩個素數p和q不再需要，應該丟棄，不要讓任
何人知道。 加密信息 m（二進製表示）時，首先把m分成等長數據
塊 m1 ,m2,..., mi ，塊長s，其中 2^s <= n, s 盡可能的大。對
應的密文是：

ci = mi^e ( mod n ) ( a )

解密時作如下計算：

mi = ci^d ( mod n ) ( b )

RSA 可用於數字簽名，方案是用 ( a ) 式簽名， ( b )
式驗證。具體操作時考慮到安全性和 m信息量較大等因素，一般是先
作 HASH 運算。

RSA 的安全性。
RSA的安全性依賴於大數分解，但是否等同於大數分解一直未能得到理
論上的證明，因為沒有證明破解RSA就一定需要作大數分解。假設存在
一種無須分解大數的演算法，那它肯定可以修改成為大數分解演算法。目前，
RSA的一些變種演算法已被證明等價於大數分解。不管怎樣，分解n是最顯
然的攻擊方法。現在，人們已能分解140多個十進制位的大素數。因此，
模數n必須選大一些，因具體適用情況而定。

RSA的速度:
由於進行的都是大數計算，使得RSA最快的情況也比DES慢上100倍，無論
是軟體還是硬體實現。速度一直是RSA的缺陷。一般來說只用於少量數據
加密。

RSA的選擇密文攻擊:
RSA在選擇密文攻擊面前很脆弱。一般攻擊者是將某一信息作一下偽裝
(Blind)，讓擁有私鑰的實體簽署。然後，經過計算就可得到它所想要的信
息。實際上，攻擊利用的都是同一個弱點，即存在這樣一個事實：乘冪保
留了輸入的乘法結構：

( XM )^d = X^d *M^d mod n

前面已經提到，這個固有的問題來自於公鑰密碼系統的最有用的特徵
--每個人都能使用公鑰。但從演算法上無法解決這一問題，主要措施有
兩條：一條是採用好的公鑰協議，保證工作過程中實體不對其他實體
任意產生的信息解密，不對自己一無所知的信息簽名；另一條是決不
對陌生人送來的隨機文檔簽名，簽名時首先使用One-Way HashFunction
對文檔作HASH處理，或同時使用不同的簽名演算法。在中提到了幾種不
同類型的攻擊方法。

RSA的公共模數攻擊。
若系統中共有一個模數，只是不同的人擁有不同的e和d，系統將是危險
的。最普遍的情況是同一信息用不同的公鑰加密，這些公鑰共模而且互
質，那末該信息無需私鑰就可得到恢復。設P為信息明文，兩個加密密鑰
為e1和e2，公共模數是n，則：

C1 = P^e1 mod n

C2 = P^e2 mod n

密碼分析者知道n、e1、e2、C1和C2，就能得到P。

因為e1和e2互質，故用Euclidean演算法能找到r和s，滿足：

r * e1 + s * e2 = 1

假設r為負數，需再用Euclidean演算法計算C1^(-1)，則

( C1^(-1) )^(-r) * C2^s = P mod n

另外，還有其它幾種利用公共模數攻擊的方法。總之，如果知道給定模數
的一對e和d，一是有利於攻擊者分解模數，一是有利於攻擊者計算出其它
成對的e』和d』，而無需分解模數。解決辦法只有一個，那就是不要共享
模數n。

RSA的小指數攻擊。 有一種提高
RSA速度的建議是使公鑰e取較小的值，這樣會使加密變得易於實現，速度
有所提高。但這樣作是不安全的，對付辦法就是e和d都取較大的值。

RSA演算法是第一個能同時用於加密和數字簽名的演算法，也易於理解和操作。
RSA是被研究得最廣泛的公鑰演算法，從提出到現在已近二十年，經歷了各
種攻擊的考驗，逐漸為人們接受，普遍認為是目前最優秀的公鑰方案之一。
RSA的安全性依賴於大數的因子分解，但並沒有從理論上證明破譯RSA的難
度與大數分解難度等價。即RSA的重大缺陷是無法從理論上把握它的保密性
能如何，而且密碼學界多數人士傾向於因子分解不是NPC問題。

RSA的缺點主要有：
A)產生密鑰很麻煩，受到素數產生技術的限制，因而難以做到一次
一密。B)分組長度太大，為保證安全性，n 至少也要 600 bits
以上，使運算代價很高，尤其是速度較慢，較對稱密碼演算法慢幾個數量級；
且隨著大數分解技術的發展，這個長度還在增加，不利於數據格式的標准化。
目前，SET(Secure Electronic Transaction)協議中要求CA採用2048比特長
的密鑰，其他實體使用1024比特的密鑰。
參考資料：http://superpch.josun.com.cn/bbs/PrintPost.asp?ThreadID=465
CRC加解密演算法
http://www.bouncycastle.org/

㈦ Java中 DES加密演算法

package des;
import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import java.security.NoSuchAlgorithmException;
import sun.misc.*;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.spec.SecretKeySpec;
import java.security.*;
import javax.crypto.SecretKeyFactory;
import java.security.spec.*;
import javax.crypto.spec.DESedeKeySpec;
/**
解密
*/
class DES {
private static String Algorithm = "DESede";//加密演算法的名稱
private static Cipher c;//密碼器
private static byte[] cipherByte;
private static SecretKey deskey;//密鑰
private static String keyString = "";//獲得密鑰的參數
//對base64編碼的string解碼成byte數組
public byte[] deBase64(String parm) throws IOException {
BASE64Decoder dec=new BASE64Decoder();
byte[] dnParm = dec.decodeBuffer(parm);
System.out.println(dnParm.length);
System.out.println(dnParm);
return dnParm;
}
//把密鑰參數轉為byte數組
public byte[] dBase64(String parm) throws IOException {
BASE64Decoder dec=new BASE64Decoder();
byte[] dnParm = dec.decodeBuffer(parm);
return dnParm;
}
/**
* 對 Byte 數組進行解密
* @param buff 要解密的數據
* @return 返回加密後的 String
*/
public static String createDecryptor(byte[] buff) throws
NoSuchPaddingException, NoSuchAlgorithmException,
UnsupportedEncodingException {
try {
c.init(Cipher.DECRYPT_MODE, deskey);//初始化密碼器，用密鑰deskey,進入解密模式
cipherByte = c.doFinal(buff);
}
catch(java.security.InvalidKeyException ex){
ex.printStackTrace();
}
catch(javax.crypto.BadPaddingException ex){
ex.printStackTrace();
}
catch(javax.crypto.IllegalBlockSizeException ex){
ex.printStackTrace();
}
return (new String(cipherByte,"UTF-8"));
}
public void getKey(String key) throws IOException, InvalidKeyException,
InvalidKeySpecException {
byte[] dKey = dBase64(key);
try {
deskey=new javax.crypto.spec.SecretKeySpec(dKey,Algorithm);
c = Cipher.getInstance(Algorithm);
}
catch (NoSuchPaddingException ex) {
}
catch (NoSuchAlgorithmException ex) {
}
}

public static void main(String args[]) throws IOException,
NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeySpecException,
InvalidKeyException, IOException {
DES des = new DES();
des.getKey(keyString);//獲取密鑰
byte[] dBy = des.deBase64("t0/fDOZ5NaQ=");//獲取需要解密的字元串
String dStr = des.createDecryptor(dBy);
System.out.println("解密："+dStr);
}
}

㈧ 用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實現des演算法

分類: 電腦/網路 >> 程序設計 >> 其並運他編程語言
問題描述:

各位好，請求各位java學習者幫助釘解決這個問題。

我想用des演算法對我的名字進行加密

我也在網上下載了des演算法，包括FileDES,SubKey,Des各程序，

可能沒真正理解這些程序，所以我想調用都鍵讓不知道將這些東西

組合起來，有知道的請幫幫忙啊！

解析:

package des;

import java.io.*;

import java.nio.*;

import java.nio.channels.FileChannel;

public class FileDES{

private static final boolean enc=true; 加密

private static final boolean dec=false; 解密

private String srcFileName;

private String destFileName;

private String inKey;

private boolean actionType;

private File srcFile;

private File destFile;

private Des des;

private void *** yzePath(){

String dirName;

int pos=srcFileNamestIndexOf("/稿蔽局");

dirName=srcFileName.substring(0,pos);

File dir=new File(dirName);

if (!dir.exists()){

System.err.println(dirName+" is not exist");

System.exit(1);

}else if(!dir.isDirectory()){

System.err.println(dirName+" is not a directory");

System.exit(1);

}

pos=destFileNamestIndexOf("/");

dirName=destFileName.substring(0,pos);

dir=new File(dirName);

if (!dir.exists()){

if(!dir.mkdirs()){

System.out.println ("can not creat directory:"+dirName);

System.exit(1);

}

}else if(!dir.isDirectory()){

System.err.println(dirName+" is not a directory");

System.exit(1);

}

}

private static int replenish(FileChannel channel,ByteBuffer buf) throws IOException{

long byteLeft=channel.size()-channel.position();

if(byteLeft==0L)

return -1;

buf.position(0);

buf.limit(buf.position()+(byteLeft<8 ? (int)byteLeft :8));

return channel.read(buf);

}

private void file_operate(boolean flag){

des=new Des(inKey);

FileOutputStream outputFile=null;

try {

outputFile=new FileOutputStream(srcFile,true);

}catch (java.io.FileNotFoundException e) {

e.printStackTrace(System.err);

}

FileChannel outChannel=outputFile.getChannel();

try{

if(outChannel.size()%2!=0){

ByteBuffer bufTemp=ByteBuffer.allocate(1);

bufTemp.put((byte)32);

bufTemp.flip();

outChannel.position(outChannel.size());

outChannel.write(bufTemp);

bufTemp.clear();

}

}catch(Exception ex){

ex.printStackTrace(System.err);

System.exit(1);

}

FileInputStream inFile=null;

try{

inFile=new FileInputStream(srcFile);

}catch(java.io.FileNotFoundException e){

e.printStackTrace(System.err);

System.exit(1);

}

outputFile=null;

try {

outputFile=new FileOutputStream(destFile,true);

}catch (java.io.FileNotFoundException e) {

e.printStackTrace(System.err);

}

FileChannel inChannel=inFile.getChannel();

outChannel=outputFile.getChannel();

ByteBuffer inBuf=ByteBuffer.allocate(8);

ByteBuffer outBuf=ByteBuffer.allocate(8);

try{

String srcStr;

String destStr;

while(true){

if (replenish(inChannel,inBuf)==-1) break;

srcStr=((ByteBuffer)(inBuf.flip())).asCharBuffer().toString();

inBuf.clear();

if (flag)

destStr=des.enc(srcStr,srcStr.length());

else

destStr=des.dec(srcStr,srcStr.length());

outBuf.clear();

if (destStr.length()==4){

for (int i = 0; i<4; i++) {

outBuf.putChar(destStr.charAt(i));

}

outBuf.flip();

}else{

outBuf.position(0);

outBuf.limit(2*destStr.length());

for (int i = 0; i<destStr.length(); i++) {

outBuf.putChar(destStr.charAt(i));

}

outBuf.flip();

}

try {

outChannel.write(outBuf);

outBuf.clear();

}catch (java.io.IOException ex) {

ex.printStackTrace(System.err);

}

}

System.out.println (inChannel.size());

System.out.println (outChannel.size());

System.out.println ("EoF reached.");

inFile.close();

outputFile.close();

}catch(java.io.IOException e){

e.printStackTrace(System.err);

System.exit(1);

}

}

public FileDES(String srcFileName,String destFileName,String inKey,boolean actionType){

this.srcFileName=srcFileName;

this.destFileName=destFileName;

this.actionType=actionType;

*** yzePath();

srcFile=new File(srcFileName);

destFile=new File(destFileName);

this.inKey=inKey;

if (actionType==enc)

file_operate(enc);

else

file_operate(dec);

}

public static void main(String[] args){

String file1=System.getProperty("user.dir")+"/111.doc";

String file2=System.getProperty("user.dir")+"/222.doc";

String file3=System.getProperty("user.dir")+"/333.doc";

String passWord="1234ABCD";

FileDES fileDes=new FileDES(file1,file2,passWord,true);

FileDES fileDes1=new FileDES(file2,file3,passWord,false);

}

㈩ 鍩轟簬DES綆楁硶鐨凜BC婕旂ず紼嬪簭瀹炵幇錛坖ava錛

鍩轟簬DES綆楁硶鐨凜BC婕旂ず紼嬪簭瀹炵幇錛坖ava錛
package des;

import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;

public class FileDES{
private static final boolean enc=true; //鍔犲瘑
private static final boolean dec=false; //瑙ｅ瘑