欧美一区二区三区老妇人-欧美做爰猛烈大尺度电-99久久夜色精品国产亚洲a-亚洲福利视频一区二区

java實現dh算法代碼 des算法java代碼

簡述DH算法

DH組的本質是使用非對稱密鑰來加密對稱密鑰。 DH算法過程： 1、相互產生密鑰對 2、交換公鑰 3、用對方的公鑰和自己的私鑰運行DH算法——得到另外一個密鑰X

10余年的夏津網站建設經驗，針對設計、前端、開發(fā)、售后、文案、推廣等六對一服務，響應快，48小時及時工作處理。成都營銷網站建設的優(yōu)勢是能夠根據用戶設備顯示端的尺寸不同，自動調整夏津建站的顯示方式，使網站能夠適用不同顯示終端，在瀏覽器中調整網站的寬度，無論在任何一種瀏覽器上瀏覽網站，都能展現優(yōu)雅布局與設計，從而大程度地提升瀏覽體驗。創(chuàng)新互聯(lián)從事“夏津網站設計”,“夏津網站推廣”以來，每個客戶項目都認真落實執(zhí)行。

驗證DH密鑰交換算法

我自己寫了個DH秘鑰的demo代碼， 以前加密用過AES的加密，全套代碼寫下來太費時間又沒技術含量。

如果你需要AES的加密代碼可以留個郵箱給我。

public?class?Test1?{

public?static?final?int?P=30;//公開的大家都知道的

public?static?final?int?G=9;//公開的大家都知道的

public?static?void?main(String[]?args)?{

A?x?=?new?A();

int?one?=?x.getV();

//分割?A?代表A這邊的系統(tǒng)加密??one?代表是給別人的值

B?y?=?new?B();

int?two?=?y.getV();

//B?代表另外一邊加密?two?代表是給別人的值

System.out.println(x.getKey(two));

System.out.println(y.getKey(one));

}

}

class?A{

private?int?a;//自己的私有密值,不會告訴任何人

public?A()?{

?Random?r?=?new?Random(200);

a=r.nextInt();

}

public?int?getV(){

return?(Test1.G^a)%Test1.P;

}

public?int?getKey(int?v){

return?(v^a)%Test1.P;

}

}

class?B{

private?int?b;//自己的私有密值，不會告訴任何人

public?B()?{

Random?r?=?new?Random(200);

b=r.nextInt();

}

public?int?getV(){

return?(Test1.G^b)%Test1.P;

}

public?int?getKey(int?v){

return?(v^b)%Test1.P;

}

}

簡要介紹DH密鑰交換算法

姓名：朱睿琦

學號：15180288015

參考：

【嵌牛導讀】：隨著互聯(lián)網絡的高速發(fā)展，計算機運算能力的提升，對信息的保密也有了更近一步的要求——不僅信息要保密，密鑰也要保密。DH(Diffie-Hellman)算法就提供了使密鑰安全通過不安全網絡的方法。

【嵌牛鼻子】：DH算法，密鑰，網絡信息安全

【嵌牛提問】：DH算法是用來保護什么在網絡中的通信安全？DH密鑰交換的基本原理是什么？

【嵌牛正文】：(1)、算法描述

離散對數的概念：

原根 ：如果 a 是素數 p 的一個原根，那么數值：

a mod p ， a^ 2 mod p ，…， a^( p-1) mod p

是各不相同的整數，且以某種排列方式組成了從 1 到 p-1 的所有整數。

離散對數 ：如果對于一個整數 b 和素數 p 的一個原根 a ，可以找到一個唯一的指數 i ，使得：

b =（ a的i次方） mod p 其中 0 ≦ i ≦ p-1

那么指數 i 稱為 b 的以 a 為基數的模p的離散對數。

Diffie-Hellman算法的有效性依賴于計算離散對數的難度，其含義是：當已知大素數 p 和它的一個原根 a 后，對給定的 b ，要計算 i ，被認為是很困難的，而給定 i 計算 b 卻相對容易。

Diffie-Hellman算法：

假如用戶A和用戶B希望交換一個密鑰。

取素數 p 和整數 a ， a 是 p 的一個原根，公開 a 和p。

A選擇隨機數XA p ，并計算YA= a^ XA mod p。

B選擇隨機數XB p ，并計算YB= a^ XB mod p。

每一方都將X保密而將Y公開讓另一方得到。

A計算密鑰的方式是：K=(YB) ^XA mod p

B計算密鑰的方式是：K=(YA) ^XB mod p

證明：

(YB)^ XA mod p = ( a^ XB mod p )^ XA mod p

= ( a^ XB)^ XA mod p = ( a^ XA) ^XB mod p (-- 密鑰即為 a^(XA*XB) mod p )

=( a^ XA mod p )^ XB mod p = (YA) ^XB mod p

由于XA和XB是保密的，而第三方只有 p 、 a 、YB、YA可以利用，只有通過取離散對數來確定密鑰，但對于大的素數 p ，計算離散對數是十分困難的。

例子：

假如用戶Alice和用戶Bob希望交換一個密鑰。

取一個素數 p =97和97的一個原根 a =5。

Alice和Bob分別選擇秘密密鑰XA=36和XB=58，并計算各自的公開密鑰：

YA= a^ XA mod p =5^36 mod 97=50

YB= a^ XB mod p =5^58 mod 97=44

Alice和Bob交換了公開密鑰之后，計算共享密鑰如下：

Alice：K=(YB) ^XA mod p =44^36 mod 97=75

Bob：K=(YA) ^XB mod p =50^58 mod 97=75

(2)、安全性

當然，為了使這個例子變得安全，必須使用非常大的XA,?XB 以及 p ， 否則可以實驗所有的可能取值。(總共有最多97個這樣的值, 就算XA和XB很大也無濟于事)。

如果 p 是一個至少 300 位的質數，并且XA和XB至少有100位長， 那么即使使用全人類所有的計算資源和當今最好的算法也不可能從a, p 和a^(XA*XB) mod p 中計算出 XA*XB。

這個問題就是著名的離散對數問題。注意g則不需要很大, 并且在一般的實踐中通常是2或者5。

在最初的描述中，迪菲－赫爾曼密鑰交換本身并沒有提供通訊雙方的身份驗證服務，因此它很容易受到中間人攻擊。

一個中間人在信道的中央進行兩次迪菲－赫爾曼密鑰交換，一次和Alice另一次和Bob，就能夠成功的向Alice假裝自己是Bob，反之亦然。

而攻擊者可以解密（讀取和存儲）任何一個人的信息并重新加密信息，然后傳遞給另一個人。因此通常都需要一個能夠驗證通訊雙方身份的機制來防止這類攻擊。

有很多種安全身份驗證解決方案使用到了迪菲－赫爾曼密鑰交換。例如當Alice和Bob共有一個公鑰基礎設施時，他們可以將他們的返回密鑰進行簽名。

java問題

-------------參考下------------------

JAVA加密算法的實現用例

對象

參數 algorithm 如:"DSA"

public final void initSign(PrivateKey privateKey)

throws InvalidKeyException

用指定的私鑰初始化

參數:privateKey 所進行簽名時用的私鑰

public final void update(byte data)

throws SignatureException

public final void update(byte[] data)

throws SignatureException

public final void update(byte[] data, int off, int len)

throws SignatureException

添加要簽名的信息

public final byte[] sign()

throws SignatureException

返回簽名的數組,前提是initSign和update

public final void initVerify(PublicKey publicKey)

throws InvalidKeyException

用指定的公鑰初始化

參數:publicKey 驗證時用的公鑰

public final boolean verify(byte[] signature)

throws SignatureException

驗證簽名是否有效,前提是已經initVerify初始化

參數: signature 簽名數組

*/

import java.security.*;

import java.security.spec.*;

public class testdsa {

public static void main(String[] args) throws java.security.NoSuchAlgorithmException,java.lang.Exception {

testdsa my=new testdsa();

my.run();

}

public void run()

{

//數字簽名生成密鑰

//第一步生成密鑰對,如果已經生成過,本過程就可以跳過,對用戶來講myprikey.dat要保存在本地

//而mypubkey.dat給發(fā)布給其它用戶

if ((new java.io.File("myprikey.dat")).exists()==false) {

if (generatekey()==false) {

System.out.println("生成密鑰對敗");

return;

};

}

//第二步,此用戶

//從文件中讀入私鑰,對一個字符串進行簽名后保存在一個文件(myinfo.dat)中

//并且再把myinfo.dat發(fā)送出去

//為了方便數字簽名也放進了myifno.dat文件中,當然也可分別發(fā)送

try {

java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));

PrivateKey myprikey=(PrivateKey)in.readObject();

in.close();

// java.security.spec.X509EncodedKeySpec pubX509=new java.security.spec.X509EncodedKeySpec(bX509);

//java.security.spec.X509EncodedKeySpec pubkeyEncode=java.security.spec.X509EncodedKeySpec

String myinfo="這是我的信息"; //要簽名的信息

//用私鑰對信息生成數字簽名

java.security.Signature signet=java.security.Signature.getInstance("DSA");

signet.initSign(myprikey);

signet.update(myinfo.getBytes());

byte[] signed=signet.sign(); //對信息的數字簽名

System.out.println ("signed(簽名內容)="+byte2hex(signed));

//把信息和數字簽名保存在一個文件中

java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myinfo.dat"));

out.writeObject(myinfo);

out.writeObject(signed);

out.close();

System.out.println("簽名并生成文件成功");

}

catch (java.lang.Exception e) {

e.printStackTrace();

System.out.println("簽名并生成文件失敗");

};

//第三步

//其他人通過公共方式得到此戶的公鑰和文件

//其他人用此戶的公鑰,對文件進行檢查,如果成功說明是此用戶發(fā)布的信息.

//

try {

java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));

PublicKey pubkey=(PublicKey)in.readObject();

in.close();

System.out.println(pubkey.getFormat());

in=new java.io.ObjectInputStream(new java.io.FileInputStream("myinfo.dat"));

String info=(String)in.readObject();

byte[] signed=(byte[])in.readObject();

in.close();

java.security.Signature signetcheck=java.security.Signature.getInstance("DSA");

signetcheck.initVerify(pubkey);

signetcheck.update (info.getBytes());

if (signetcheck.verify(signed)) {

System.out.println("info="+info);

System.out.println("簽名正常");

}

else System.out.println("非簽名正常");

}

catch ( java.lang.Exception e) {e.printStackTrace();};

}

//生成一對文件myprikey.dat和mypubkey.dat---私鑰和公鑰,

//公鑰要用戶發(fā)送(文件,網絡等方法)給其它用戶,私鑰保存在本地

public boolean generatekey()

{

try {

java.security.KeyPairGenerator keygen=java.security.KeyPairGenerator.getInstance("DSA");

// SecureRandom secrand=new SecureRandom();

// secrand.setSeed("tttt".getBytes()); //初始化隨機產生器

// keygen.initialize(576,secrand); //初始化密鑰生成器

keygen.initialize(512);

KeyPair keys=keygen.genKeyPair();

// KeyPair keys=keygen.generateKeyPair(); //生成密鑰組

PublicKey pubkey=keys.getPublic();

PrivateKey prikey=keys.getPrivate();

java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myprikey.dat"));

out.writeObject(prikey);

out.close();

System.out.println("寫入對象 prikeys ok");

out=new java.io.ObjectOutputStream (new java.io.FileOutputStream("mypubkey.dat"));

out.writeObject(pubkey);

out.close();

System.out.println("寫入對象 pubkeys ok");

System.out.println("生成密鑰對成功");

return true;

}

catch (java.lang.Exception e) {

e.printStackTrace();

System.out.println("生成密鑰對失敗");

return false;

};

}

public String byte2hex(byte[] b)

{

String hs="";

String stmp="";

for (int n=0;nb.length;n++)

{

stmp=(java.lang.Integer.toHexString(b[n] 0XFF));

if (stmp.length()==1) hs=hs+"0"+stmp;

else hs=hs+stmp;

if (nb.length-1) hs=hs+":";

}

return hs.toUpperCase();

}

}

2.4. DESede/DES對稱算法

首先生成密鑰,并保存(這里并沒的保存的代碼,可參考DSA中的方法)

KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);

SecretKey deskey = keygen.generateKey();

用密鑰加密明文(myinfo),生成密文(cipherByte)

Cipher c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.ENCRYPT_MODE,deskey);

byte[] cipherByte=c1.doFinal(myinfo.getBytes());

傳送密文和密鑰,本文沒有相應代碼可參考DSA

.............

用密鑰解密密文

c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.DECRYPT_MODE,deskey);

byte[] clearByte= c1.doFinal(cipherByte);

相對來說對稱密鑰的使用是很簡單的,對于JCE來講支技DES,DESede,Blowfish三種加密術

對于密鑰的保存各傳送可使用對象流或者用二進制編碼,相關參考代碼如下

SecretKey deskey = keygen.generateKey();

byte[] desEncode=deskey.getEncoded();

javax.crypto.spec.SecretKeySpec destmp=new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm);

SecretKey mydeskey=destmp;

相關API

KeyGenerator 在DSA中已經說明,在添加JCE后在instance進可以如下參數

DES,DESede,Blowfish,HmacMD5,HmacSHA1

javax.crypto.Cipher 加/解密器

public static final Cipher getInstance(java.lang.String transformation)

throws java.security.NoSuchAlgorithmException ,

NoSuchPaddingException

返回一個指定方法的Cipher對象

參數:transformation 方法名(可用 DES,DESede,Blowfish)

public final void init(int opmode, java.security.Key key)

throws java.security.InvalidKeyException

用指定的密鑰和模式初始化Cipher對象

參數:opmode 方式(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)

key 密鑰

public final byte[] doFinal(byte[] input)

throws java.lang.IllegalStateException,

IllegalBlockSizeException,

BadPaddingException

對input內的串,進行編碼處理,返回處理后二進制串,是返回解密文還是加解文由init時的opmode決定

注意:本方法的執(zhí)行前如果有update,是對updat和本次input全部處理,否則是本inout的內容

/*

安全程序 DESede/DES測試

*/

import java.security.*;

import javax.crypto.*;

public class testdes {

public static void main(String[] args){

testdes my=new testdes();

my.run();

}

public void run() {

//添加新安全算法,如果用JCE就要把它添加進去

Security.addProvider(new com.sun.crypto.provider.SunJCE());

String Algorithm="DES"; //定義 加密算法,可用 DES,DESede,Blowfish

String myinfo="要加密的信息";

try {

//生成密鑰

KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);

SecretKey deskey = keygen.generateKey();

//加密

System.out.println("加密前的二進串:"+byte2hex( myinfo.getBytes()));

System.out.println("加密前的信息:"+myinfo);

Cipher c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.ENCRYPT_MODE,deskey);

byte[] cipherByte=c1.doFinal(myinfo.getBytes());

System.out.println("加密后的二進串:"+byte2hex(cipherByte));

//解密

c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.DECRYPT_MODE,deskey);

byte[] clearByte=c1.doFinal(cipherByte);

System.out.println ("解密后的二進串:"+byte2hex(clearByte));

System.out.println("解密后的信息:"+(new String(clearByte)));

}

catch (java.security.NoSuchAlgorithmException e1) {e1.printStackTrace();}

catch (javax.crypto.NoSuchPaddingException e2) {e2.printStackTrace();}

catch (java.lang.Exception e3) {e3.printStackTrace();}

}

public String byte2hex(byte[] b) //二行制轉字符串

{

String hs="";

String stmp="";

for (int n=0;nb.length;n++)

{

stmp=(java.lang.Integer.toHexString(b[n] 0XFF));

if (stmp.length()==1) hs=hs+"0"+stmp;

else hs=hs+stmp;

if (nb.length-1 ) hs=hs+":";

}

return hs.toUpperCase();

}

}

2.5. Diffie-Hellman密鑰一致協(xié)議

公 開密鑰密碼體制的奠基人Diffie和Hellman所提出的 "指數密鑰一致協(xié)議" (Exponential Key Agreement Protocol),該協(xié)議不要求別的安全性先決條件,允許兩名用戶在公開媒體上交換信息以生成 "一致"的,可以共享的密鑰。在JCE的中實現用戶alice生成DH類型的密鑰對,如果長度用1024生成的時間請,推薦第一次生成后保存 DHParameterSpec,以便下次使用直接初始化.使其速度加快

System.out.println("ALICE: 產生 DH 對 ...");

KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");

aliceKpairGen.initialize(512);

KeyPair aliceKpair = aliceKpairGen.generateKeyPair();

alice生成公鑰發(fā)送組bob

byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();

bob從alice發(fā)送來的公鑰中讀出DH密鑰對的初始參數生成bob的DH密鑰對

注意這一步一定要做,要保證每個用戶用相同的初始參數生成的

DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();

KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");

bobKpairGen.initialize(dhParamSpec);

KeyPair bobKpair = bobKpairGen.generateKeyPair();

bob根據alice的公鑰生成本地的DES密鑰

KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");

bobKeyAgree.init(bobKpair.getPrivate());

bobKeyAgree.doPhase (alicePubKey, true);

SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

bob已經生成了他的DES密鑰,他現把他的公鑰發(fā)給alice,

byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

alice根據bob的公鑰生成本地的DES密鑰

,,,,,,解碼

KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");

aliceKeyAgree.init(aliceKpair.getPrivate());

aliceKeyAgree.doPhase (bobPubKey, true);

SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

bob和alice能過這個過程就生成了相同的DES密鑰,在這種基礎就可進行安全能信

常用API

java.security.KeyPairGenerator 密鑰生成器類

public static KeyPairGenerator getInstance(String algorithm)

throws NoSuchAlgorithmException

以指定的算法返回一個KeyPairGenerator 對象

參數: algorithm 算法名.如:原來是DSA,現在添加了 DiffieHellman(DH)

public void initialize(int keysize)

以指定的長度初始化KeyPairGenerator對象,如果沒有初始化系統(tǒng)以1024長度默認設置

參數:keysize 算法位長.其范圍必須在 512 到 1024 之間，且必須為 64 的倍數

注意:如果用1024生長的時間很長,最好生成一次后就保存,下次就不用生成了

public void initialize(AlgorithmParameterSpec params)

throws InvalidAlgorithmParameterException

以指定參數初始化

javax.crypto.interfaces.DHPublicKey

public DHParameterSpec getParams()

返回

java.security.KeyFactory

public static KeyFactory getInstance(String algorithm)

throws NoSuchAlgorithmException

以指定的算法返回一個KeyFactory

參數: algorithm 算法名:DSH,DH

public final PublicKey generatePublic(KeySpec keySpec)

throws InvalidKeySpecException

根據指定的key說明,返回一個PublicKey對象

java.security.spec.X509EncodedKeySpec

public X509EncodedKeySpec(byte[] encodedKey)

根據指定的二進制編碼的字串生成一個key的說明

參數:encodedKey 二進制編碼的字串(一般能過PublicKey.getEncoded()生成)

javax.crypto.KeyAgreement 密碼一至類

public static final KeyAgreement getInstance(java.lang.String algorithm)

throws java.security.NoSuchAlgorithmException

返回一個指定算法的KeyAgreement對象

參數:algorithm 算法名,現在只能是DiffieHellman(DH)

public final void init(java.security.Key key)

throws java.security.InvalidKeyException

用指定的私鑰初始化

參數:key 一個私鑰

public final java.security.Key doPhase(java.security.Key key,

boolean lastPhase)

throws java.security.InvalidKeyException,

java.lang.IllegalStateException

用指定的公鑰進行定位,lastPhase確定這是否是最后一個公鑰,對于兩個用戶的

情況下就可以多次定次,最后確定

參數:key 公鑰

lastPhase 是否最后公鑰

public final SecretKey generateSecret(java.lang.String algorithm)

throws java.lang.IllegalStateException,

java.security.NoSuchAlgorithmException,

java.security.InvalidKeyException

根據指定的算法生成密鑰

參數:algorithm 加密算法(可用 DES,DESede,Blowfish)

*/

import java.io.*;

import java.math.BigInteger;

import java.security.*;

import java.security.spec.*;

import java.security.interfaces.*;

import javax.crypto.*;

import javax.crypto.spec.*;

import javax.crypto.interfaces.*;

import com.sun.crypto.provider.SunJCE;

public class testDHKey {

public static void main(String argv[]) {

try {

testDHKey my= new testDHKey();

my.run();

} catch (Exception e) {

System.err.println(e);

}

}

private void run() throws Exception {

Security.addProvider (new com.sun.crypto.provider.SunJCE());

System.out.println("ALICE: 產生 DH 對 ...");

KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");

aliceKpairGen.initialize (512);

KeyPair aliceKpair = aliceKpairGen.generateKeyPair(); //生成時間長

// 張三(Alice)生成公共密鑰 alicePubKeyEnc 并發(fā)送給李四(Bob) ,

//比如用文件方式,socket.....

byte[] alicePubKeyEnc = aliceKpair.getPublic ().getEncoded();

//bob接收到alice的編碼后的公鑰,將其解碼

KeyFactory bobKeyFac = KeyFactory.getInstance("DH");

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec (alicePubKeyEnc);

PublicKey alicePubKey = bobKeyFac.generatePublic(x509KeySpec);

System.out.println("alice公鑰bob解碼成功");

// bob必須用相同的參數初始化的他的DH KEY對,所以要從Alice發(fā)給他的公開密鑰,

//中讀出參數,再用這個參數初始化他的 DH key對

//從alicePubKye中取alice初始化時用的參數

DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();

KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");

bobKpairGen.initialize(dhParamSpec);

KeyPair bobKpair = bobKpairGen.generateKeyPair();

System.out.println("BOB: 生成 DH key 對成功");

KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");

bobKeyAgree.init(bobKpair.getPrivate());

System.out.println("BOB: 初始化本地key成功");

//李四(bob) 生成本地的密鑰 bobDesKey

bobKeyAgree.doPhase(alicePubKey, true);

SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

System.out.println("BOB: 用alice的公鑰定位本地key,生成本地DES密鑰成功");

// Bob生成公共密鑰 bobPubKeyEnc 并發(fā)送給Alice,

//比如用文件方式,socket.....,使其生成本地密鑰

byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

System.out.println("BOB向ALICE發(fā)送公鑰");

// alice接收到 bobPubKeyEnc后生成bobPubKey

// 再進行定位,使aliceKeyAgree定位在bobPubKey

KeyFactory aliceKeyFac = KeyFactory.getInstance("DH");

x509KeySpec = new X509EncodedKeySpec(bobPubKeyEnc);

PublicKey bobPubKey = aliceKeyFac.generatePublic(x509KeySpec);

System.out.println("ALICE接收BOB公鑰并解碼成功");

;

KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");

aliceKeyAgree.init(aliceKpair.getPrivate());

System.out.println("ALICE: 初始化本地key成功");

aliceKeyAgree.doPhase(bobPubKey, true);

// 張三(alice) 生成本地的密鑰 aliceDesKey

SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

System.out.println("ALICE: 用bob的公鑰定位本地key,并生成本地DES密鑰");

if (aliceDesKey.equals(bobDesKey)) System.out.println ("張三和李四的密鑰相同");

//現在張三和李四的本地的deskey是相同的所以,完全可以進行發(fā)送加密,接收后解密,達到

//安全通道的的目的

/*

* bob用bobDesKey密鑰加密信息

*/

Cipher bobCipher = Cipher.getInstance("DES");

bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);

String bobinfo= "這是李四的機密信息";

System.out.println("李四加密前原文:"+bobinfo);

byte[] cleartext =bobinfo.getBytes();

byte[] ciphertext = bobCipher.doFinal(cleartext);

/*

* alice用aliceDesKey密鑰解密

*/

Cipher aliceCipher = Cipher.getInstance("DES");

aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey);

byte[] recovered = aliceCipher.doFinal(ciphertext);

System.out.println("alice解密bob的信息:"+(new String(recovered)));

if (!java.util.Arrays.equals(cleartext, recovered))

throw new Exception("解密后與原文信息不同");

System.out.println("解密后相同");

}

}

文章名稱：java實現dh算法代碼 des算法java代碼
路徑分享：http://chinadenli.net/article6/ddgdjig.html

成都網站建設公司_創(chuàng)新互聯(lián)，為您提供域名注冊、品牌網站設計、定制網站、網站營銷、標簽優(yōu)化、ChatGPT

廣告

聲明：本網站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)

外貿網站制作