eclipse实现可认证的DH密钥交换协议_eclipse实现dh密钥协_秃头选拔赛形象大使的博客

二、实验要求

熟悉DH密钥交换算法基本原理；
理解原始DH密钥交换算法存在的中间人攻击；
理解简化STS协议抗中间人攻击的原理。
掌握使用java编写实验代码进行正确的简化STS协议实现和验证。
三、开发环境

JDK 1.7，Java开发环境（本实验采用Windows+eclipse作为实验环境），要求参与实验的同学按照对称加密提供的方法，提前安装好JDK。
四、实验原理

通过使用密码学库实现可认证的DH密钥交换协议（简化STS协议），能够编写简单的实验代码进行正确的协议实现和验证。

代码段：
AuthDHKeyAgree
import java.math.BigInteger;
import java.util.Random;
public class AuthDHKeyAgree {
	private static final int securityParam = 1023;
	public static BigInteger p;
	public static BigInteger q;
	public static BigInteger g;
	//生成安全素数p,p=2q+1,q为一个1023 bits的大素数
	public static void safePGen() {
		BigInteger one = new BigInteger("1",10);
		BigInteger two = new BigInteger("2",10);
		do {
			p = new BigInteger("0",10);
			q = new BigInteger(securityParam, 100, new Random());
			p = p.add(q.multiply(two).add(one));
		}while( p.isProbablePrime(100) == false );
	//选取随机生成元g,通过随机选择[2,p-2]之间的数g,然后判断g^q mod p是否等于1,如果不等于1,则g为生成元
	public static void generatorGGen() {
		BigInteger one = new BigInteger("1",10);
		BigInteger two = new BigInteger("2",10);
		BigInteger result;
		do {
			g = new BigInteger(securityParam, new Random());
			g = g.mod(p.subtract(one));
			result = g.modPow(q, p);
		}while( g.compareTo(two) < 0 || result.compareTo(one) == 0 );
	public static void main(String[] args) {
		System.out.println("系统初始化,生成安全素数p,选取随机生成元g...");
		safePGen();
		System.out.println("p: "+p.toString(16));
		System.out.println("q: "+q.toString(16));
		generatorGGen();
		System.out.println("g: "+g.toString(16));
		//Alice选择随机秘密值 0<=r1<=p-1
		BigInteger r1 = new BigInteger(securityParam, new Random());
		BigInteger A;
		r1 = r1.mod(p);
		//Alice计算g^r1 mod p
		A = g.modPow(r1, p);
		//Bob选择随机秘密值0<=r2<=p-1
		BigInteger r2 = new BigInteger(securityParam, new Random());
		BigInteger B;
		//Bob计算g^r2 mod p
		B = g.modPow(r2, p);
		//Bob初始化一个RSA签名算法对象
		RSASignatureAlgorithm BobRSA = new RSASignatureAlgorithm();
		BobRSA.initKeys();
		byte[] BobM = (A.toString()+B.toString()+"Alice"+"Bob").getBytes();
		//Bob生成签名
		BigInteger BobSig = BobRSA.signature(BobM);
		//Alice验证签名
		BobM = (A.toString()+B.toString()+"Alice"+"Bob").getBytes();
		boolean result = BobRSA.verify(BobM, BobSig);
		if( result == true ) System.out.println("Alice验证签名通过。");
		else System.out.println("Alice验证签名不通过。");
		//Alice计算会话密钥
		BigInteger sessionKey = (A.multiply(B)).mod(p);
		System.out.println("Alice计算得到的会话密钥为:"+sessionKey.toString(16));
		//Alice初始化一个RSA签名算法对象
		RSASignatureAlgorithm AliceRSA = new RSASignatureAlgorithm();
		AliceRSA.initKeys();
		byte[] AliceM = (A.toString()+B.toString()+"Alice"+"Bob").getBytes();
		//Alice生成签名
		BigInteger AliceSig = AliceRSA.signature(AliceM);
		//Bob验证签名
		AliceM = (A.toString()+B.toString()+"Alice"+"Bob").getBytes();
		result = AliceRSA.verify(AliceM, AliceSig);
		if ( result == true ) System.out.println("Bob验证签名通过。");
		else System.out.println("Bob验证签名不通过");
		//Bob计算会话密钥
		sessionKey = (B.multiply(A)).mod(p);
		System.out.println("Bob计算得到的会话密钥为:"+sessionKey.toString(16));
RSASignatureAlgorithm




    
 
import java.math.BigInteger;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Random;
public class RSASignatureAlgorithm {
	BigInteger n;
	BigInteger e;
	BigInteger d;
	public BigInteger __hash(byte m[]) {
		MessageDigest md;
		try {
			md = MessageDigest.getInstance("SHA-256");
			md.update(m);
		byte b[] = new byte[33];
		System.arraycopy(md.digest(), 0, b, 1, 32);
		return new BigInteger(b);
		} catch (NoSuchAlgorithmException e) {
			System.out.println("this cannot happen.");
	return null;
	public void initKeys() {
		BigInteger p = new BigInteger(1024, 500, new Random());
		BigInteger q = new BigInteger(1024, 500, new Random());
		assert(p.compareTo(q) != 0);
		n = p.multiply(q);
		BigInteger fi_n = p.subtract(BigInteger.ONE)
			.multiply(q.subtract(BigInteger.ONE));
		e = new BigInteger(512, 100, new Random());
		d = e.modInverse(fi_n);
		System.out.println("n : " + n.toString(16));
		System.out.println("e : " + e.toString(16));
		System.out.println("d : " + d.toString(16));
	public BigInteger signature(byte m[]) {
		BigInteger s = __hash(m).modPow(d, n);
		System.out.println("s : " + s);
		return s;
	public boolean verify(byte m[], BigInteger s) {
		BigInteger left  = __hash(m).mod(n);
		BigInteger right = s.modPow(e, n);
		return left.compareTo(right) == 0;
                                    DH密钥交换算法简单来说就是一共有三种密钥，一个仅自己知道的私钥，一个可以公开的公钥，一个相同的共享密钥，甲乙双方都需要用对方私钥计算出来的一个公钥，再结合自己的私钥计算出一个相同的共享密钥。来达到安全传输密钥的目的。
                                    可认证的DH密钥交换协议，供大家参考，具体内容如下一、实验目的通过使用密码学库实现可认证的DH密钥交换协议(简化STS协议)，能够编写简单的实验代码进行正确的协议实现和验证。二、实验要求1、熟悉DH密钥交换算法基本原理；2、理解原始DH密钥交换算法存在的中间人攻击；3、理解简化STS协议抗中间人攻击的原理。4、掌握使用java编写实验代码进行正确的简化STS协议实现和验证。三、 开发环境JDK 1...
一 什么是DH密钥交换
DH密钥交换是1976年由Diffie和Hellman共同发明的一种算法。使用这种算法，通信双方仅通过交换一些可以公开的信息就能够生成出共享的密码数字，而这一密码数字就可以被用作对称密码的密钥。IPsec中就使用了经过改良的DH密钥交换。
虽然这种方法的名字叫“密钥交换”，但实际上双方并没有真正交换密钥，而是通过计算生成出一个相同的共享密钥。因此，这种方法也称DH密钥协商。
二 DH密钥交换的步骤
现在假设Alic
密钥交换/协商目的
“密钥协商机制”是：（在身份认证的前提下）规避【偷窥】的风险。通俗地说，即使有攻击者在偷窥客户端与服务器的网络传输，客户端（client）依然可以利用“密钥协商机制”与服务器端（server）协商出一个只有二者可知的用来对于应用层数据进行加密的密钥（也称“会话密钥”）。
密钥交换/协商机制的几种类型
1，依靠非对称加密算法
拿到公钥的一
有这样一个事，在以前通信、交通都不是很方便的时候，一个地主A要给B传输一个秘密，但相隔还有点点远，所以A把秘密写在了纸上，把纸装在了一个箱子里面，找了龙门镖局帮忙运输，但现在A不能一路跟上，所以怕镖局的人中间把箱子打开，所以就给箱子加了个锁（这儿假设箱子和锁在没有钥匙的情况下是打不开的），老谋深算的地主A认定镖局是不可信的，可能去偷看，所以不可能把钥匙交个他们，那么这种情况下，要怎么才能保证运输中的安全性呢？且运到后B是可以正常去查看消息的。
他们是这样做的，地主A先上一把锁，让镖局的把箱子运往B，叫
                                    Diffie-Hellman:一种确保共享KEY安全穿越不安全网络的方法，它是OAKLEY的一个组成部分。Whitfield Diffie与Martin Hellman在1976年提出了一个奇妙的密钥交换协议，称为Diffie-Hellman密钥交换协议/算法(Diffie-Hellman Key Exchange/Agreement Algorithm).这个机制的巧妙在于需要安全通信的双方可以用
                                    ECC算法和DH结合使用，用于密钥磋商，这个密钥交换算法称为ECDH。交换双方可以在不共享任何秘密的情况下协商出一个密钥。ECC是建立在基于椭圆曲线的离散对数问题上的密码体制，给定椭圆曲线上的一个点P，一个整数k，求解Q=kP很容易；给定一个点P、Q，知道Q=kP，求整数k确是一个难题。ECDH即建立在此数学难题之上。密钥磋商过程：
假设密钥交换双方为Alice、Bob，其有共享曲线参数（椭圆曲线E、阶N、基点G）。
Alice生成随机整数a，计算A=a*G。
Bob生成随机整数b，计算B=b*G。
二、实验要求

三、 开发环境

四、实验原理

三、开发环境
