信息计算2019-1易称清

19信计易称清201

4月22号截图

19信计易称清201

4月29号截图

19信计易称清201

5月3号截图

19信计易称清201

1. package test;
   
2. 
   
3. import java.math.BigInteger;
   
4. public class Prime {
   
5.         public boolean sushu(double n) {
   
6.                 // 判断素数
   
7.                 boolean isPrime = true;
   
8.                 if (n > 2) {
   
9. 
   
10.                         if (n % 2 == 0) {
    
11.                                 isPrime = false;
    
12.                         } else {
    
13.                                 for (int i = 3; i <= (int) Math.sqrt(n); i += 2) {
    
14.                                         if (n % i == 0) {
    
15.                                                 isPrime = false;
    
16.                                                 break;
    
17.                                         }
    
18.                                 }
    
19.                         }
    
20. 
    
21.                 }
    
22.                 return isPrime;
    
23.         }
    
24. 
    
25.         private static final BigInteger ZERO = BigInteger.ZERO;
    
26.         private static final BigInteger ONE = BigInteger.ONE;
    
27.         private static final BigInteger TWO = new BigInteger("2");
    
28.         private static final int ERR_VAL = 100;
    
29. 
    
30.         public BigInteger nextPrime(BigInteger start) {
    
31.                 // 产生一个比给定大整数 start 大的素数，错误率低于 1/2 的 ERR_VAL 次方
    
32.                 if (isEven(start))
    
33.                         start = start.add(ONE);
    
34.                 else
    
35.                         start = start.add(TWO);
    
36.                 if (start.isProbablePrime(ERR_VAL))  //判断start有没有可能是素数
    
37.                         return (start);
    
38.                 else
    
39.                         // 采用递归方式
    
40.                         return (nextPrime(start));
    
41.         }
    
42. 
    
43.         private static boolean isEven(BigInteger n) {
    
44.                 // 测试一个大整数是否为偶数
    
45.                 return (n.mod(TWO).equals(ZERO));
    
46.         }
    
47. 
    
48.         public BigInteger bigRandom(int numDigits) {
    
49.                 // 产生一个随机大整数，各位上的数字都是随机产生的，首位不为 0
    
50.                 StringBuffer s = new StringBuffer("");
    
51.                 for (int i = 0; i < numDigits; i++)
    
52.                         if (i == 0)
    
53.                                 s.append(randomDigit(false));
    
54.                         else
    
55.                                 s.append(randomDigit(true));
    
56.                 return (new BigInteger(s.toString()));
    
57.         }
    
58. 
    
59.         private StringBuffer randomDigit(boolean isZeroOK) {
    
60.                 // 产生一个随机的数字（字符串形式的），isZeroOK 决定这个数字是否可以为 0
    
61.                 int index;
    
62.                 if (isZeroOK)
    
63.                         index = (int) Math.floor(Math.random() * 10);
    
64.                 else
    
65.                         index = 1 + (int) Math.floor(Math.random() * 9);
    
66.                 return (digits[index]);
    
67.         }
    
68. 
    
69.         private static StringBuffer[] digits = { new StringBuffer("0"),
    
70.                         new StringBuffer("1"), new StringBuffer("2"),
    
71.                         new StringBuffer("3"), new StringBuffer("4"),
    
72.                         new StringBuffer("5"), new StringBuffer("6"),
    
73.                         new StringBuffer("7"), new StringBuffer("8"), new StringBuffer("9") };
    
74. 
    
75.         public static void main(String[] args) {
    
76. 
    
77.         }
    
78. }
    
79. 
    
80. ********************************************************
    
81. ************************************************************************************
    
82. *******************************************************************************************************
    
83. package test;
    
84. 
    
85. import java.math.BigInteger;
    
86. import java.util.Scanner;
    
87. 
    
88. public class test0511{
    
89.         static BigInteger x, y;
    
90. 
    
91.         public static boolean fun(BigInteger x, BigInteger y) {
    
92.                 BigInteger t;
    
93.                 while (!(y.equals(new BigInteger("0")))) {
    
94.                         t = x;
    
95.                         x = y;
    
96.                         y = t.mod(y);
    
97.                 }
    
98.                 if (x.equals(new BigInteger("1")))
    
99.                         return false;
    
100.                 else
     
101.                         return true;
     
102.         }
     
103. 
     
104.         public static BigInteger siyao(BigInteger a, BigInteger b) {
     
105.                 BigInteger temp;
     
106.                 if (b.equals(new BigInteger("0"))) {
     
107.                         x = new BigInteger("1");
     
108.                         y = new BigInteger("0");
     
109.                         return x;
     
110.                 }
     
111.                 siyao(b, a.mod(b));
     
112.                 temp = x;
     
113.                 x = y;
     
114.                 y = temp.subtract((a.divide(b).multiply(y)));
     
115.                 return x;
     
116.         }
     
117. 
     
118.         public static void main(String[] args) {
     
119.                 BigInteger p = null;
     
120.                 BigInteger e, d, n, t, c;
     
121.                 BigInteger q = null;
     
122.                 for (int i = 0; i < 2; i++) {// 生成p,q
     
123.                         int numDigits;
     
124.                         Prime pri = new Prime();
     
125.                         numDigits = Integer.parseInt("10");
     
126.                         BigInteger start = pri.bigRandom(numDigits);// 生成一个十位的大数
     
127.                         BigInteger big = pri.nextPrime(start);// 求出比start大的素数
     
128.                         if (i == 0)
     
129.                                 p = big; // 把第一次生成的数赋值给p
     
130.                         else
     
131.                                 q = big; // 把第二次生成的数赋值给q
     
132.                 }
     
133.                
     
134.                 Scanner sc = new Scanner(System.in); // 键盘输入明文
     
135.                 n = p.multiply(q); // 求出φ(n)
     
136.                 t = p.subtract(new BigInteger("1")).multiply( // 求出φ(n)=t=(p-1)*(q-1)
     
137.                                 q.subtract(new BigInteger("1")));
     
138.                 int numDigits;
     
139.                 Prime pri = new Prime();
     
140.                 numDigits = Integer.parseInt("10");
     
141.                 BigInteger start = pri.bigRandom(numDigits);
     
142.                 BigInteger big = pri.nextPrime(start); // 找出一个质数e
     
143.                 e = big;
     
144.                 // 求出私钥d
     
145.                 d = siyao(e, t);
     
146.                 System.out.println("Produces 2 prime numbers");
     
147.                 System.out.println("p:"+p);
     
148.                 System.out.println("q:"+q);
     
149.                 System.out.println("n=p*q:"+n);
     
150.                 System.out.println("e:"+e);
     
151.                 System.out.println("φ(n)=(p-1)*(q-1):"+t);
     
152.                 System.out.println("public key："+e);
     
153.                 System.out.println("privil key："+d);
     
154.                 System.out.println("give message：");
     
155.                 String mess = sc.nextLine();
     
156.                 BigInteger m = new BigInteger(mess.getBytes());
     
157.                 System.out.println("public Large integers：" + m);
     
158.                 c = m.modPow(e, n);
     
159.                 System.out.println("privil large intergars：" + c);
     
160.                 m = c.modPow(d, n);
     
161.                 System.out.println("Decryption yields large integers in plaintext：" + c);
     
162.                 String str = new String(m.toByteArray());
     
163.                 System.out.println("Decryption yields the plaintext :" + str);
     
164.         }
     
165. 
     
166. }
     

复制代码

19信计易称清201

大数RSA

1. package RSA2022;
   
2. import java.math.BigInteger;
   
3. import java.util.ArrayList;
   
4. import java.util.Scanner;
   
5. 
   
6. public class RSA {
   
7.         static BigInteger x, y;
   
8.          
   
9.         public static boolean fun(BigInteger x, BigInteger y) {
   
10.                 BigInteger t;
    
11.                 while (!(y.equals(new BigInteger("0")))) {
    
12.                         t = x;
    
13.                         x = y;
    
14.                         y = t.mod(y);
    
15.                 }
    
16.                 if (x.equals(new BigInteger("1")))
    
17.                         return false;
    
18.                 else
    
19.                         return true;
    
20.         }
    
21. 
    
22.         public static BigInteger siyue(BigInteger a, BigInteger b) {
    
23.                 BigInteger temp;
    
24.                 if (b.equals(new BigInteger("0"))) {
    
25.                         x = new BigInteger("1");
    
26.                         y = new BigInteger("0");
    
27.                         return x;
    
28.                 }
    
29.                 siyue(b, a.mod(b));
    
30.                 temp = x;
    
31.                 x = y;
    
32.                 y = temp.subtract((a.divide(b).multiply(y)));
    
33.                 return x;
    
34.         }
    
35. 
    
36.         public static double entropy(String mess) {
    
37.                 ArrayList<Node> jieguo = new ArrayList<Node>();
    
38.                 jieguo.clear();
    
39.                 double num = mess.length();
    
40.                 for (int i = 0; i < num; i++) {
    
41.                         boolean flag_exit = true;
    
42.                         for (int j = 0; j < jieguo.size(); j++) {
    
43.                                 if (jieguo.get(j).getalpha() == mess.charAt(i)) {
    
44.                                         flag_exit = false;
    
45.                                         jieguo.get(j).setp(jieguo.get(j).getp() + 1 / num);
    
46.                                 }
    
47.                         }
    
48.                         if (flag_exit)
    
49.                                 jieguo.add(new Node(1 / num, mess.charAt(i)));
    
50.                 }
    
51.                 /** 计算熵 */
    
52.                 double entropy = 0;
    
53.                 for (int i = 0; i < jieguo.size(); i++) {
    
54.                         double p1 = jieguo.get(i).getp();
    
55.                         entropy += (-p1 * (Math.log(p1) / Math.log(2)));
    
56.                 }
    
57.                 return entropy;
    
58.         }
    
59. 
    
60.         public static void main(String[] args) {
    
61.                 BigInteger p = null;
    
62.                 BigInteger e, d, n, t, c;
    
63.                 BigInteger q = null;
    
64.                 for (int i = 0; i < 2; i++) {
    
65.                         int numDigits;
    
66.                         Prime pri = new Prime();
    
67.                         try {
    
68.                                 numDigits = Integer.parseInt("15");
    
69.                         } catch (Exception e1) {
    
70.                                 numDigits = 128;
    
71.                         }
    
72.                         BigInteger start = pri.bigRandom(numDigits);
    
73.                         BigInteger big = pri.nextPrime(start);
    
74.                         if (i == 0)
    
75.                                 p = big;
    
76.                         else
    
77.                                 q = big;
    
78.                 }
    
79.                 Scanner input = new Scanner(System.in);
    
80.                 n = p.multiply(q);
    
81.                 t = p.subtract(new BigInteger("1")).multiply(
    
82.                                 q.subtract(new BigInteger("1")));
    
83.                 int numDigits;
    
84.                 Prime pri = new Prime();
    
85.                 try {
    
86.                         numDigits = Integer.parseInt("15");
    
87.                 } catch (Exception e1) {
    
88.                         numDigits = 128;
    
89.                 }
    
90.                 BigInteger start = pri.bigRandom(numDigits);
    
91.                 BigInteger big = pri.nextPrime(start);
    
92.                 e = big;
    
93.                 while (e.compareTo(t) == 1 || fun(e, t)) {
    
94.                         System.out.println("e不合要求，请重新产生" + (e.compareTo(t) == 1)
    
95.                                         + fun(e, t));
    
96.                         pri = new Prime();
    
97.                         try {
    
98.                                 numDigits = Integer.parseInt("15");
    
99.                         } catch (Exception e1) {
    
100.                                 numDigits = 128;
     
101.                         }
     
102.                         start = pri.bigRandom(numDigits);
     
103.                         big = pri.nextPrime(start);
     
104.                         e = big;
     
105.                 }
     
106.                 // 求出私钥d
     
107.                 d = siyue(e, t);
     
108.                 System.out.println("由计算机随机产生2个素数p,q，分别如下:");
     
109.                 System.out.println(p);
     
110.                 System.out.println(q);
     
111.                 System.out.println("计算得到的n:");
     
112.                 System.out.println(n);
     
113.                 System.out.println("计算得到的t:");
     
114.                 System.out.println(t);
     
115.                 System.out.println("随机产生的公钥：");
     
116.                 System.out.println(e);
     
117.                 System.out.println("由扩展的欧几里德算法求得私钥：");
     
118.                 System.out.println(d);
     
119.                 while (true) {
     
120.                         System.out.println("请输入明文：");
     
121.                         String mess = input.nextLine();
     
122.                         //
     
123.                         BigInteger m = new BigInteger(mess.getBytes());// 把字串转成一个BigInteger对象
     
124.                         System.out.println("明文的大整数表示形式：" + m);
     
125.                         /** 调用函数计算信息，统计信息 */
     
126.                         mess = m.toString();
     
127.                 //        
     
128.                         // 修改第一位，+1
     
129.                         c = m.modPow(e, n);// JAVA中的方法
     
130.                         System.out.println("密文的大整数表示形式：" + c);
     
131.                 //        
     
132.                         System.out.println("密文的字符串表示形式：" + new String(c.toByteArray()));
     
133.                         m = c.modPow(d, n);
     
134.                         System.out.println("解密得到明文的大整数表示形式：" + c);
     
135.                         String str = new String(m.toByteArray());// 把返回的结果还原成一个字串
     
136.                         System.out.println("解密得到明文为：" + str);
     
137.                 }
     
138.         }
     
139. 
     
140. }
     

复制代码

19信计易称清201

建立基于椭圆曲线的加密机制，需要找到类似RSA质因子分解或其他求离散对数这样的难题。而椭圆曲线上的已知G和xG求x，是非常困难的，此即为椭圆曲线上的的离散对数问题。此处x即为私钥，xG即为公钥。

椭圆曲线加密算法原理如下：

设私钥、公钥分别为k、K，即K = kG，其中G为G点。

公钥加密：　　选择随机数r，将消息M生成密文C，该密文是一个点对，即：　　C = {rG, M+rK}，其中K为公钥

私钥解密：　　M + rK - k(rG) = M + r(kG) - k(rG) = M　　其中k、K分别为私钥、公钥。

1. //曲线椭圆加密算法
   
2. public static void ec() throws InvalidKeyException, SignatureException, NoSuchAlgorithmException {
   
3.     //Create a key pair
   
4.     KeyPairGenerator keyGen = KeyPairGenerator.getInstance("EC");
   
5.     SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
   
6.     keyGen.initialize(256, random);
   
7. 
   
8.     KeyPair keypair = keyGen.genKeyPair();
   
9.     PrivateKey privateKey = keypair.getPrivate();
   
10.     PublicKey publicKey = keypair.getPublic();
    
11. 
    
12.     System.out.println("private key: " + Arrays.toString(privateKey.getEncoded()));
    
13.     System.out.println("public key: " + Arrays.toString(publicKey.getEncoded()));
    
14. 
    
15. 
    
16. 
    
17.     String input = "hello world";
    
18. 
    
19.     //签名算法
    
20.     Signature signer = Signature.getInstance("SHA256withECDSA");
    
21. 
    
22.     //用私钥初始化签名
    
23.     signer.initSign(privateKey);
    
24.     //用签名更新输入
    
25.     signer.update(input.getBytes());
    
26.     byte[] sign = signer.sign();
    
27. 
    
28.     //打印得到的签名， 可以将此签名传给第三方
    
29.     System.out.println("input is:  " + input);
    
30.     System.out.println("Sign: " + Arrays.toString(sign));
    
31. 
    
32. 
    
33.     //第三方用公钥初始化，用签名做验证， 返回true表示验证正确
    
34.     Signature verifier = Signature.getInstance("SHA256withECDSA");
    
35.     verifier.initVerify(publicKey);
    
36. 
    
37.     //第三方的数据abc，用签名来验证是否和数据一致
    
38.     String input_again = "hello world";
    
39.     verifier.update(input_again.getBytes());
    
40.     boolean checkResult = verifier.verify(sign);
    
41.     System.out.println("Sign result : " + checkResult);
    
42. }

复制代码