非对称加密算法-DH,RSA,ElGamal

最新推荐文章于 2023-10-16 23:18:58 发布
最新推荐文章于 2023-10-16 23:18:58 发布
阅读量3.8k 收藏 2
点赞数
分类专栏： security 文章标签： security 非对称加密 DH RSA ElGamal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuozhiyoulaisam/article/details/54947402
版权

代码参考URL:http://www.imooc.com/learn/288

1.非对称加密算法--DH

流程说明参考的文章：http://blog.csdn.net/sunny_sailor/article/details/7445649

DH的流程:

1.甲方构建密钥对儿，将公钥公布给乙方，将私钥保留；双方约定数据加密算法；乙方通过甲方公钥构建密钥对儿，将公钥公布给甲方，将私钥保留。 
2.甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给乙方加密后的数据；乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。 
3.乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给甲方加密后的数据；甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。


1.使用jdk,bc来实现对应代码:

package com.samlai.security.asyEncry;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.spec.X509EncodedKeySpec;
import java.util.Objects;

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;


public class DHStudy {
	/**
	 * 非对称加密算法 -DH(密钥交换)
	 *  对称加密带来的困扰
	 *  构建本地密钥
	 *  对称
	 */
	private static String STR = "one type of security:DH";
	
	public static void main(String[] args) {
		jdkDH();
		bcDH();
	}
	
	
	//jdk实现DH
	public static void jdkDH(){
		try {
			//初始化发送方密钥
			KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance("DH");
			senderKeyPairGenerator.initialize(512);
			KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair();
			//发送方公钥，发送给收方(网络,文件)
			byte[] senderPublicKeyEnc=senderKeyPair.getPublic().getEncoded();
			
			//初始化接收方密钥
			KeyFactory receiverKeyFactory=KeyFactory.getInstance("DH");
			X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(senderPublicKeyEnc);
			PublicKey receiverPublicKey=receiverKeyFactory.generatePublic(x509EncodedKeySpec);
			DHParameterSpec dhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();
			KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance("DH");
			receiverKeyPairGenerator.initialize(dhParameterSpec);
			KeyPair receiverKeyPair=receiverKeyPairGenerator.generateKeyPair();
			PrivateKey reveiverPrivateKey=receiverKeyPair.getPrivate();
			byte[] receiverPublicKeyEnc=receiverKeyPair.getPublic().getEncoded();
			
			//密钥构建
			KeyAgreement receiverKeyAgreement=KeyAgreement.getInstance("DH");
			receiverKeyAgreement.init(reveiverPrivateKey);
			receiverKeyAgreement.doPhase(receiverPublicKey, true);
			SecretKey receiverDesKey=receiverKeyAgreement.generateSecret("DES");
			
			KeyFactory senderKeyFactory=KeyFactory.getInstance("DH");
			x509EncodedKeySpec=new X509EncodedKeySpec(receiverPublicKeyEnc);
			PublicKey senderPublicKey=senderKeyFactory.generatePublic(x509EncodedKeySpec);
			KeyAgreement senderKeyAgreement=KeyAgreement.getInstance("DH");
			senderKeyAgreement.init(senderKeyPair.getPrivate());
			senderKeyAgreement.doPhase(senderPublicKey, true);
			SecretKey senderDesKey=senderKeyAgreement.generateSecret("DES");
			if(Objects.equals(receiverDesKey, senderDesKey)){
				System.out.println("双方密钥相同");
			}
			
			//加密
			Cipher cipher=Cipher.getInstance("DES");
			cipher.init(Cipher.ENCRYPT_MODE, senderDesKey);
			byte[] result=cipher.doFinal(STR.getBytes());
			System.out.println("jdk DH encode: "+Base64.encodeBase64String(result));
			
			
			//解密
			cipher.init(Cipher.DECRYPT_MODE, receiverDesKey);
			result=cipher.doFinal(result);
			System.out.println("jdk DH decode: "+new String(result));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	//bc实现DH算法
	public static void bcDH(){
		try {
			Security.addProvider(new BouncyCastleProvider());
			//初始化发送方密钥
			KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance("DH","BC");
			senderKeyPairGenerator.getProvider();
			senderKeyPairGenerator.initialize(512);
			KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair();
			//发送方公钥，发送给收方(网络,文件)
			byte[] senderPublicKeyEnc=senderKeyPair.getPublic().getEncoded();
			
			//初始化接收方密钥
			KeyFactory receiverKeyFactory=KeyFactory.getInstance("DH");
			X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(senderPublicKeyEnc);
			PublicKey receiverPublicKey=receiverKeyFactory.generatePublic(x509EncodedKeySpec);
			DHParameterSpec dhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();
			KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance("DH","BC");
			receiverKeyPairGenerator.getProvider();
			receiverKeyPairGenerator.initialize(dhParameterSpec);
			KeyPair receiverKeyPair=receiverKeyPairGenerator.generateKeyPair();
			PrivateKey reveiverPrivateKey=receiverKeyPair.getPrivate();
			byte[] receiverPublicKeyEnc=receiverKeyPair.getPublic().getEncoded();
			
			//密钥构建
			KeyAgreement receiverKeyAgreement=KeyAgreement.getInstance("DH");
			receiverKeyAgreement.init(reveiverPrivateKey);
			receiverKeyAgreement.doPhase(receiverPublicKey, true);
			SecretKey receiverDesKey=receiverKeyAgreement.generateSecret("DES");
			
			KeyFactory senderKeyFactory=KeyFactory.getInstance("DH");
			x509EncodedKeySpec=new X509EncodedKeySpec(receiverPublicKeyEnc);
			PublicKey senderPublicKey=senderKeyFactory.generatePublic(x509EncodedKeySpec);
			KeyAgreement senderKeyAgreement=KeyAgreement.getInstance("DH");
			senderKeyAgreement.init(senderKeyPair.getPrivate());
			senderKeyAgreement.doPhase(senderPublicKey, true);
			SecretKey senderDesKey=senderKeyAgreement.generateSecret("DES");
			if(Objects.equals(receiverDesKey, senderDesKey)){
				System.out.println("双方密钥相同");
			}
			
			//加密
			Cipher cipher=Cipher.getInstance("DES");
			cipher.init(Cipher.ENCRYPT_MODE, senderDesKey);
			byte[] result=cipher.doFinal(STR.getBytes());
			System.out.println("bc DH encode: "+Base64.encodeBase64String(result));
			
			
			//解密
			cipher.init(Cipher.DECRYPT_MODE, receiverDesKey);
			result=cipher.doFinal(result);
			System.out.println("bc DH decode: "+new String(result));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

运行的结果：

双方密钥相同
jdk DH encode: XbmK/tkwVlYao3lhJvLWqceJ8QiYkODa
jdk DH decode: one type of security:DH
双方密钥相同
bc DH encode: Ehu42tOe7AmwMLOAAf2S4/1pwnX+91Iy
bc DH decode: one type of security:DH

2.jdk实现RSA算法: 

package com.samlai.security.asyEncry;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Base64;

public class RSAStudy {
	/**
	 * 非对称加密算法 --RSA
	 * 基于大数因子分解
	 * 	唯一广泛接受并实现
	 * 	数据加密&数字签名
	 * 	公钥加密 私钥解密
	 * 	私钥加密 公钥解密
	 */
	private static String STR = "one type of security:RSA";
	
	public static void main(String[] args) {
		jdkRSA();
	}
	
	//jdk实现RSA加密
	public static void jdkRSA(){
		try {
			//1.初始化密钥
			KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA");
			keyPairGenerator.initialize(512);
			KeyPair keyPair=keyPairGenerator.generateKeyPair();
			RSAPublicKey rsaPublicKey=(RSAPublicKey)keyPair.getPublic();
			RSAPrivateKey rsaPrivate=(RSAPrivateKey)keyPair.getPrivate();
			//打印出来的公钥是比私钥短较多的,公钥公开，较短较容易保存
			System.out.println("public Key: "+Base64.encodeBase64String(rsaPublicKey.getEncoded()));
			System.out.println("private Key: "+Base64.encodeBase64String(rsaPrivate.getEncoded()));
			
			
			//2.私钥加密,公钥解密---加密
			PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivate.getEncoded());
			KeyFactory keyFactory=KeyFactory.getInstance("RSA");
			PrivateKey privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
			Cipher cipher=Cipher.getInstance("RSA");
			cipher.init(Cipher.ENCRYPT_MODE, privateKey);
			byte[] result=cipher.doFinal(STR.getBytes());
			System.out.println("私钥加密,公钥解密---加密: "+Base64.encodeBase64String(result));
			
			//3.私钥加密,公钥解密---解密
			X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
			keyFactory=KeyFactory.getInstance("RSA");
			PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
			cipher=Cipher.getInstance("RSA");
			cipher.init(Cipher.DECRYPT_MODE, publicKey);
			result=cipher.doFinal(result);
			System.out.println("私钥加密,公钥解密---解密: "+new String(result));
			
			
			//4.公钥加密,私钥解密 --- 加密[与上面非常的相近的]
			x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
			keyFactory=KeyFactory.getInstance("RSA");
			publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
			cipher.init(Cipher.ENCRYPT_MODE, publicKey);
			result=cipher.doFinal(result);
			System.out.println("公钥加密,私钥解密 --- 加密: "+Base64.encodeBase64String(result));
			
			//5.公钥加密,私钥解密 --- 解密
			pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivate.getEncoded());
			keyFactory=KeyFactory.getInstance("RSA");
			privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
			cipher=Cipher.getInstance("RSA");
			cipher.init(Cipher.DECRYPT_MODE, privateKey);
			result=cipher.doFinal(result);
			System.out.println("公钥加密,私钥解密 --- 解密: "+new String(result));
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}

运行的结果: 

public Key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAM0TUZSywLpr8e3UGhCM84/LQT+LS64OUXTFn9O5Kt/dOg+eiYdBKSON1cfVJWAsEAuIKYwFwl2z1PfxBkZ01r0CAwEAAQ==
private Key: MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAzRNRlLLAumvx7dQaEIzzj8tBP4tLrg5RdMWf07kq3906D56Jh0EpI43Vx9UlYCwQC4gpjAXCXbPU9/EGRnTWvQIDAQABAkBolsG0pLXGXec09EeWyUwuueq9Db27N3Izq9anlHhZUv/PLIg83/Ucxl5NTDFfxPiBHqtYWUsAprOvxUqORzABAiEA/DK5wwaH7kOf+EE0ytMzlb2rwYM7Semx6OhrM23eVUECIQDQKr0i1LpRU2caCS5F3wc+FkrZF1ajZBA6EsNDUQm2fQIgKyJd5T5Tt2u3i5VTezE+TGkhXDqexFiFBkniM+yhr0ECIQCxm4V77lx5ftt8z1B3tO6M/qAl0U/OYFWn9tI64S2UUQIhAOh4v+zANLyfdFKNeau/zIeRLGYXzDd8lUg2KQuHPzB4
私钥加密,公钥解密---加密: Oy+z3Ncym67f7tYYoulFDfjTn3tQK3YQ+Dx/UhBljsSC2WTf2ZnlT6+EK+rqSyqkOK93w00tNoeGrYdlWMAlSw==
私钥加密,公钥解密---解密: one type of security:RSA
公钥加密,私钥解密 --- 加密: uLndrx+xnmR6en3f4gfEnY9u9vrf4UnDIUcM5+zXc4ykSBk628x0vKT+UuRYBY30Pyh60aoBz0FLbuimGBKQNw==
公钥加密,私钥解密 --- 解密: one type of security:RSA

RSA运用的流程如下：



3.ElGamal算法实现

当密钥大于128时，代码会抛出java.security.InvalidKeyException: Illegal key size or default parametersIllegal key size or default parameters是指密钥长度是受限制的，java运行时环境读到的是受限的policy文件。文件位于${java_home}/jre/lib/security。这种限制是因为美国对软件出口的控制。

条件:因为ElGamal加密的长度为8的倍数，160-16384位,由于from us所以对加密长度有进行限制的，（大于128位时）所以本身我们本地的jdk是对这些文件是有限制，故需要下载额外的jar文件:US_export_policy.jar,local_policy.jar 替换的本地的java的jdk目录下的jre的security下2jar包就可以正确执行ElGamal代码了

参考url:http://stackoverflow.com/questions/6481627/java-security-illegal-key-size-or-default-parameters

package com.samlai.security.asyEncry;


import java.security.AlgorithmParameterGenerator;
import java.security.AlgorithmParameters;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;


import javax.crypto.Cipher;
import javax.crypto.spec.DHParameterSpec;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class ElGamalStudy {
	
	/**
	 * 没有jdk实现，bc提供
	 * 公钥加密算法
	 * 密钥长度：8的倍数 160>
	 * 
	 */
	private static String STR = "one type of security:ElGamal";
	public static void main(String[] args) {
		bcElGamal();
	}
	//jdk实现RSA加密
	public static void bcElGamal(){
		try {
			Security.addProvider(new BouncyCastleProvider());
			//初始化密钥
			AlgorithmParameterGenerator algorithmParameterGenerator=AlgorithmParameterGenerator.getInstance("ElGamal");
			algorithmParameterGenerator.init(256);
			AlgorithmParameters algorithmParameters=algorithmParameterGenerator.generateParameters();
			DHParameterSpec dhParameterSpec=(DHParameterSpec)algorithmParameters.getParameterSpec(DHParameterSpec.class);
			KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("ElGamal");
			keyPairGenerator.initialize(dhParameterSpec,new SecureRandom());
			KeyPair keyPair=keyPairGenerator.generateKeyPair();
			//构建对应的密钥对
			PublicKey elGamalPublicKey=keyPair.getPublic();
			PrivateKey elGamalPrivateKey=keyPair.getPrivate();
			
			System.out.println("Public Key: "+Base64.encodeBase64String(elGamalPublicKey.getEncoded()));
			System.out.println("Private Key: "+Base64.encodeBase64String(elGamalPrivateKey.getEncoded()));;
			
			
			//步骤是：
			/**
			 * 1.在接收者上进行构建密钥对就是公钥跟私钥
			 * 2.由接收者进行发布公钥,再由发布者进行公钥进行加密数据,再进行传输加密数据
			 * 3.接收者进行接收数据,由私钥进行解密
			 */
			
			//公钥加密,私钥解密 ----- 加密
//			X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(elGamalPublicKey.getEncoded());
//			KeyFactory keyFactory=KeyFactory.getInstance("ElGamal");
//			PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
			Cipher cipher=Cipher.getInstance("ElGamal");
			cipher.init(Cipher.ENCRYPT_MODE, elGamalPublicKey);
			byte[] result=cipher.doFinal(STR.getBytes());
			System.out.println("ElGamals算法,公钥加密,私钥解密-----加密: "+Base64.encodeBase64String(result));
			
//			PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(elGamalPrivateKey.getEncoded());
//			keyFactory=KeyFactory.getInstance("ElGamal");
//			PrivateKey privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
			cipher=Cipher.getInstance("ElGamal");
			cipher.init(Cipher.DECRYPT_MODE, elGamalPrivateKey);
			result=cipher.doFinal(result);
			System.out.println("ElGamals算法,公钥加密,私钥解密-----解密: "+new String(result));
			
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

运行结果: 

Public Key: MHcwUAYGKw4HAgEBMEYCIQDLb7VPLae2lzgRPOjD8dXsxxsuDaZVEdXjknwg4b2g/wIhAIdAvANdNVDdJ7JZoPZBpzWzKe9PA94xpPe59+fARTE4AyMAAiAG6zKE1VmQofKM6+oIYAYE4+sze9UT5eYPOx4rdAlBbQ==
Private Key: MHkCAQAwUAYGKw4HAgEBMEYCIQDLb7VPLae2lzgRPOjD8dXsxxsuDaZVEdXjknwg4b2g/wIhAIdAvANdNVDdJ7JZoPZBpzWzKe9PA94xpPe59+fARTE4BCICIAUlzfqi879n8oJfQcIDUniu4yaJ1JRA5G0RIj58XuCE
ElGamals算法,公钥加密,私钥解密-----加密: ToLmNsaIM422cRKXOoJbyPy2ta2lzhVR1bmlEGv/+VuAkKeVpqj5XKjE1wMWVQCHP5t6UTBPIcPAdNQbydhxXQ==
ElGamals算法,公钥加密,私钥解密-----解密: one type of security:ElGamal





左之右
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
独孤密码-非对称加密算法RSA解析
01-07
非对称加密算法家族包含了鼻祖DH算法,基于因子分解难题的RSA算法,基于离散对数难题的ElGamal算法和ECC算法等.在本人对接过的多家银行和第三方支付接口中,RSA算法是非对称加密中的网红花旦,今天就浅谈下RSA算法. 二....
DH密钥交换与RSA加密算法
qq_37056751的博客
04-12 1487
DH密钥交换 DH密钥交换是一种非对称加密算法。 它是基于一个很简单的想法——颜色。由两种颜色混合得到第三种混合色很容易，分离混合色很难。 交换过程如上图，其中黄（Y）是共享颜色，蓝（B）是“我”的私有颜色，“绿”是小明的私有颜色。最终结果BGY=GBY，两个人的密钥相同，建立通信成功。而窃听者小刚只能得到（BY）和（GY），即使将它们混合，也只能得到BGYY，很难将黄色从中分离。 如果我们要在计算机中实现，就必须使用数学方法。即单向函数——正向运算容易，逆向运算难。符合这种方法的是模运算。例如x % y
DH、RSA与ElGamal非对称加密算法实现及应用
weixin_30897233的博客
07-28 758
1.对称加密与非对称加密概述 关于对称加密与非对称加密的概念这里不再多说，感兴趣可以看下我之前的几篇文章，下面说一说两者的主要区别。 对称加密算法数据安全，密钥管理复杂，密钥传递过程复杂，存在密钥泄露问题。 非对称加密算法强度复杂、安全性依赖于算法与密钥。但是由于算法复杂，使得非对称算法加解密速度没有对称算法加解密的速度快。 对称密钥体制中只有一种密钥，并且是非公开的。如果要解密就得让对...
9、EIGamal算法
安全学习笔记
05-20 6835
EIGamal算法
浅谈ElGamal加密算法
最新发布
weixin_72223644的博客
10-16 1124
ElGamal加密算法，与耳熟能详的另一个算法RSA，同属于公钥密码体制，也就是非对称加密。差别在于，ElGamal是基于离散对数问题的难解性。此外，ElGamal算法在椭圆曲线上也有广泛的应用。然而，作为初学者，本文不涉及椭圆曲线内容，仅从算法的简单实现上谈一谈想法。首先，和许多加密算法一样，在密钥生成中要求我们选取一个大素数p，其中一个原因:使得求解离散对数问题在计算上是困难的，这点暂且不论。随后，在算法的实现过程中，我因疏忽而选取了一个小的素数，即令p=19，需要传输的消息是数字m=36。
ElGamal加密算法｜ElGamal签名算法｜公钥密码｜数字签名｜密码学｜信息安全
Suryxin's blogs
12-20 1万+
ElGamal加密算法 简单介绍 EIGamal密码是除了RSA密码之外最有代表性的公开密钥密码 EIGamal是建立在离散对数的困难问题上的一种公钥体制密码 密钥产生 选一个素数p，以及小于p的两个随机数g和x 计算 y=gxy = g^xy=gx%p 公钥为(y, g, p)，私钥为x 算法加密过程 M为明文 选取一个与p-1互素的整数k C1=gkC_1=g^kC1​=gk%p C2=ykMC_2=y^kMC2​=ykM%p (C1,C2)(C_1,C_2)(C1​,C2​)即为密文
【密码学】ElGamal加密算法原理 以及 例题讲解
码农研究僧的博客
04-15 7040
非对称加密算法应用于一些技术标准中，如数字签名标准（DSS）、S/MIME 电子邮件标准算法定义在任何循环群 G 上，安全性取决于 G 上的离散对数难题。
Java编程实现非对称加密的方法详解
08-29
它可以用于加/解密报文，是一种常用的非对称加密算法。 4. ElGamal加密算法 ElGamal加密算法是一种基于离散对数算法的一种加密算法。它可以用于加/解密报文，是一种高级的非对称加密算法。 5. Java实现DH加密解密...
java加密算法:Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法
03-15
java关于加密的算法demo代码（Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法） JAVA安全实现三种方式： 1.JDK 2.Commons Codec 3.Bouncy Castle 一。非对称加密算法： 1.DH 2.RSA 3.ELGamal 二。...
JavaSecurity:java 摘要算法，对称加密，非对称加密算法
05-14
RSA是一种广泛使用的非对称加密算法，结合了大整数因子分解的难度，适用于数字签名和密钥交换。ElGamal则是另一种非对称加密算法，基于离散对数问题，常用于数字签名和加密。 在Java中，可以使用`java.security`包...
[JAVA加解密]DES,AES,PBE,DH,RSA,ElGamal等算法实现及DataServlet实例
01-28
接下来，非对称加密算法，如DH（Diffie-Hellman）和RSA，它们使用一对公钥和私钥。DH算法主要用于密钥交换，两方通过公开信息协商出一个共享密钥，而RSA则可用于加密和数字签名，私钥用于解密和签名，公钥用于加密和...
Elgamal加密算法原理及实现
u012391423的博客
05-17 2万+
目录 一、概述 二、知识准备 1、阶 2、本原元 三、算法流程 1、密钥生成 2、加密 3、解密 四、代码实现 一、概述 Rsa是基于大质数分解难题；而Elgamal是基于G上的离散对数难题 ElGamal算法是由Tather ElGamal在1985年提出的，它是一种基于离散对数难题的加密体系，与RAS算法一样，既能用于数据加密，也能用于数字签名。ElGamal算法是基于因数分解，而ElGamal算法是基于离散对数问题。与RSA算法相比，ElGamal算法哪怕是使用相同的.
对称加密与非对称加密算法
热门推荐
new9232的博客
01-24 3万+
对称加密算法又称为传统密码算法，加密密钥和解密密钥是相同的。对称加密算法要求通信双方在开始通信前，要首先商定一个用于加密和解密的密钥。算法的安全性就依赖于这个密钥，如果这个密钥被泄露了，就意味着通信不再安全。
深入浅出——Elgamal非对称加密算法
weixin_42295969的博客
07-21 2033
1. 背景 在密码学中，ElGamal加密算法是一个基于迪菲-赫尔曼密钥交换的非对称加密算法，它在1985年由塔希尔·盖莫尔提出 。 EIGamal公开密钥密码体制是基于有限域中离散对数间题的难解性。它所根据的原理是：求解离散对数是困难的，而其逆运算可以应用平方乘的方法有效的计算出来。在相应的群 G中，指数函数是单向函数，所谓单向函数它的意义就是在有限的算力之下如果你希望逆向去求的话是不可能做到的 2. 加密方案 三个部分，分为秘钥生成，加密以及解密 核心加密解密成分就是通过(gx)y=(gy)x=gxy{
elgamal算法_ElGamal
weixin_27064845的博客
12-23 2467
ElGamal算法是一种常见加密算法, 与Diffie-Hellman算法有密切关联。该算法安全性依赖于计算有限域上离散对数难题：求解离散对数(目前)是困难的,其逆运算指数运算简单。 算法思路:假设有2个用户Alice 和 Bob，Bob欲使用ElGamal加密算法向Alice发送信息。对于Alice,首先要选择一个素数q, α是素数q的本原根。 [本原根的概念对应模q乘法群(需循环群)中的生成元...
Java Language——数据加密算法和编码方式
一叶知秋的博客
05-23 4867
数据加密是计算机系统对信息进行保护的一种最可靠的办法。它利用密码技术对信息进行加密，实现信息隐蔽，从而起到保护信息的安全的作用。本文主要介绍了几种常见的数据加密算法（对称密码算法/非对称密码算法）的 Java 实现和常见编码方式的使用。
ElGamal加密及其乘法同态
watqw的博客
10-13 5075
ElGamal加密方案 ElGamal加密方案是基于离散对数问题的公钥加密方案。其加密运算是随机的，即同一明文在相同密钥加密下，所得到的密文是不一样的。 离散对数问题 实例：对于乘法群G，其中一个n阶元素alpha，有beta属于由alpha生成的子群。 问题：找到唯一的整数a，0<=a<=n-1，满足： 将这个整数a记作，称为beta的离散对数。 求解离散对数（可能）是困难的，目前没有已知的多项式时间算法的解决，而其逆，即指数运算，可以通过模重复平方算法快速求解。 所以，可.
非对称加密技术 - DH算法
HackerSaillen的专栏
04-11 2121
DH算法是非对称加密算法的鼻祖，为非对称加密算法奠定了基础。主要用途是进行密钥交换。DH算法历史1976年非对称加密算法思想被提出，但是当时并没有给出具体算法和方案，因为当时没有研究出单向函数（也就是信息摘要算法还没出现），但是IEEE的期刊（作者：W.Diffie和M.Hellman）中给出了通信时双方如何通过信息交换协商密钥的算法，也就是DH算法。DH算法的目的仅在于双方在安全的环境下协商一个加
密码学专题 非对称加密算法指令概述 DH算法指令
CHYabc123456hh的博客
12-06 3448
DH概述 用于密钥交换的公开算法，广泛应用于各种安全协议 SSL协议同样支持DH算法 DH算法使用之前需要预先共享两个参数，本原元g和模n，这两个参数影响到算法的安全性，因此需要预先生成并检测其安全性 生成这些必要参数和管理这些参数的指令dhparam、gendh和dh 注意事项：DH算法本身不定义加密和解密的操作，只是单纯的提供一个安全交换或者生成共同数据加密密钥(用于对称加密的会话密钥)的方法 OpenSSL也没有提供利用DH进行加密和解密操作的指令和生成DH的指令，只提供了生成DH参数和对

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值