精华内容
下载资源
问答
  • javaElGamal算法实现

    2018-04-25 12:28:00
    该class通过调用ElGamalCoder.getKeyFile()方法生成公钥和私钥,公钥文件为publicKey,私钥文件为privateKey。 加密:String miwen = ElGamalCoder.decrypt("这里传入明文", "publicKey");...
  • 最近在搞一个使用ElGamal算法的demo,遇到了不少大坑,记录下来。关于ElGamal的使用,参考该链接:非对称加密算法-ElGamal算法他这个使用,由于jdk并没有实现ElGamal,所以得引用两个jar包:bcprov-jdk16-145.jar 和...

    最近在搞一个使用ElGamal算法的demo,遇到了不少大坑,记录下来。

    关于ElGamal的使用,参考该链接:非对称加密算法-ElGamal算法

    他这个使用,由于jdk并没有实现ElGamal,所以得引用两个jar包:bcprov-jdk16-145.jar 和commons-codec-1.11.jar,而这也成为了后来的万恶之源。

    原链接的前辈写的代码是这样的:

    //初始化密钥  
            //生成密钥对  
            Map<String,Object> keyMap=ElGamalCoder.initKey();  
            //公钥  
            byte[] publicKey=ElGamalCoder.getPublicKey(keyMap);  
              
            //私钥  
            byte[] privateKey=ElGamalCoder.getPrivateKey(keyMap);  
            System.out.println("公钥:/n"+Base64.encodeBase64String(publicKey));  
            System.out.println("私钥:/n"+Base64.encodeBase64String(privateKey));  
              
            System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方,开始进行加密数据的传输=============");  
            String str="ElGamal密码交换算法";  
            System.out.println("/n===========甲方向乙方发送加密数据==============");  
            System.out.println("原文:"+str);  
              
            //乙方使用公钥对数据进行加密  
            byte[] code2=ElGamalCoder.encryptByPublicKey(str.getBytes(), publicKey);  
            System.out.println("===========乙方使用公钥对数据进行加密==============");  
            System.out.println("加密后的数据:"+Base64.encodeBase64String(code2));  
              
              
            //甲方使用私钥对数据进行解密  
            byte[] decode2=ElGamalCoder.decryptByPrivateKey(code2, privateKey);  
              
            System.out.println("甲方解密后的数据:"+new String(decode2));

    密钥生成、加解密都在一个函数里面,这样子运行的时候没问题,也不存在乱码,因为是直接用的byte[]数组作为明文和密文进行加解密。但是,我的需求是需要在不同的地方进行公私钥的生成、加密、解密,于是就出现了两个问题:

    1.不将byte数组作为参数,而是将byte数组序列化为字符串,将字符串作为密钥传入进行加密解密的时候会出现解密结果是乱码的问题。

    解决办法:我没有找到合适的序列化的方法将生成的byte[]格式的公私钥序列化为正确的字符串,最后使用文件的方式解决:将byte[]用字节流写入文件,生成两个文件:publicKey和privateKey,使用的时候将文件中的二进制数据读取为byte[],使用这个byte[]作为参数传入,就不会产生乱码的问题。

    2.我写了三个函数将密钥生成、加密和解密分开,单独调用的时候报如下异常:

    Exception in thread "main" java.security.NoSuchAlgorithmException: ElGamal KeyFactory not available
    	at java.security.KeyFactory.<init>(Unknown Source)
    	at java.security.KeyFactory.getInstance(Unknown Source)
    	at com.sta.Util.ElGamalCoder.encryptByPublicKey(ElGamalCoder.java:104)
    	at com.sta.Util.ElGamalCoder.decrypt(ElGamalCoder.java:211)
    	at com.sta.Util.ElGamalCoder.main(ElGamalCoder.java:249)
    
    我们来看一下这句话:
    ElGamal KeyFactory not available

    这句话产生的原因就是上面说的,JDK并没有自己实现ElGamal算法,需要添加额外的支持,链接中的前辈写的代码由于是密钥生成、加解密都在一个函数中调用,因此在密钥生成时写的添加ElGamal支持的代码对加解密方法同样生效,但是将加解密和密钥生成分开,分别调用时,KeyFactory就会没有ElGamal的支持,因此抛出上面的异常,具体细节可参考该链接: java中的秘钥工厂KeyFactory

    所以我将前辈写的代码做了如下改动:

    /**
    	 * 公钥加密
    	 * @param data待加密数据
    	 * @param key 密钥
    	 * @return byte[] 加密数据
    	 * */
    	public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{
    		//------------------以下是改动,添加ElGamal支持------------------------------------------------
                    //加入对BouncyCastle支持
    		Security.addProvider(new BouncyCastleProvider());
    		AlgorithmParameterGenerator apg=AlgorithmParameterGenerator.getInstance(KEY_ALGORITHM);
    		//初始化参数生成器
    		apg.init(KEY_SIZE);
    		//生成算法参数
    		AlgorithmParameters params=apg.generateParameters();
    		//构建参数材料
    		DHParameterSpec elParams=(DHParameterSpec)params.getParameterSpec(DHParameterSpec.class);
                    //--------------------------------------------------------------------------------------------
                     //实例化密钥工厂
    		KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
    		//初始化公钥
    		//密钥材料转换
    		X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
    		//产生公钥
    		PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
    		
    		//数据加密
    		Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
    		cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    		return cipher.doFinal(data);
    	}

    解密方法同理,添加上ElGamal支持的代码即可。

    另外代码中密钥长度为256位,在某些情况下密钥长度超过128

    位会报如下异常:NoSuchAlgorithmException,这个问题是美

    帝的出口限制导致的,解决办法如图:


    最后附我修改之后的ElGamalCoder.java:  该class通过调用ElGamalCoder.getKeyFile()方法生成公钥和私钥,公钥文件为publicKey,私钥文件为privateKey。

    加密:String miwen = ElGamalCoder.decrypt("这里传入明文", "publicKey"); //publicKey是公钥文件所在的路径(包括文件名)

    解密:String mingwen = ElGamalCoder.encrypt("这里传入加密之后的密文","privateKey");//privateKey是私钥文件所在路径

    java文件下载:ElGamalCoder.java

    -end-

    展开全文
  • Elgamal算法java实现

    千次阅读 2014-04-16 14:32:47
    曾经有位故人请在下帮助做此...,当初为使故人能够更容易的阅读代码,程序中则以static function的方式进行组织,此非JAVA的对像思想;请读者不要误解! /**  * author:zmhu  * QQ:4328335 , @阿胡Ahoo  */
    曾经有位故人请在下帮助做此程序,虽然故人已消失多年,QQ也被其列入黑名单,今天在电脑里偶然发现这个程序代码,分享于大家;望对学习有所帮助!,当初为使故人能够更容易的阅读代码,程序中则以static function的方式进行组织,此非JAVA的对像思想;请读者不要误解! 
    
    /**
     * author:zmhu

     * QQ:4328335 , @阿胡Ahoo
     */
    package elgamar;

    import java.math.BigInteger;
    import java.util.Random;
    import java.io.*;
    /**
     * @author zmhu
     */
    public class ElGamal
    {
     /**
      * 加密一个消息m(m为BigInteger类型) 并返回加密结果为一个BigInteger数组
      * @param m
      * @param p
      * @param b
      * @param g
      * @return
      */
     public static BigInteger [] encrypt(BigInteger m,BigInteger p,BigInteger b,BigInteger g)
     {
      //随机选取一个k gcd(k,p-1)=1 0<=k<p
      BigInteger [] rtn = {null,null};//定义一个BigInteger数组,存贮返回的加密对象C1,C2
      BigInteger k = ElGamal.getRandomk(p); //随机取满足条件的k
      //计算密文C1,C1
      BigInteger C1 = g.modPow(k, p);
      BigInteger C2 = m.multiply(b.modPow(k, p)).mod(p);
      //保存密文到对象中
      rtn[0] = C1;
      rtn[1] = C2;
      return rtn;
     }
     /**
      * 取随机数k
      * @param p
      * @return
      */
     public static BigInteger getRandomk(BigInteger p)
     {
      ///随机取一个与p-1互质的数k & 0<=k<p-1
      Random r = new Random();
      BigInteger k = null;
      while(true)
      {
       k = new BigInteger(p.bitLength()-1,r);//产生一0<=k<p-1的随机数
       if(k.gcd(p.subtract(BigInteger.ONE)).equals(BigInteger.ONE))
       {//如果随机数与p-1互质 则选取成功,返回随机数k
        break;
       }
      }
      return k;
     }
     /**
      * 取一个大的随机素数P,和P的生成元a
      * @param alpha 为该素数的比特位数
      * @return
      */
     public static BigInteger [] getRandomP(int alpha)
     {
      BigInteger rtn [] = {null,null};
      Random r = new Random();
      BigInteger p = null;
      BigInteger q = null;
      //选取一个安全素数Q, p = 2q+1 如果P为素数,选定成功
      while(true)
      {
       q = BigInteger.probablePrime(alpha, r);//new BigInteger(alpha,r); //取一个随机数q, r为随机数发生器 alpha 为想要得到随机数大小[2^alpha]p = 2^alpha
       if(q.bitLength() != alpha) //判断生成的随机数q<2^alpha 如果q<2^alpha 重新再生成一个随机数直到q>2^alpha
        continue;
       if(q.isProbablePrime(10)) //如果q为素数则再进一步计算生成元
       {
        p = q.multiply(new BigInteger("2")).add(BigInteger.ONE); // 选取一个安全素数P=2*Q+1 
        if(p.isProbablePrime(10)) //如果P为素数则选取成功 否则继续第一步
         break;
       }
      }
      //计算p 的乘法群 
      //在Zp中选择一个g != 1
      BigInteger g = null;
      while(true)
      {
       g = BigInteger.probablePrime(p.bitLength()-1, r);//new BigInteger(p.bitLength()-1,r);//从Zp*中随机取出一个元
       if(!g.modPow(BigInteger.ONE, p).equals(BigInteger.ONE) && !g.modPow(q, p).equals(BigInteger.ONE)) 
       {在Z*p中任选一元素a!=1,计算a^2 mod P 和a^Q mod P ,如它们都不等于1,则a是生成元,否则继续选取
        break;
       }
      }
      rtn[0] = p;
      rtn[1] = g;
      return rtn;
     }
     /**
      * 取随机数a
      * @param p
      * @return
      */
     public static BigInteger getRandoma(BigInteger p)
     {
      BigInteger a = null;
      Random r = new Random();
      a = new BigInteger(p.bitLength()-1,r);
      return a;
     }
     /**
      * 计算b的值
      * @param g
      * @param a
      * @param p
      * @return
      */
     public static BigInteger calculateb(BigInteger g,BigInteger a,BigInteger p)
     {
      BigInteger b = null;
      b = g.modPow(a, p);
      return b;
     }
     /**
      * 解密一个串返回值为一个BigInteger对象
      * @param C1
      * @param C2
      * @param a
      * @param p
      * @return
      */
     public static BigInteger decrypt(BigInteger C1,BigInteger C2,BigInteger a,BigInteger p)
     {
      BigInteger m = null;
      m = C2.multiply(C1.modPow(a.negate(), p)).mod(p);
      return m;
     }
     /**
      * 加密一个数字签名,其实就是加密一个字符串,消息m为一个字串,程序中是把消息m(String)转成一个byte数组,
      * 然后再把byte类型的数组再构造成一个BigInteger对象,使用encrypt方法加密
      * @param m
      * @param p
      * @param b
      * @param g
      * @return
      */
     public static BigInteger [] encryptSignature(String m,BigInteger p,BigInteger b,BigInteger g)
     {
      BigInteger [] rtn = {null,null};//定义一个BigInteger数组,存贮返回的加密对象C1,C2
      BigInteger message = new BigInteger(m.getBytes());//把字串转成一个BigInteger对象
      rtn = ElGamal.encrypt(message, p, b, g);//调用解密方法encrypt解密
      return rtn;
     }
     /**
      * 解密一个数字签名,传入先前加密结果,两个BigInteger的对象C1,C2
      * 程序使用先前的decrypt方法进行解密,把解密得到的结果(BigInteger对象),转化为一个byte的数组
      * 再把byte类型的数组还原为一个字串
      * @param C1
      * @param C2
      * @param a
      * @param p
      * @return
      */
     public static String decryptSignature(BigInteger C1,BigInteger C2,BigInteger a,BigInteger p)
     {
      BigInteger rtn = ElGamal.decrypt(C1, C2, a, p);//调用decrypt方法解密
      String str = new String(rtn.toByteArray());//把返回的结果还原成一个字串
      return str;
     }
     public static void main(String [] args)
     {
      BigInteger p = null; //随机数P
      BigInteger g = null; //P的生成元
      //BigInteger m = new BigInteger("11111111111111"); // 明文M 0<=m<p
      //System.out.println("明文:"+m);//输出
      BigInteger b = null; // 公钥<b,g,p>
      BigInteger a = null;//私钥<a,g,p> 0<a<p
      BigInteger [] rtn = {null,null}; 
      
      String signm = "";
      System.out.println("请输入消息M:");
      InputStream clav= System.in;
      BufferedReader rd = new BufferedReader(new InputStreamReader(clav));
      try {signm = rd.readLine();}
      catch(IOException e) {System.out.println(e.getMessage());}
      //System.out.println(new BigInteger(signm.getBytes()).bitLength());
      //System.exit(0);
      rtn = ElGamal.getRandomP(new BigInteger(signm.getBytes()).bitLength());//取得随机数P,和P的生成元g
      
      p = rtn[0];
      g = rtn[1];
      a = ElGamal.getRandoma(p);
      b = ElGamal.calculateb(g, a, p);
      //rtn = ElGamal.encrypt(m, p, b, g);
      //System.out.println("密文:"+rtn[0]+","+rtn[1]);
      //BigInteger dm = ElGamal.decrypt(rtn[0], rtn[1], a, p);
      //System.out.println("解密:"+dm);
      /数字签名
      
      

      System.out.println("原文:"+signm);
      byte[] mb = signm.getBytes();
      System.out.println("字节码构造的超大整数:"+new BigInteger(mb).toString());
      System.out.println("素数P:"+p);
      System.out.println("生成元:"+g);
      System.out.println("随机数a(私钥):"+a);
      System.out.println("b(公钥):"+b);
      //rtn = ElGamal.getRandomP(100);//取得随机数P,和P的生成元g
      //p = rtn[0];
      //g = rtn[1];
      a = ElGamal.getRandoma(p);
      b = ElGamal.calculateb(g, a, p);
      rtn = ElGamal.encryptSignature(signm, p, b, g);
      System.out.println("密文:"+rtn[0]+","+rtn[1]);
      String designm = ElGamal.decryptSignature(rtn[0], rtn[1], a, p);
      mb = designm.getBytes();
      System.out.println("解密后的超大整数:"+new BigInteger(mb));
      System.out.println("解密:"+designm);
      
     }
    }
    展开全文
  • ElGamal算法大整数版本的实现 ElGamal加密体制是基于有限域上离散对数问题的公钥密码体制。 算法实现过程中,唯一的难点是如何寻找生成元。后来在网上找到求生成元的办法(根据欧拉定理和拉格朗日定理,主要是利用...

    [注:本文为本人本科期间实验成果,仅供参考,拷贝以及转载引起的后果自负!]

    ElGamal算法大整数版本的JAVA实现

    ElGamal加密体制是基于有限域上离散对数问题的公钥密码体制。

    算法实现过程中,唯一的难点是如何寻找生成元。后来在网上找到求生成元的办法(根据欧拉定理和拉格朗日定理,主要是利用安全素数的概念)。

    算法执行结果:



    JAVA代码如下:

    import java.math.BigInteger;
    import java.util.ArrayList;
    import java.util.Random;
    import java.util.Scanner;
    
    public class ElGamal {
    	static BigInteger p, g; // 大素数和本原元
    	static BigInteger C, C1;// 密文
    
    	public static double entropy(String mess) {
    		ArrayList<Node> jieguo = new ArrayList<Node>();
    		jieguo.clear();
    		double num = mess.length();
    		for (int i = 0; i < num; i++) {
    			boolean flag_exit = true;
    			for (int j = 0; j < jieguo.size(); j++) {
    				if (jieguo.get(j).getalpha() == mess.charAt(i)) {
    					flag_exit = false;
    					jieguo.get(j).setp(jieguo.get(j).getp() + 1 / num);
    				}
    			}
    			if (flag_exit)
    				jieguo.add(new Node(1 / num, mess.charAt(i)));
    		}
    		/** 计算熵 */
    		double entropy = 0;
    		for (int i = 0; i < jieguo.size(); i++) {
    			double p1 = jieguo.get(i).getp();
    			entropy += (-p1 * (Math.log(p1) / Math.log(2)));
    		}
    		return entropy;
    	}
    
    	/** 取一个大的随机素数P,和P的生成元a */
    	public static void getRandomP(int alpha) {
    		Random r = new Random();
    		BigInteger q = null;
    		while (true) {
    			q = BigInteger.probablePrime(alpha, r);
    			if (q.bitLength() != alpha)
    				continue;
    			if (q.isProbablePrime(10)) // 如果q为素数则再进一步计算生成元
    			{
    				p = q.multiply(new BigInteger("2")).add(BigInteger.ONE);
    				if (p.isProbablePrime(10)) // 如果P为素数则OK~,否则继续
    					break;
    			}
    		}
    		while (true) {
    			g = BigInteger.probablePrime(p.bitLength() - 1, r);
    			if (!g.modPow(BigInteger.ONE, p).equals(BigInteger.ONE)
    					&& !g.modPow(q, p).equals(BigInteger.ONE)) {
    				break;
    			}
    		}
    	}
    
    	/** 取随机数a */
    	public static BigInteger getRandoma(BigInteger p) {
    		BigInteger a;
    		Random r = new Random();
    		a = new BigInteger(p.bitLength() - 1, r);
    		return a;
    	}
    
    	/** 计算密钥的值 */
    	public static BigInteger calculatey(BigInteger x, BigInteger g, BigInteger p) {
    		BigInteger y;
    		y = g.modPow(x, p);
    		return y;
    	}
    
    	/** 加密 */
    	public static void encrypt(String m, BigInteger y, BigInteger p,
    			BigInteger g) {
    		BigInteger message = new BigInteger(m.getBytes());// 把字串转成一个BigInteger对象
    		Random r = new Random();
    		BigInteger k;
    		while (true) {
    			k = new BigInteger(p.bitLength() - 1, r);// 产生一0<=k<p-1的随机数
    			if (k.gcd(p.subtract(BigInteger.ONE)).equals(BigInteger.ONE)) {// 如果随机数与p-1互质
    																			// 则选取成功,返回随机数k
    				break;
    			}
    		}
    		// 计算密文C,C1
    		C = g.modPow(k, p);
    		C1 = message.multiply(y.modPow(k, p)).mod(p);
    		// 保存密文到对象中
    
    	}
    
    	/** 解密 */
    	public static String decrypt(BigInteger C, BigInteger C1, BigInteger a,
    			BigInteger p) {
    		BigInteger scy = C1.multiply(C.modPow(a.negate(), p)).mod(p);
    		String str = new String(scy.toByteArray());// 把返回的结果还原成一个字串
    		return str;
    	}
    
    	public static void main(String[] args) {
    		BigInteger y, x; // 随机数 P,g是P的生成元,公钥<y,g,p>,私钥<x,g,p> 0<a<p
    		System.out.println("请输入明文:");
    
    		while (true) {
    			Scanner input = new Scanner(System.in);
    			String str = input.nextLine();
    			ElGamal.getRandomP(new BigInteger(str.getBytes()).bitLength());// 取得随机数P,和P的生成元g
    			x = ElGamal.getRandoma(p);
    			y = ElGamal.calculatey(x, g, p);
    			System.out.println("计算机随机生成的素数P:" + p);
    			System.out.println("求得其生成元:" + g);
    			System.out.println("私钥<x,g,p>为: (" + x + "," + g + "," + p + ")");
    			System.out.println("公钥<y,g,p>为:" + "(" + y + "," + g + "," + p
    					+ ")");
    			x = ElGamal.getRandoma(p);
    			y = ElGamal.calculatey(x, g, p);
    			ElGamal.encrypt(str, y, p, g);
    			System.out
    					.println("计算得到的明文熵:" + entropy(str.getBytes().toString()));
    			System.out.println("加密后的密文为:" + C + "," + C1);
    			System.out.println("计算得到的密文熵:"
    					+ entropy(C.toString().concat(C1.toString())));
    			String designm = ElGamal.decrypt(C, C1, x, p);
    			System.out.println("解密得到明文为:" + designm);
    		}
    	}
    }

    2.Node.java

    public class Node {
    	private double p;// 记录概率
    	private char alpha;// 记录对应的字母
    
    	public Node(double p, char alpha) {
    		this.p = p;
    		this.alpha = alpha;
    	}
    
    	public void setp(double p) {
    		this.p = p;
    	}
    
    	public void setalpha(char a) {
    		this.alpha = a;
    	}
    
    	public double getp() {
    		return p;
    	}
    
    	public char getalpha() {
    		return alpha;
    	}
    }


    展开全文
  • Java实现ElGamal算法签名

    千次阅读 2018-06-20 23:09:10
    Elgamal.java package elgamal; import java.math.BigInteger; import java.lang.Math; import java.util.Random; import java.io.*; public class ElGamal { private static final BigIn...

    今晚有点迟了,具体说明明天再来补
    Elgamal.java

    package elgamal;
    
    import java.math.BigInteger;
    import java.lang.Math;
    import java.util.Random;
    import java.io.*;
    
    public class ElGamal {
    
        private static final BigInteger ONE = BigInteger.ONE;
    
        // 获取随机大素数
        public static BigInteger getPrime(int bitLenth) {
            BigInteger p = BigInteger.probablePrime(bitLenth, new Random());
            while(!p.isProbablePrime(6)) {
                p.nextProbablePrime();
            }
            return p;
        }
    
        // 枚举遍历求生成元g
        public static BigInteger getG(BigInteger p, BigInteger p_MinusOne) {
            BigInteger g = null;
    
            outterLoop: for (int i = 2; i < 50; i++) {
                for (int x1 = 1; x1 <= Integer.valueOf(p_MinusOne.toString()); x1++) {
                    String str1 = String.valueOf(i);
                    String str2 = String.valueOf(x1);
                    BigInteger tmp1 = new BigInteger(str1);
                    BigInteger tmp2 = new BigInteger(str2);
                    if (tmp1.modPow(tmp2, p).compareTo(ONE) == 0 && tmp2.compareTo(p_MinusOne) == -1) {
                        break;
                    } else if (tmp1.modPow(tmp2, p).compareTo(ONE) == 0 && tmp2.compareTo(p_MinusOne) == 0) {
                        g = tmp1;
                        break outterLoop;
                    }
                }
            }
    
            return g;
        }
    
    }

    ReadFile.java

    package elgamal;
    
    import java.io.BufferedReader;  
    import java.io.File;  
    import java.io.FileReader;
    import java.io.IOException;  
    
    public class ReadFile {  
        public static String txt2String(File file) throws IOException{  
    
            StringBuilder result = new StringBuilder(); 
            // 建立数据的输入通道  
            FileReader fileReader = new FileReader(file);  
            //建立缓冲字符数组读取文件数据  
            char[] buf = new char[1024];  
            int length = 0 ;
    
            while((length = fileReader.read(buf))!=-1){  
                result.append(new String(buf,0,length));  
            }  
    
            return result.toString();
    
            /*StringBuilder result = new StringBuilder();  
            try{  
                BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件  
                String s = null;  
                while((s = br.readLine())!=null){//使用readLine方法,一次读一行  
                    result.append(System.lineSeparator()+s);  
                }  
                br.close();      
            }catch(Exception e){  
                e.printStackTrace();  
            }  
            return result.toString();  */
        }  
    
        public static void main(String[] args) throws IOException{  
            File file = new File("H:/test.txt");  
            System.out.println(txt2String(file));  
        }  
    
    }  
    

    Main.java

    package elgamal;
    
    import java.io.File;
    import java.io.IOException;
    import java.math.BigInteger;
    import java.util.Random;
    
    public class Main {
    
        private static final BigInteger ONE = BigInteger.ONE;
    
        public static void main(String[] args) throws IOException {
            File file = new File("H:/test.txt");
    
            String m = ReadFile.txt2String(file);
            System.out.println("消息m = " + m);
    
            int length = m.length();
    
            // 随机的大素数p
            BigInteger p = ElGamal.getPrime(length);
            System.out.println("p = " + p.toString());
    
            // 下面计算时用到的p-1
            BigInteger p_MinusOne = p.subtract(ONE);
            System.out.println("p-1 = " + p_MinusOne.toString());
    
            // 枚举遍历求生成元g
            BigInteger g = null;
            g = ElGamal.getG(p, p_MinusOne);
            System.out.println("g = " + g.toString());
    
            // 随机数x,满足区间[2,p-1)
            BigInteger x = new BigInteger(length,new Random());
            System.out.println("x = " + x.toString());
    
            // y ≡ g^x( mod p )
            BigInteger y = g.modPow(x,p);
            System.out.println("y = " + y.toString());
    
            // 随机的大素数k,满足区间[2,p-1)
            BigInteger k = ElGamal.getPrime(length);
            System.out.println("k = " + k.toString());
    
            // k的逆元
            BigInteger k_Reverse = k.modInverse(p_MinusOne);
            System.out.println("k对p-1的逆元 = " + k_Reverse.toString());
    
            // a ≡ g^k ( mod p )
            BigInteger a = g.modPow(k,p);
            System.out.println("a = " + a.toString());
    
            // h(m)
            int hm = Math.abs(m.hashCode());
            String temp = String.valueOf(hm);
            String hmm = temp.substring(1, 5);
            BigInteger h_m = new BigInteger(hmm);
            System.out.println("h(m) = " + h_m.toString());
    
            BigInteger tmp1 = h_m.subtract(x.multiply(a));
            System.out.println("tmp1 = " + tmp1.toString());
    
            BigInteger tmp2 = tmp1.multiply(k_Reverse);
            System.out.println("tmp2 = " + tmp2.toString());
    
            BigInteger b = tmp2.mod(p_MinusOne);
            System.out.println("b = " + b.toString());
    
            System.out.println("消息m的数字签名为: " + a.toString() + "," + b.toString());
    
            BigInteger left = y.pow(a.intValue()).multiply(a.pow(b.intValue())).mod(p);
            System.out.println("left = " + left.toString());
    
            int unsignedH_m = h_m.intValue();
            if(unsignedH_m < 0) {
                unsignedH_m = -unsignedH_m;
            }
            BigInteger right = g.pow(unsignedH_m).mod(p);
    
            System.out.println("right = " + right.toString());
    
        }
    
    }
    
    展开全文
  • ElGamal实现加密算法

    千次阅读 2017-10-04 19:38:43
    1.新建一个java项目,里面新建一个java类,加入要...2.ElGamal.java里面的代码如下所示: import java.security.AlgorithmParameterGenerator; import java.security.AlgorithmParameters; import java.security.KeyPa
  • ElGamal签名算法实现 学校的课程设计作业。 要用的话自取。 不得不说,学校的老师太没有B树了。 验收根本不看你的代码,说你的报告贴那么多代码干嘛,不写汉字领导检查怎么看的懂。 简直无语,呵呵哒。
  • ElGamal算法1. 算法概述模型分析 1. 算法概述 ElGamal算法和ECC算法基于离散对数问题建立。与典型非对称加密算法RSA算法相比,ElGamal算法则被称为常用非对称加密算法。 ElGamal既可用于加密,又可用于数字签名,是...
  • 数字签名中的elgamal算法

    热门讨论 2011-05-09 18:28:55
    本压缩包中是用C编写的ELGAMAL加密算法
  • [JAVA加解密]DES,AES,PBE,DH,RSA,ElGamal算法实现及DataServlet实例
  • elgamal算法两种算法One of the influences I remember in considering software development, was my sister telling me I would be good at it because I’m ‘a really good problem solver’. We enjoyed ...
  • RSA、MD5 字符串、MD5文件、DES、ELGamal等加密算法实现,以及RSA模拟数字签名过程(工程Crypto和RSASignature),全部用GUI展现(NetBean6.5的Swing库),要求JDK1.5+,读者可以直接运行dist目录下的jar文件,一目了然...
  • Elgamal数字签名

    2015-10-07 14:13:42
    Elgamal数字签名的JAVA代码,比较简单,希望有用
  • 主要为大家详细介绍了eclipse实现ElGamal数字签名,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • ElGamal加密由三部分组成:密钥生成器,加密算法和解密算法。 密钥生成 密钥生成器的工作方式如下: 爱丽丝用生成器g生成q阶循环群G的有效描述。 有关此组所需属性的讨论,请参见下文。 爱丽丝从{1,…,q − 1}中...
  • ELGamal密码是除了RSA之外最有代表性的公开密钥密码之一,它的安全性建立在离散对数问题的困难性之上,是一种公认安全的公钥密码。 我们再来回顾下离散对数问题: 设p为素数,若存在一个正整数α,使得α、α2、......
  • [JAVA加解密]RSA算法、ElGamal算法

    千次阅读 2015-01-27 12:02:57
    一、RSA算法: 1、简介:RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们...
  • ElGamal算法 ElGamalCoder ElGamalCoderTest 参考资料 本系列其他文章 ElGamal算法 ElGamal算法,是一种较为常见的加密算法,它是基于1985年提出的公钥密码体制和椭圆曲线加密体系。百度百科 就像之前说的...
  • 1.对称加密与非对称加密概述 关于对称加密与非对称加密的概念这里...但是由于算法复杂,使得非对称算法加解密速度没有对称算法加解密的速度快。 对称密钥体制中只有一种密钥,并且是非公开的。如果要解密就得让对...
  • ElGamal算法的基本原理及实现

    千次阅读 2019-09-21 06:56:25
    1)m = b * a^(-x) mod p 注解:ba^(-x) mod p Ξ m * y^k * g^(-xk) Ξ m * g^(xk) * g^(-xk) Ξ m 加密及解密的实现: 1 import java.util.ArrayList; 2 3 public class Main { 4 static ArrayList suArr = new ...
  • BGN是一种同态加密方案,是Boned ...和传统的仅能支持单同态的elgamal和paillier加密方案不一样,BGN能够同时支持加同态和一次乘同态运算。 BGN的实现我们主要使用JAVA中的大整数math.BigInteger类以及双线性库JPBC实现
  • 这里写自定义目录标题算法原理代码 算法原理 代码 package com.example.secureserver.encryption; import org.bouncycastle.jce.provider.BouncyCastleProvider; import javax.crypto.Cipher; import javax.crypto...
  • 1、ElGamal算法和ECC算法基于离散对数问题 2、这个是一个单向的过程。虽然密钥对构造简单,但是只是乙方向另外一方单向传送数据进行加解密,不能反向操作 3、这里只有“公钥加密、私钥解密”这个过程 4、...
  • 加密分配 / 加密协议 / 第 4 天 / Elgamal: ================================================== ====================================== 任务是实施 Elgamal 签名程序。 实现了以下功能: 密钥生成 加密/解密...
  • 非对称加密算法-DH,RSA,ElGamal

    千次阅读 2017-02-09 15:13:37
    1.非对称加密算法--DH 参考的文章:http://blog.csdn.net/sunny_sailor/article/details/7445649 DH的流程: 1.甲方构建密钥对儿,将公钥公布给乙方,将私钥保留;双方约定数据加密算法;乙方通过甲方公钥构建密钥...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 850
精华内容 340
关键字:

elgamal算法java

java 订阅